@alienplatform/sdk 1.14.1 → 2.0.1

package/dist/commands/client.d.ts

@@ -1,47 +0,0 @@
-/**
- * Commands Client - Lightweight client for deployment command invocation
- *
- * Handles command invocation with automatic:
- * - Base64 encoding/decoding of params and responses
- * - Large payload upload/download via storage
- * - Polling with exponential backoff
- * - Error handling and timeout
- */
-import type { CommandsClientConfig, InvokeOptions } from "./types.js";
-/**
- * Commands client for invoking deployment commands
- */
-export declare class CommandsClient {
-    private readonly managerUrl;
-    private readonly deploymentId;
-    private readonly token;
-    private readonly defaultTimeout;
-    private readonly allowLocalStorage;
-    constructor(config: CommandsClientConfig);
-    /**
-     * Invoke a command on the deployment and wait for response
-     *
-     * @param command - Command name (e.g., "generate-report")
-     * @param params - Command parameters (JSON-serializable)
-     * @param options - Invocation options
-     * @returns Decoded response data
-     */
-    invoke<TParams = unknown, TResponse = unknown>(command: string, params: TParams, options?: InvokeOptions): Promise<TResponse>;
-    /**
-     * Create a command
-     */
-    private createCommand;
-    /**
-     * Get command status
-     */
-    private getCommandStatus;
-    /**
-     * Handle terminal state and return response
-     */
-    private handleTerminalState;
-    /**
-     * Sleep helper
-     */
-    private sleep;
-}
-//# sourceMappingURL=client.d.ts.map

package/dist/commands/client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/commands/client.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAYH,OAAO,KAAK,EAKV,oBAAoB,EAEpB,aAAa,EACd,MAAM,YAAY,CAAA;AA0LnB;;GAEG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;IACnC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAQ;IACrC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAQ;IAC9B,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAQ;IACvC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAS;gBAE/B,MAAM,EAAE,oBAAoB;IAQxC;;;;;;;OAOG;IACG,MAAM,CAAC,OAAO,GAAG,OAAO,EAAE,SAAS,GAAG,OAAO,EACjD,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,OAAO,EACf,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,SAAS,CAAC;IAsCrB;;OAEG;YACW,aAAa;IAsD3B;;OAEG;YACW,gBAAgB;IAkC9B;;OAEG;YACW,mBAAmB;IA4DjC;;OAEG;IACH,OAAO,CAAC,KAAK;CAGd"}

package/dist/commands/errors.d.ts

@@ -1,198 +0,0 @@
-/**
- * Commands Client Error Definitions
- */
-import { z } from "zod/v4";
-/**
- * Error thrown when command creation fails.
- */
-export declare const CommandCreationFailedError: {
-    metadata: import("@alienplatform/core").AlienErrorMetadata<z.ZodObject<{
-        deploymentId: z.ZodString;
-        command: z.ZodString;
-        reason: z.ZodString;
-    }, z.core.$strip>>;
-    contextSchema: z.ZodObject<{
-        deploymentId: z.ZodString;
-        command: z.ZodString;
-        reason: z.ZodString;
-    }, z.core.$strip>;
-    create: (context: {
-        deploymentId: string;
-        command: string;
-        reason: string;
-    }) => import("@alienplatform/core").AlienErrorDefinition<z.ZodObject<{
-        deploymentId: z.ZodString;
-        command: z.ZodString;
-        reason: z.ZodString;
-    }, z.core.$strip>>;
-};
-/**
- * Error thrown when command execution times out.
- */
-export declare const CommandTimeoutError: {
-    metadata: import("@alienplatform/core").AlienErrorMetadata<z.ZodObject<{
-        commandId: z.ZodString;
-        command: z.ZodString;
-        timeoutMs: z.ZodNumber;
-        lastState: z.ZodString;
-    }, z.core.$strip>>;
-    contextSchema: z.ZodObject<{
-        commandId: z.ZodString;
-        command: z.ZodString;
-        timeoutMs: z.ZodNumber;
-        lastState: z.ZodString;
-    }, z.core.$strip>;
-    create: (context: {
-        commandId: string;
-        command: string;
-        timeoutMs: number;
-        lastState: string;
-    }) => import("@alienplatform/core").AlienErrorDefinition<z.ZodObject<{
-        commandId: z.ZodString;
-        command: z.ZodString;
-        timeoutMs: z.ZodNumber;
-        lastState: z.ZodString;
-    }, z.core.$strip>>;
-};
-/**
- * Error thrown when the deployment returns an error response.
- */
-export declare const DeploymentCommandError: {
-    metadata: import("@alienplatform/core").AlienErrorMetadata<z.ZodObject<{
-        commandId: z.ZodString;
-        command: z.ZodString;
-        errorCode: z.ZodString;
-        errorMessage: z.ZodString;
-        errorDetails: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    contextSchema: z.ZodObject<{
-        commandId: z.ZodString;
-        command: z.ZodString;
-        errorCode: z.ZodString;
-        errorMessage: z.ZodString;
-        errorDetails: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-    create: (context: {
-        commandId: string;
-        command: string;
-        errorCode: string;
-        errorMessage: string;
-        errorDetails?: string | undefined;
-    }) => import("@alienplatform/core").AlienErrorDefinition<z.ZodObject<{
-        commandId: z.ZodString;
-        command: z.ZodString;
-        errorCode: z.ZodString;
-        errorMessage: z.ZodString;
-        errorDetails: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-};
-/**
- * Error thrown when command expires before completion.
- */
-export declare const CommandExpiredError: {
-    metadata: import("@alienplatform/core").AlienErrorMetadata<z.ZodObject<{
-        commandId: z.ZodString;
-        command: z.ZodString;
-    }, z.core.$strip>>;
-    contextSchema: z.ZodObject<{
-        commandId: z.ZodString;
-        command: z.ZodString;
-    }, z.core.$strip>;
-    create: (context: {
-        commandId: string;
-        command: string;
-    }) => import("@alienplatform/core").AlienErrorDefinition<z.ZodObject<{
-        commandId: z.ZodString;
-        command: z.ZodString;
-    }, z.core.$strip>>;
-};
-/**
- * Error thrown when storage upload/download fails.
- */
-export declare const StorageOperationFailedError: {
-    metadata: import("@alienplatform/core").AlienErrorMetadata<z.ZodObject<{
-        operation: z.ZodEnum<{
-            upload: "upload";
-            download: "download";
-        }>;
-        url: z.ZodString;
-        reason: z.ZodString;
-    }, z.core.$strip>>;
-    contextSchema: z.ZodObject<{
-        operation: z.ZodEnum<{
-            upload: "upload";
-            download: "download";
-        }>;
-        url: z.ZodString;
-        reason: z.ZodString;
-    }, z.core.$strip>;
-    create: (context: {
-        operation: "upload" | "download";
-        url: string;
-        reason: string;
-    }) => import("@alienplatform/core").AlienErrorDefinition<z.ZodObject<{
-        operation: z.ZodEnum<{
-            upload: "upload";
-            download: "download";
-        }>;
-        url: z.ZodString;
-        reason: z.ZodString;
-    }, z.core.$strip>>;
-};
-/**
- * Error thrown when response decoding fails.
- */
-export declare const ResponseDecodingFailedError: {
-    metadata: import("@alienplatform/core").AlienErrorMetadata<z.ZodObject<{
-        commandId: z.ZodString;
-        command: z.ZodString;
-        reason: z.ZodString;
-    }, z.core.$strip>>;
-    contextSchema: z.ZodObject<{
-        commandId: z.ZodString;
-        command: z.ZodString;
-        reason: z.ZodString;
-    }, z.core.$strip>;
-    create: (context: {
-        commandId: string;
-        command: string;
-        reason: string;
-    }) => import("@alienplatform/core").AlienErrorDefinition<z.ZodObject<{
-        commandId: z.ZodString;
-        command: z.ZodString;
-        reason: z.ZodString;
-    }, z.core.$strip>>;
-};
-/**
- * Error thrown when Manager returns an HTTP error.
- */
-export declare const ManagerHttpError: {
-    metadata: import("@alienplatform/core").AlienErrorMetadata<z.ZodObject<{
-        method: z.ZodString;
-        url: z.ZodString;
-        status: z.ZodNumber;
-        statusText: z.ZodString;
-        body: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    contextSchema: z.ZodObject<{
-        method: z.ZodString;
-        url: z.ZodString;
-        status: z.ZodNumber;
-        statusText: z.ZodString;
-        body: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-    create: (context: {
-        method: string;
-        url: string;
-        status: number;
-        statusText: string;
-        body?: string | undefined;
-    }) => import("@alienplatform/core").AlienErrorDefinition<z.ZodObject<{
-        method: z.ZodString;
-        url: z.ZodString;
-        status: z.ZodNumber;
-        statusText: z.ZodString;
-        body: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-};
-//# sourceMappingURL=errors.d.ts.map

package/dist/commands/errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/commands/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B;;GAEG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;CAYrC,CAAA;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;CAa9B,CAAA;AAEF;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAcjC,CAAA;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;CAU9B,CAAA;AAEF;;GAEG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWtC,CAAA;AAEF;;GAEG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;CAWtC,CAAA;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAc3B,CAAA"}

package/dist/commands/index.d.ts

@@ -1,23 +0,0 @@
-/**
- * Commands client — invoke commands on remote Alien deployments.
- *
- * @example
- * ```typescript
- * import { CommandsClient } from "@alienplatform/sdk/commands"
- *
- * const commands = new CommandsClient({
- *   managerUrl: "https://manager.example.com",
- *   deploymentId: "deployment_123",
- *   token: "bearer_token",
- * })
- *
- * const result = await commands.invoke("generate-report", {
- *   startDate: "2024-01-01",
- *   endDate: "2024-01-31",
- * })
- * ```
- */
-export { CommandsClient } from "./client.js";
-export type { CommandsClientConfig, BodySpec, CommandResponse, CommandState, CommandStatusResponse, CreateCommandResponse, InvokeOptions, PresignedRequest, StorageUpload, } from "./types.js";
-export { DeploymentCommandError, ManagerHttpError, CommandCreationFailedError, CommandExpiredError, CommandTimeoutError, ResponseDecodingFailedError, StorageOperationFailedError, } from "./errors.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/commands/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/commands/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAC5C,YAAY,EACV,oBAAoB,EACpB,QAAQ,EACR,eAAe,EACf,YAAY,EACZ,qBAAqB,EACrB,qBAAqB,EACrB,aAAa,EACb,gBAAgB,EAChB,aAAa,GACd,MAAM,YAAY,CAAA;AACnB,OAAO,EACL,sBAAsB,EACtB,gBAAgB,EAChB,0BAA0B,EAC1B,mBAAmB,EACnB,mBAAmB,EACnB,2BAA2B,EAC3B,2BAA2B,GAC5B,MAAM,aAAa,CAAA"}

package/dist/commands/index.js

@@ -1,387 +0,0 @@
-import { c as string, n as defineError, o as number, r as _enum, s as object, t as AlienError } from "../dist.js";
-//#region src/commands/errors.ts
-/**
-* Commands Client Error Definitions
-*/
-/**
-* Error thrown when command creation fails.
-*/
-const CommandCreationFailedError = defineError({
-	code: "COMMAND_CREATION_FAILED",
-	context: object({
-		deploymentId: string(),
-		command: string(),
-		reason: string()
-	}),
-	message: ({ deploymentId, command, reason }) => `Failed to create command '${command}' for deployment '${deploymentId}': ${reason}`,
-	retryable: false,
-	internal: false,
-	httpStatusCode: 500
-});
-/**
-* Error thrown when command execution times out.
-*/
-const CommandTimeoutError = defineError({
-	code: "COMMAND_TIMEOUT",
-	context: object({
-		commandId: string(),
-		command: string(),
-		timeoutMs: number(),
-		lastState: string()
-	}),
-	message: ({ command, timeoutMs, lastState }) => `Command '${command}' timed out after ${timeoutMs}ms (last state: ${lastState})`,
-	retryable: true,
-	internal: false,
-	httpStatusCode: 504
-});
-/**
-* Error thrown when the deployment returns an error response.
-*/
-const DeploymentCommandError = defineError({
-	code: "DEPLOYMENT_COMMAND_ERROR",
-	context: object({
-		commandId: string(),
-		command: string(),
-		errorCode: string(),
-		errorMessage: string(),
-		errorDetails: string().optional()
-	}),
-	message: ({ command, errorCode, errorMessage }) => `Deployment command '${command}' failed: [${errorCode}] ${errorMessage}`,
-	retryable: false,
-	internal: false,
-	httpStatusCode: 500
-});
-/**
-* Error thrown when command expires before completion.
-*/
-const CommandExpiredError = defineError({
-	code: "COMMAND_EXPIRED",
-	context: object({
-		commandId: string(),
-		command: string()
-	}),
-	message: ({ command }) => `Command '${command}' expired before completion`,
-	retryable: false,
-	internal: false,
-	httpStatusCode: 410
-});
-/**
-* Error thrown when storage upload/download fails.
-*/
-const StorageOperationFailedError = defineError({
-	code: "STORAGE_OPERATION_FAILED",
-	context: object({
-		operation: _enum(["upload", "download"]),
-		url: string(),
-		reason: string()
-	}),
-	message: ({ operation, reason }) => `Storage ${operation} failed: ${reason}`,
-	retryable: true,
-	internal: false,
-	httpStatusCode: 500
-});
-/**
-* Error thrown when response decoding fails.
-*/
-const ResponseDecodingFailedError = defineError({
-	code: "RESPONSE_DECODING_FAILED",
-	context: object({
-		commandId: string(),
-		command: string(),
-		reason: string()
-	}),
-	message: ({ command, reason }) => `Failed to decode response for command '${command}': ${reason}`,
-	retryable: false,
-	internal: false,
-	httpStatusCode: 500
-});
-/**
-* Error thrown when Manager returns an HTTP error.
-*/
-const ManagerHttpError = defineError({
-	code: "MANAGER_HTTP_ERROR",
-	context: object({
-		method: string(),
-		url: string(),
-		status: number(),
-		statusText: string(),
-		body: string().optional()
-	}),
-	message: ({ method, url, status, statusText }) => `Manager ${method} ${url} failed: ${status} ${statusText}`,
-	retryable: false,
-	internal: false,
-	httpStatusCode: 500
-});
-//#endregion
-//#region src/commands/client.ts
-/**
-* Commands Client - Lightweight client for deployment command invocation
-*
-* Handles command invocation with automatic:
-* - Base64 encoding/decoding of params and responses
-* - Large payload upload/download via storage
-* - Polling with exponential backoff
-* - Error handling and timeout
-*/
-/**
-* Base64 encode data
-*/
-function base64Encode(data) {
-	const json = typeof data === "string" ? data : JSON.stringify(data);
-	if (typeof btoa !== "undefined") return btoa(json);
-	return Buffer.from(json, "utf-8").toString("base64");
-}
-/**
-* Base64 decode data
-*/
-function base64Decode(encoded) {
-	if (typeof atob !== "undefined") return atob(encoded);
-	return Buffer.from(encoded, "base64").toString("utf-8");
-}
-/**
-* Create inline body spec. Always sends inline — the server handles storage
-* decisions transparently (auto-promoting to blob if needed).
-*/
-function createBodySpec(data) {
-	return {
-		mode: "inline",
-		inlineBase64: base64Encode(typeof data === "string" ? data : JSON.stringify(data))
-	};
-}
-/**
-* Decode response body spec
-*/
-async function decodeBodySpec(body, commandId, command, allowLocalStorage) {
-	if (body.mode === "inline") {
-		const json = base64Decode(body.inlineBase64);
-		return JSON.parse(json);
-	}
-	if (body.mode === "storage") {
-		if (!body.storageGetRequest) throw new AlienError(ResponseDecodingFailedError.create({
-			commandId,
-			command,
-			reason: "Storage response missing storageGetRequest"
-		}));
-		const request = body.storageGetRequest;
-		const expiration = new Date(request.expiration);
-		if (Date.now() > expiration.getTime()) throw new AlienError(StorageOperationFailedError.create({
-			operation: "download",
-			url: request.backend.type === "http" ? request.backend.url : "local",
-			reason: `Presigned request expired at ${expiration.toISOString()}`
-		}));
-		if (request.backend.type === "http") try {
-			const response = await fetch(request.backend.url, {
-				method: request.backend.method,
-				headers: request.backend.headers
-			});
-			if (!response.ok) throw new AlienError(StorageOperationFailedError.create({
-				operation: "download",
-				url: request.backend.url,
-				reason: `HTTP ${response.status} ${response.statusText}`
-			}));
-			const text = await response.text();
-			return JSON.parse(text);
-		} catch (error) {
-			if (error instanceof AlienError) throw error;
-			throw (await AlienError.from(error)).withContext(StorageOperationFailedError.create({
-				operation: "download",
-				url: request.backend.url,
-				reason: error instanceof Error ? error.message : String(error)
-			}));
-		}
-		else if (request.backend.type === "local") {
-			if (!allowLocalStorage) throw new AlienError(StorageOperationFailedError.create({
-				operation: "download",
-				url: `local://${request.backend.filePath}`,
-				reason: "Local storage backend not enabled (set allowLocalStorage: true for local dev)"
-			}));
-			const filePath = request.backend.filePath;
-			if (filePath.includes("..")) throw new AlienError(StorageOperationFailedError.create({
-				operation: "download",
-				url: `local://${filePath}`,
-				reason: "Path traversal not allowed in local storage paths"
-			}));
-			try {
-				const { readFile } = await import("node:fs/promises");
-				const content = await readFile(filePath, "utf-8");
-				return JSON.parse(content);
-			} catch (error) {
-				if (error instanceof AlienError) throw error;
-				throw (await AlienError.from(error)).withContext(StorageOperationFailedError.create({
-					operation: "download",
-					url: `local://${filePath}`,
-					reason: error instanceof Error ? error.message : String(error)
-				}));
-			}
-		} else throw new AlienError(StorageOperationFailedError.create({
-			operation: "download",
-			url: "unknown",
-			reason: `Unknown storage backend type: ${request.backend.type}`
-		}));
-	}
-	throw new AlienError(ResponseDecodingFailedError.create({
-		commandId,
-		command,
-		reason: `Unknown body mode: ${body.mode}`
-	}));
-}
-/**
-* Check if state is terminal
-*/
-function isTerminalState(state) {
-	return state === "SUCCEEDED" || state === "FAILED" || state === "EXPIRED";
-}
-/**
-* Commands client for invoking deployment commands
-*/
-var CommandsClient = class {
-	managerUrl;
-	deploymentId;
-	token;
-	defaultTimeout;
-	allowLocalStorage;
-	constructor(config) {
-		this.managerUrl = config.managerUrl.replace(/\/+$/, "");
-		this.deploymentId = config.deploymentId;
-		this.token = config.token;
-		this.defaultTimeout = config.timeout ?? 6e4;
-		this.allowLocalStorage = config.allowLocalStorage ?? false;
-	}
-	/**
-	* Invoke a command on the deployment and wait for response
-	*
-	* @param command - Command name (e.g., "generate-report")
-	* @param params - Command parameters (JSON-serializable)
-	* @param options - Invocation options
-	* @returns Decoded response data
-	*/
-	async invoke(command, params, options) {
-		const timeout = options?.timeout ?? this.defaultTimeout;
-		const startTime = Date.now();
-		const createResponse = await this.createCommand(command, params, options);
-		const pollInterval = options?.pollInterval ?? 500;
-		const maxPollInterval = options?.maxPollInterval ?? 5e3;
-		const pollBackoff = options?.pollBackoff ?? 1.5;
-		let currentInterval = pollInterval;
-		while (Date.now() - startTime < timeout) {
-			await this.sleep(currentInterval);
-			const status = await this.getCommandStatus(createResponse.commandId);
-			if (isTerminalState(status.state)) return await this.handleTerminalState(command, status);
-			currentInterval = Math.min(currentInterval * pollBackoff, maxPollInterval);
-		}
-		const finalStatus = await this.getCommandStatus(createResponse.commandId);
-		throw new AlienError(CommandTimeoutError.create({
-			commandId: createResponse.commandId,
-			command,
-			timeoutMs: timeout,
-			lastState: finalStatus.state
-		}));
-	}
-	/**
-	* Create a command
-	*/
-	async createCommand(command, params, options) {
-		const url = `${this.managerUrl}/v1/commands`;
-		const body = {
-			deploymentId: this.deploymentId,
-			command,
-			params: createBodySpec(params),
-			deadline: options?.deadline?.toISOString(),
-			idempotencyKey: options?.idempotencyKey
-		};
-		try {
-			const response = await fetch(url, {
-				method: "POST",
-				headers: {
-					"Content-Type": "application/json",
-					Authorization: `Bearer ${this.token}`
-				},
-				body: JSON.stringify(body)
-			});
-			if (!response.ok) {
-				const errorBody = await response.text().catch(() => "");
-				throw new AlienError(ManagerHttpError.create({
-					method: "POST",
-					url,
-					status: response.status,
-					statusText: response.statusText,
-					body: errorBody
-				}));
-			}
-			return await response.json();
-		} catch (error) {
-			if (error instanceof AlienError) throw error;
-			throw (await AlienError.from(error)).withContext(CommandCreationFailedError.create({
-				deploymentId: this.deploymentId,
-				command,
-				reason: error instanceof Error ? error.message : String(error)
-			}));
-		}
-	}
-	/**
-	* Get command status
-	*/
-	async getCommandStatus(commandId) {
-		const url = `${this.managerUrl}/v1/commands/${commandId}`;
-		try {
-			const response = await fetch(url, {
-				method: "GET",
-				headers: { Authorization: `Bearer ${this.token}` }
-			});
-			if (!response.ok) {
-				const errorBody = await response.text().catch(() => "");
-				throw new AlienError(ManagerHttpError.create({
-					method: "GET",
-					url,
-					status: response.status,
-					statusText: response.statusText,
-					body: errorBody
-				}));
-			}
-			return await response.json();
-		} catch (error) {
-			if (error instanceof AlienError) throw error;
-			throw await AlienError.from(error);
-		}
-	}
-	/**
-	* Handle terminal state and return response
-	*/
-	async handleTerminalState(command, status) {
-		if (status.state === "EXPIRED") throw new AlienError(CommandExpiredError.create({
-			commandId: status.commandId,
-			command
-		}));
-		if (!status.response) throw new AlienError(ResponseDecodingFailedError.create({
-			commandId: status.commandId,
-			command,
-			reason: "Terminal state but no response present"
-		}));
-		const response = status.response;
-		if (response.status === "error") throw new AlienError(DeploymentCommandError.create({
-			commandId: status.commandId,
-			command,
-			errorCode: response.code,
-			errorMessage: response.message,
-			errorDetails: response.details ?? void 0
-		}));
-		try {
-			return await decodeBodySpec(response.response, status.commandId, command, this.allowLocalStorage);
-		} catch (error) {
-			if (error instanceof AlienError) throw error;
-			throw new AlienError(ResponseDecodingFailedError.create({
-				commandId: status.commandId,
-				command,
-				reason: error instanceof Error ? error.message : String(error)
-			}));
-		}
-	}
-	/**
-	* Sleep helper
-	*/
-	sleep(ms) {
-		return new Promise((resolve) => setTimeout(resolve, ms));
-	}
-};
-//#endregion
-export { CommandCreationFailedError, CommandExpiredError, CommandTimeoutError, CommandsClient, DeploymentCommandError, ManagerHttpError, ResponseDecodingFailedError, StorageOperationFailedError };