@blaxel/core 0.2.43-dev.196 → 0.2.43-dev.199

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

@@ -0,0 +1,3 @@
+import { Config } from "./settings.js";
+export declare function initialize(config: Config): void;
+export declare function authenticate(): Promise<void>;

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

@@ -0,0 +1,5 @@
+export declare const fs: any;
+export declare const os: any;
+export declare const path: any;
+export declare const dotenv: any;
+export declare function getWebSocket(): Promise<any>;

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

@@ -0,0 +1,5 @@
+type EnvVariables = {
+    [key: string]: string | undefined;
+};
+declare const env: EnvVariables;
+export { env };

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

@@ -0,0 +1 @@
+export declare function handleDynamicImportError(err: any): void;

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

@@ -0,0 +1,6 @@
+export declare function getAlphanumericLimitedHash(input: string, maxSize?: number): string;
+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/internal.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,25 @@
+interface LoggerInterface {
+    info: (message: string) => void;
+    debug: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+}
+/**
+ * Stringify an object with a limited depth
+ * @param obj The object to stringify
+ * @param maxDepth Maximum depth (default: 1)
+ * @param depth Current depth (internal use)
+ */
+export declare function stringify<T>(obj: T, maxDepth?: number, depth?: number): string;
+declare class Logger {
+    private logger;
+    constructor();
+    setLogger(logger: LoggerInterface): void;
+    parseArgs(args: unknown[]): string;
+    info(...message: unknown[]): void;
+    debug(...message: unknown[]): void;
+    warn(...message: unknown[]): void;
+    error(...message: unknown[]): void;
+}
+declare const logger: Logger;
+export { logger };

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

@@ -0,0 +1,6 @@
+declare let fs: typeof import("fs") | null;
+declare let os: typeof import("os") | null;
+declare let path: typeof import("path") | null;
+declare let dotenv: typeof import("dotenv") | null;
+export declare function getWebSocket(): Promise<any>;
+export { dotenv, fs, os, path };

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

@@ -0,0 +1,32 @@
+import { Credentials } from "../authentication/credentials.js";
+export type Config = {
+    proxy?: string;
+    apikey?: string;
+    workspace?: string;
+};
+declare class Settings {
+    credentials: Credentials;
+    config: Config;
+    private _version;
+    constructor();
+    setConfig(config: Config): void;
+    get env(): string;
+    get baseUrl(): string;
+    get runUrl(): string;
+    get workspace(): string;
+    get authorization(): string;
+    get token(): string;
+    get version(): string;
+    get headers(): Record<string, string>;
+    get name(): string;
+    get type(): string;
+    get runInternalHostname(): string;
+    get runInternalProtocol(): string;
+    get blCloud(): boolean;
+    get workspaceId(): string;
+    get generation(): string;
+    get loggerType(): string;
+    authenticate(): Promise<void>;
+}
+export declare const settings: Settings;
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,18 @@
+import './common/autoload';
+export * from "./agents/index.js";
+export * from "./client/client.js";
+export * from "./common/autoload.js";
+export * from "./common/env.js";
+export * from "./common/node.js";
+export * from "./common/errors.js";
+export * from "./common/internal.js";
+export * from "./common/logger.js";
+export * from "./common/settings.js";
+export * from "./jobs/index.js";
+export * from "./mcp/index.js";
+export * from "./models/index.js";
+export * from "./sandbox/index.js";
+export * from "./telemetry/telemetry.js";
+export * from "./tools/index.js";
+export * from "./tools/types.js";
+export * from "./volume/index.js";

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

@@ -0,0 +1,3 @@
+export * from "./jobs.js";
+export * from "./start.js";
+export * from "./types.js";

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

@@ -0,0 +1,13 @@
+declare class BlJob {
+    jobName: string;
+    constructor(jobName: string);
+    get fallbackUrl(): import("url").URL | null;
+    get externalUrl(): import("url").URL;
+    get internalUrl(): import("url").URL;
+    get forcedUrl(): import("url").URL | null;
+    get url(): import("url").URL;
+    call(url: URL, tasks: Record<string, unknown>[]): Promise<Response>;
+    run(tasks: Record<string, unknown>[]): Promise<string>;
+}
+export declare const blJob: (jobName: string) => BlJob;
+export {};

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

@@ -0,0 +1 @@
+export declare const blStartJob: (func: (args: any) => Promise<void>) => void;

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

@@ -0,0 +1,3 @@
+export type ExecutionArgs = {
+    [key: number]: any;
+}[];

package/dist/cjs-browser/types/mcp/client.d.ts

@@ -0,0 +1,28 @@
+import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
+/**
+ * Client transport for WebSocket: this will connect to a server over the WebSocket protocol.
+ * Works in both browser and Node.js environments.
+ */
+export declare class BlaxelMcpClientTransport implements Transport {
+    private _socket?;
+    private _url;
+    private _headers;
+    private _isBrowser;
+    private _retry_max;
+    private _retry_delay;
+    onclose?: () => void;
+    onerror?: (error: Error) => void;
+    onmessage?: (message: JSONRPCMessage) => void;
+    constructor(url: string, headers?: Record<string, string>, options?: {
+        retry: {
+            max?: number;
+            delay?: number;
+        };
+    });
+    start(): Promise<void>;
+    private _connect;
+    get isConnected(): boolean;
+    close(): Promise<void>;
+    send(message: JSONRPCMessage): Promise<void>;
+}

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

@@ -0,0 +1,2 @@
+export * from "./client.js";
+export * from "./server.js";

package/dist/cjs-browser/types/mcp/server.d.ts

@@ -0,0 +1,24 @@
+import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+interface JSONRPCMessage {
+    jsonrpc: "2.0";
+    id?: string | number;
+    method?: string;
+    params?: Record<string, unknown>;
+}
+export declare class BlaxelMcpServerTransport implements Transport {
+    private port;
+    private wss;
+    private clients;
+    onclose?: () => void;
+    onerror?: (err: Error) => void;
+    private messageHandler?;
+    onconnection?: (clientId: string) => void;
+    ondisconnection?: (clientId: string) => void;
+    set onmessage(handler: ((message: JSONRPCMessage) => void) | undefined);
+    constructor(port?: number);
+    start(): Promise<void>;
+    send(msg: JSONRPCMessage): Promise<void>;
+    broadcast(msg: JSONRPCMessage): Promise<void>;
+    close(): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,8 @@
+import { Model } from "../client/types.gen.js";
+export declare class BLModel {
+    modelName: string;
+    options?: Record<string, unknown>;
+    constructor(modelName: string, options?: Record<string, unknown>);
+}
+export declare const blModel: (modelName: string, options?: Record<string, unknown>) => BLModel;
+export declare const getModelMetadata: (model: string) => Promise<Model | null>;

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

@@ -0,0 +1,19 @@
+import { SandboxConfiguration } from "./types.js";
+export declare class ResponseError extends Error {
+    response: Response;
+    data: unknown;
+    error: unknown;
+    constructor(response: Response, data: unknown, error: unknown);
+}
+export declare class SandboxAction {
+    protected sandbox: SandboxConfiguration;
+    constructor(sandbox: SandboxConfiguration);
+    get name(): string;
+    get fallbackUrl(): string | null;
+    get externalUrl(): string;
+    get internalUrl(): string;
+    get client(): import("@hey-api/client-fetch").Client;
+    get forcedUrl(): string | import("url").URL | null;
+    get url(): string;
+    handleResponseError(response: Response, data: unknown, error: unknown): void;
+}

package/dist/cjs-browser/types/sandbox/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/cjs-browser/types/sandbox/client/index.d.ts

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

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

@@ -0,0 +1,101 @@
+import type { Options as ClientOptions, TDataShape, Client } from '@hey-api/client-fetch';
+import type { DeleteFilesystemByPathData, GetFilesystemByPathData, PutFilesystemByPathData, DeleteNetworkProcessByPidMonitorData, PostNetworkProcessByPidMonitorData, GetNetworkProcessByPidPortsData, GetProcessData, PostProcessData, DeleteProcessByIdentifierData, GetProcessByIdentifierData, DeleteProcessByIdentifierKillData, GetProcessByIdentifierLogsData, GetProcessByIdentifierLogsStreamData, GetWatchFilesystemByPathData, GetWsProcessByIdentifierLogsStreamData, GetWsWatchFilesystemByPathData } from './types.gen';
+export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean> = ClientOptions<TData, ThrowOnError> & {
+    /**
+     * You can provide a client instance returned by `createClient()` instead of
+     * individual options. This might be also useful if you want to implement a
+     * custom client.
+     */
+    client?: Client;
+    /**
+     * You can pass arbitrary values through the `meta` object. This can be
+     * used to access values that aren't defined as part of the SDK function.
+     */
+    meta?: Record<string, unknown>;
+};
+/**
+ * Delete file or directory
+ * Delete a file or directory
+ */
+export declare const deleteFilesystemByPath: <ThrowOnError extends boolean = false>(options: Options<DeleteFilesystemByPathData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").SuccessResponse, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * Get file or directory information
+ * Get content of a file or listing of a directory
+ */
+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, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * Create or update a file or directory
+ * Create or update a file or directory
+ */
+export declare const putFilesystemByPath: <ThrowOnError extends boolean = false>(options: Options<PutFilesystemByPathData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").SuccessResponse, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * Stop monitoring ports for a process
+ * Stop monitoring for new ports opened by a process
+ */
+export declare const deleteNetworkProcessByPidMonitor: <ThrowOnError extends boolean = false>(options: Options<DeleteNetworkProcessByPidMonitorData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<{
+    [key: string]: unknown;
+}, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * Start monitoring ports for a process
+ * Start monitoring for new ports opened by a process
+ */
+export declare const postNetworkProcessByPidMonitor: <ThrowOnError extends boolean = false>(options: Options<PostNetworkProcessByPidMonitorData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<{
+    [key: string]: unknown;
+}, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * Get open ports for a process
+ * Get a list of all open ports for a process
+ */
+export declare const getNetworkProcessByPidPorts: <ThrowOnError extends boolean = false>(options: Options<GetNetworkProcessByPidPortsData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<{
+    [key: string]: unknown;
+}, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * List all processes
+ * Get a list of all running and completed processes
+ */
+export declare const getProcess: <ThrowOnError extends boolean = false>(options?: Options<GetProcessData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").ProcessResponse[], unknown, ThrowOnError>;
+/**
+ * Execute a command
+ * Execute a command and return process information
+ */
+export declare const postProcess: <ThrowOnError extends boolean = false>(options: Options<PostProcessData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").ProcessResponse, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * Stop a process
+ * Gracefully stop a running process
+ */
+export declare const deleteProcessByIdentifier: <ThrowOnError extends boolean = false>(options: Options<DeleteProcessByIdentifierData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").SuccessResponse, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * Get process by identifier
+ * Get information about a process by its PID or name
+ */
+export declare const getProcessByIdentifier: <ThrowOnError extends boolean = false>(options: Options<GetProcessByIdentifierData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").ProcessResponse, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * Kill a process
+ * Forcefully kill a running process
+ */
+export declare const deleteProcessByIdentifierKill: <ThrowOnError extends boolean = false>(options: Options<DeleteProcessByIdentifierKillData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").SuccessResponse, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * Get process logs
+ * Get the stdout and stderr output of a process
+ */
+export declare const getProcessByIdentifierLogs: <ThrowOnError extends boolean = false>(options: Options<GetProcessByIdentifierLogsData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").ProcessLogs, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * Stream process logs in real time
+ * Streams the stdout and stderr output of a process in real time, one line per log, prefixed with 'stdout:' or 'stderr:'. Closes when the process exits or the client disconnects.
+ */
+export declare const getProcessByIdentifierLogsStream: <ThrowOnError extends boolean = false>(options: Options<GetProcessByIdentifierLogsStreamData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<string, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * Stream file modification events in a directory
+ * Streams the path of modified files (one per line) in the given directory. Closes when the client disconnects.
+ */
+export declare const getWatchFilesystemByPath: <ThrowOnError extends boolean = false>(options: Options<GetWatchFilesystemByPathData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<string, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * Stream process logs in real time via WebSocket
+ * Streams the stdout and stderr output of a process in real time as JSON messages.
+ */
+export declare const getWsProcessByIdentifierLogsStream: <ThrowOnError extends boolean = false>(options: Options<GetWsProcessByIdentifierLogsStreamData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<unknown, import("./types.gen").ErrorResponse, ThrowOnError>;
+/**
+ * Stream file modification events in a directory via WebSocket
+ * Streams JSON events of modified files in the given directory. Closes when the client disconnects.
+ */
+export declare const getWsWatchFilesystemByPath: <ThrowOnError extends boolean = false>(options: Options<GetWsWatchFilesystemByPathData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<unknown, import("./types.gen").ErrorResponse, ThrowOnError>;