@cloudflare/sandbox 0.13.0-next.649.1 → 0.13.0-next.681.1

package/dist/errors-ewgSNicb.js

@@ -0,0 +1,741 @@
+import { i as ErrorCode } from "./errors-k3B8orjH.js";
+
+//#region src/errors/classes.ts
+/**
+* Base SDK error that wraps ErrorResponse
+* Preserves all error information from container
+*/
+var SandboxError = class extends Error {
+	constructor(errorResponse, options) {
+		super(errorResponse.message, options);
+		this.errorResponse = errorResponse;
+		this.name = "SandboxError";
+	}
+	get code() {
+		return this.errorResponse.code;
+	}
+	get context() {
+		return this.errorResponse.context;
+	}
+	get httpStatus() {
+		return this.errorResponse.httpStatus;
+	}
+	get operation() {
+		return this.errorResponse.operation;
+	}
+	get suggestion() {
+		return this.errorResponse.suggestion;
+	}
+	get timestamp() {
+		return this.errorResponse.timestamp;
+	}
+	get documentation() {
+		return this.errorResponse.documentation;
+	}
+	toJSON() {
+		return {
+			name: this.name,
+			message: this.message,
+			code: this.code,
+			context: this.context,
+			httpStatus: this.httpStatus,
+			operation: this.operation,
+			suggestion: this.suggestion,
+			timestamp: this.timestamp,
+			documentation: this.documentation,
+			stack: this.stack
+		};
+	}
+};
+/**
+* Error thrown when a file or directory is not found
+*/
+var FileNotFoundError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "FileNotFoundError";
+	}
+	get path() {
+		return this.context.path;
+	}
+};
+/**
+* Error thrown when a file already exists
+*/
+var FileExistsError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "FileExistsError";
+	}
+	get path() {
+		return this.context.path;
+	}
+};
+/**
+* Error thrown when a file is too large
+*/
+var FileTooLargeError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "FileTooLargeError";
+	}
+	get path() {
+		return this.context.path;
+	}
+};
+/**
+* Generic file system error (permissions, disk full, etc.)
+*/
+var FileSystemError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "FileSystemError";
+	}
+	get path() {
+		return this.context.path;
+	}
+	get stderr() {
+		return this.context.stderr;
+	}
+	get exitCode() {
+		return this.context.exitCode;
+	}
+};
+/**
+* Error thrown when permission is denied
+*/
+var PermissionDeniedError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "PermissionDeniedError";
+	}
+	get path() {
+		return this.context.path;
+	}
+};
+/**
+* Error thrown when a command is not found
+*/
+var CommandNotFoundError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "CommandNotFoundError";
+	}
+	get command() {
+		return this.context.command;
+	}
+};
+/**
+* Generic command execution error
+*/
+var CommandError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "CommandError";
+	}
+	get command() {
+		return this.context.command;
+	}
+	get exitCode() {
+		return this.context.exitCode;
+	}
+	get stdout() {
+		return this.context.stdout;
+	}
+	get stderr() {
+		return this.context.stderr;
+	}
+};
+/**
+* Error thrown when a process is not found
+*/
+var ProcessNotFoundError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "ProcessNotFoundError";
+	}
+	get processId() {
+		return this.context.processId;
+	}
+};
+/**
+* Generic process error
+*/
+var ProcessError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "ProcessError";
+	}
+	get processId() {
+		return this.context.processId;
+	}
+	get pid() {
+		return this.context.pid;
+	}
+	get exitCode() {
+		return this.context.exitCode;
+	}
+	get stderr() {
+		return this.context.stderr;
+	}
+};
+/**
+* Error thrown when a session already exists
+*/
+var SessionAlreadyExistsError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "SessionAlreadyExistsError";
+	}
+	get sessionId() {
+		return this.context.sessionId;
+	}
+	get containerPlacementId() {
+		return this.context.containerPlacementId;
+	}
+};
+/**
+* Error thrown when a session was destroyed while a command was executing
+*/
+var SessionDestroyedError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "SessionDestroyedError";
+	}
+	get sessionId() {
+		return this.context.sessionId;
+	}
+};
+/**
+* Error thrown when a session's underlying shell exited without an explicit
+* `destroy()` call (user ran `exit`, the shell crashed, or a child process
+* took the shell down). The session-local state is gone, but the next call
+* with the same sessionId will transparently start a fresh session.
+*/
+var SessionTerminatedError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "SessionTerminatedError";
+	}
+	get sessionId() {
+		return this.context.sessionId;
+	}
+	get exitCode() {
+		return this.context.exitCode;
+	}
+};
+/**
+* Compatibility error for legacy port exposure registry responses.
+*/
+var PortAlreadyExposedError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "PortAlreadyExposedError";
+	}
+	get port() {
+		return this.context.port;
+	}
+	get portName() {
+		return this.context.portName;
+	}
+};
+/**
+* Compatibility error for legacy port exposure registry responses.
+*/
+var PortNotExposedError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "PortNotExposedError";
+	}
+	get port() {
+		return this.context.port;
+	}
+};
+/**
+* Error thrown when a port number is invalid
+*/
+var InvalidPortError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "InvalidPortError";
+	}
+	get port() {
+		return this.context.port;
+	}
+	get reason() {
+		return this.context.reason;
+	}
+};
+/**
+* Error thrown when a service on a port is not responding
+*/
+var ServiceNotRespondingError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "ServiceNotRespondingError";
+	}
+	get port() {
+		return this.context.port;
+	}
+	get portName() {
+		return this.context.portName;
+	}
+};
+/**
+* Error thrown when a port is already in use
+*/
+var PortInUseError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "PortInUseError";
+	}
+	get port() {
+		return this.context.port;
+	}
+};
+/**
+* Generic port operation error
+*/
+var PortError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "PortError";
+	}
+	get port() {
+		return this.context.port;
+	}
+	get portName() {
+		return this.context.portName;
+	}
+	get stderr() {
+		return this.context.stderr;
+	}
+};
+/**
+* Error thrown when port exposure requires a custom domain
+*/
+var CustomDomainRequiredError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "CustomDomainRequiredError";
+	}
+};
+/**
+* Error thrown when a git repository is not found
+*/
+var GitRepositoryNotFoundError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "GitRepositoryNotFoundError";
+	}
+	get repository() {
+		return this.context.repository;
+	}
+};
+/**
+* Error thrown when git authentication fails
+*/
+var GitAuthenticationError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "GitAuthenticationError";
+	}
+	get repository() {
+		return this.context.repository;
+	}
+};
+/**
+* Error thrown when a git branch is not found
+*/
+var GitBranchNotFoundError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "GitBranchNotFoundError";
+	}
+	get branch() {
+		return this.context.branch;
+	}
+	get repository() {
+		return this.context.repository;
+	}
+};
+/**
+* Error thrown when a git network operation fails
+*/
+var GitNetworkError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "GitNetworkError";
+	}
+	get repository() {
+		return this.context.repository;
+	}
+	get branch() {
+		return this.context.branch;
+	}
+	get targetDir() {
+		return this.context.targetDir;
+	}
+};
+/**
+* Error thrown when git clone fails
+*/
+var GitCloneError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "GitCloneError";
+	}
+	get repository() {
+		return this.context.repository;
+	}
+	get targetDir() {
+		return this.context.targetDir;
+	}
+	get stderr() {
+		return this.context.stderr;
+	}
+	get exitCode() {
+		return this.context.exitCode;
+	}
+};
+/**
+* Error thrown when git checkout fails
+*/
+var GitCheckoutError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "GitCheckoutError";
+	}
+	get branch() {
+		return this.context.branch;
+	}
+	get repository() {
+		return this.context.repository;
+	}
+	get stderr() {
+		return this.context.stderr;
+	}
+};
+/**
+* Error thrown when a git URL is invalid
+*/
+var InvalidGitUrlError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "InvalidGitUrlError";
+	}
+	get validationErrors() {
+		return this.context.validationErrors;
+	}
+};
+/**
+* Generic git operation error
+*/
+var GitError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "GitError";
+	}
+	get repository() {
+		return this.context.repository;
+	}
+	get branch() {
+		return this.context.branch;
+	}
+	get targetDir() {
+		return this.context.targetDir;
+	}
+	get stderr() {
+		return this.context.stderr;
+	}
+	get exitCode() {
+		return this.context.exitCode;
+	}
+};
+/**
+* Error thrown when interpreter is not ready
+*/
+var InterpreterNotReadyError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "InterpreterNotReadyError";
+	}
+	get retryAfter() {
+		return this.context.retryAfter;
+	}
+	get progress() {
+		return this.context.progress;
+	}
+};
+/**
+* Error thrown when a context is not found
+*/
+var ContextNotFoundError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "ContextNotFoundError";
+	}
+	get contextId() {
+		return this.context.contextId;
+	}
+};
+/**
+* Error thrown when code execution fails
+*/
+var CodeExecutionError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "CodeExecutionError";
+	}
+	get contextId() {
+		return this.context.contextId;
+	}
+	get ename() {
+		return this.context.ename;
+	}
+	get evalue() {
+		return this.context.evalue;
+	}
+	get traceback() {
+		return this.context.traceback;
+	}
+};
+/**
+* Error thrown when validation fails
+*/
+var ValidationFailedError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "ValidationFailedError";
+	}
+	get validationErrors() {
+		return this.context.validationErrors;
+	}
+};
+/**
+* Error thrown when a process does not become ready within the timeout period
+*/
+var ProcessReadyTimeoutError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "ProcessReadyTimeoutError";
+	}
+	get processId() {
+		return this.context.processId;
+	}
+	get command() {
+		return this.context.command;
+	}
+	get condition() {
+		return this.context.condition;
+	}
+	get timeout() {
+		return this.context.timeout;
+	}
+};
+/**
+* Error thrown when a process exits before becoming ready
+*/
+var ProcessExitedBeforeReadyError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "ProcessExitedBeforeReadyError";
+	}
+	get processId() {
+		return this.context.processId;
+	}
+	get command() {
+		return this.context.command;
+	}
+	get condition() {
+		return this.context.condition;
+	}
+	get exitCode() {
+		return this.context.exitCode;
+	}
+};
+/**
+* Error thrown when a backup is not found in R2
+*/
+var BackupNotFoundError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "BackupNotFoundError";
+	}
+	get backupId() {
+		return this.context.backupId;
+	}
+};
+/**
+* Error thrown when a backup has expired (past its TTL)
+*/
+var BackupExpiredError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "BackupExpiredError";
+	}
+	get backupId() {
+		return this.context.backupId;
+	}
+	get expiredAt() {
+		return this.context.expiredAt;
+	}
+};
+/**
+* Error thrown when backup configuration or inputs are invalid
+*/
+var InvalidBackupConfigError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "InvalidBackupConfigError";
+	}
+	get reason() {
+		return this.context.reason;
+	}
+};
+/**
+* Error thrown when backup creation fails
+*/
+var BackupCreateError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "BackupCreateError";
+	}
+	get dir() {
+		return this.context.dir;
+	}
+	get backupId() {
+		return this.context.backupId;
+	}
+};
+/**
+* Error thrown when backup restoration fails
+*/
+var BackupRestoreError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "BackupRestoreError";
+	}
+	get dir() {
+		return this.context.dir;
+	}
+	get backupId() {
+		return this.context.backupId;
+	}
+};
+var ContainerUnavailableError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "ContainerUnavailableError";
+	}
+};
+var OperationInterruptedError = class extends SandboxError {
+	constructor(errorResponse) {
+		super(errorResponse);
+		this.name = "OperationInterruptedError";
+	}
+	get reason() {
+		return this.context.reason;
+	}
+	get retryable() {
+		return this.context.retryable;
+	}
+	get operationName() {
+		return this.context.operation;
+	}
+};
+/**
+* Raised when the capnweb WebSocket session itself fails on the SDK side.
+* Unlike the rest of the SandboxError tree, the container never produces
+* this error — it is synthesised by `translateRPCError` from the plain
+* Errors capnweb / DeferredTransport raise when the connection dies.
+*
+* `kind` distinguishes the failure mode (peer close, upgrade failed, etc.)
+* so callers can branch on a structured code instead of substring-matching
+* on the message.
+*
+* Always retryable: the SDK opens a fresh connection on the next call.
+*/
+var RPCTransportError = class extends SandboxError {
+	constructor(errorResponse, options) {
+		super(errorResponse, options);
+		this.name = "RPCTransportError";
+	}
+	get kind() {
+		return this.errorResponse.context.kind;
+	}
+	get originalMessage() {
+		return this.errorResponse.context.originalMessage;
+	}
+};
+
+//#endregion
+//#region src/errors/adapter.ts
+/**
+* Convert ErrorResponse to appropriate Error class
+* Simple switch statement - we trust the container sends correct context
+*/
+function createErrorFromResponse(errorResponse, options) {
+	switch (errorResponse.code) {
+		case ErrorCode.FILE_NOT_FOUND: return new FileNotFoundError(errorResponse);
+		case ErrorCode.FILE_EXISTS: return new FileExistsError(errorResponse);
+		case ErrorCode.FILE_TOO_LARGE: return new FileTooLargeError(errorResponse);
+		case ErrorCode.PERMISSION_DENIED: return new PermissionDeniedError(errorResponse);
+		case ErrorCode.IS_DIRECTORY:
+		case ErrorCode.NOT_DIRECTORY:
+		case ErrorCode.NO_SPACE:
+		case ErrorCode.TOO_MANY_FILES:
+		case ErrorCode.RESOURCE_BUSY:
+		case ErrorCode.READ_ONLY:
+		case ErrorCode.NAME_TOO_LONG:
+		case ErrorCode.TOO_MANY_LINKS:
+		case ErrorCode.FILESYSTEM_ERROR: return new FileSystemError(errorResponse);
+		case ErrorCode.COMMAND_NOT_FOUND: return new CommandNotFoundError(errorResponse);
+		case ErrorCode.COMMAND_PERMISSION_DENIED:
+		case ErrorCode.COMMAND_EXECUTION_ERROR:
+		case ErrorCode.INVALID_COMMAND:
+		case ErrorCode.STREAM_START_ERROR: return new CommandError(errorResponse);
+		case ErrorCode.PROCESS_NOT_FOUND: return new ProcessNotFoundError(errorResponse);
+		case ErrorCode.PROCESS_PERMISSION_DENIED:
+		case ErrorCode.PROCESS_ERROR: return new ProcessError(errorResponse);
+		case ErrorCode.SESSION_ALREADY_EXISTS: return new SessionAlreadyExistsError(errorResponse);
+		case ErrorCode.SESSION_DESTROYED: return new SessionDestroyedError(errorResponse);
+		case ErrorCode.SESSION_TERMINATED: return new SessionTerminatedError(errorResponse);
+		case ErrorCode.PORT_ALREADY_EXPOSED: return new PortAlreadyExposedError(errorResponse);
+		case ErrorCode.PORT_NOT_EXPOSED: return new PortNotExposedError(errorResponse);
+		case ErrorCode.INVALID_PORT_NUMBER:
+		case ErrorCode.INVALID_PORT: return new InvalidPortError(errorResponse);
+		case ErrorCode.SERVICE_NOT_RESPONDING: return new ServiceNotRespondingError(errorResponse);
+		case ErrorCode.PORT_IN_USE: return new PortInUseError(errorResponse);
+		case ErrorCode.PORT_OPERATION_ERROR: return new PortError(errorResponse);
+		case ErrorCode.CUSTOM_DOMAIN_REQUIRED: return new CustomDomainRequiredError(errorResponse);
+		case ErrorCode.GIT_REPOSITORY_NOT_FOUND: return new GitRepositoryNotFoundError(errorResponse);
+		case ErrorCode.GIT_AUTH_FAILED: return new GitAuthenticationError(errorResponse);
+		case ErrorCode.GIT_BRANCH_NOT_FOUND: return new GitBranchNotFoundError(errorResponse);
+		case ErrorCode.GIT_NETWORK_ERROR: return new GitNetworkError(errorResponse);
+		case ErrorCode.GIT_CLONE_FAILED: return new GitCloneError(errorResponse);
+		case ErrorCode.GIT_CHECKOUT_FAILED: return new GitCheckoutError(errorResponse);
+		case ErrorCode.INVALID_GIT_URL: return new InvalidGitUrlError(errorResponse);
+		case ErrorCode.GIT_OPERATION_FAILED: return new GitError(errorResponse);
+		case ErrorCode.BACKUP_NOT_FOUND: return new BackupNotFoundError(errorResponse);
+		case ErrorCode.BACKUP_EXPIRED: return new BackupExpiredError(errorResponse);
+		case ErrorCode.INVALID_BACKUP_CONFIG: return new InvalidBackupConfigError(errorResponse);
+		case ErrorCode.BACKUP_CREATE_FAILED: return new BackupCreateError(errorResponse);
+		case ErrorCode.BACKUP_RESTORE_FAILED: return new BackupRestoreError(errorResponse);
+		case ErrorCode.INTERPRETER_NOT_READY: return new InterpreterNotReadyError(errorResponse);
+		case ErrorCode.CONTEXT_NOT_FOUND: return new ContextNotFoundError(errorResponse);
+		case ErrorCode.CODE_EXECUTION_ERROR: return new CodeExecutionError(errorResponse);
+		case ErrorCode.CONTAINER_UNAVAILABLE: return new ContainerUnavailableError(errorResponse);
+		case ErrorCode.OPERATION_INTERRUPTED: return new OperationInterruptedError(errorResponse);
+		case ErrorCode.RPC_TRANSPORT_ERROR: return new RPCTransportError(errorResponse, options);
+		case ErrorCode.VALIDATION_FAILED: return new ValidationFailedError(errorResponse);
+		case ErrorCode.INVALID_JSON_RESPONSE:
+		case ErrorCode.UNKNOWN_ERROR:
+		case ErrorCode.INTERNAL_ERROR: return new SandboxError(errorResponse);
+		default: return new SandboxError(errorResponse);
+	}
+}
+
+//#endregion
+export { PortError as A, SessionAlreadyExistsError as B, InterpreterNotReadyError as C, OperationInterruptedError as D, InvalidPortError as E, ProcessNotFoundError as F, SessionTerminatedError as H, ProcessReadyTimeoutError as I, RPCTransportError as L, PortNotExposedError as M, ProcessError as N, PermissionDeniedError as O, ProcessExitedBeforeReadyError as P, SandboxError as R, GitRepositoryNotFoundError as S, InvalidGitUrlError as T, ValidationFailedError as U, SessionDestroyedError as V, GitBranchNotFoundError as _, BackupRestoreError as a, GitError as b, CommandNotFoundError as c, CustomDomainRequiredError as d, FileExistsError as f, GitAuthenticationError as g, FileTooLargeError as h, BackupNotFoundError as i, PortInUseError as j, PortAlreadyExposedError as k, ContainerUnavailableError as l, FileSystemError as m, BackupCreateError as n, CodeExecutionError as o, FileNotFoundError as p, BackupExpiredError as r, CommandError as s, createErrorFromResponse as t, ContextNotFoundError as u, GitCheckoutError as v, InvalidBackupConfigError as w, GitNetworkError as x, GitCloneError as y, ServiceNotRespondingError as z };
+//# sourceMappingURL=errors-ewgSNicb.js.map