@sandbox-kit/daytona 0.0.0-stage → 0.1.0

package/dist/mappings/mappings.js

@@ -0,0 +1,341 @@
+// Provider-specific orchestration around generated portable field mappings.
+import { EgressMode, ErrorKind, IsolationKind, SandboxState, SecretInjection, SnapshotKind, ValueOrigin, WaitCondition, sandboxError, CreateFieldIsolation, CreateFieldNetwork, CreateFieldNetworkEgress, CreateFieldNetworkLinkedSandbox, CreateFieldObservabilityVerbose, CreateFieldPlacement, CreateFieldProvisioningWaitFor, CreateFieldReadiness, CreateFieldResources, CreateFieldResourcesCpuCores, CreateFieldRuntime, CreateFieldSecuritySecretsEnvironmentVariable, CreateFieldSecuritySecretsInjection, CreateFieldSourceSnapshotKind, CreateFieldRuntimeUser, CreateFieldSecuritySecretsReference, CreateFieldSecurityWorkloadIdentity, CreateFieldSourceImageReference, CreateFieldSourceSnapshotProviderKind, CreateFieldSourceSnapshotReference, CreateFieldSourceWarmPool, CreateFieldNetworkOutboundCidrs, CreateFieldNetworkOutboundDomains, CreateFieldLifetimeIdleTerminate, CreateFieldObservabilityTelemetryEndpoint, } from "@sandbox-kit/sandbox";
+import { metadataObjectFromMap } from "@sandbox-kit/sandbox";
+import {} from "@daytona/sdk";
+import { mapAllocatedResources as generatedMapAllocatedResources, mapCommonCreateFields as generatedMapCommonCreateFields, mapLifetimePolicies as generatedMapLifetimePolicies, mapResources as generatedMapResources, mapSandboxInfo as generatedMapSandboxInfo, } from "./provider_mappings.js";
+import { validateProviderCreate } from "#checks/provider_checks.js";
+import { mapGeneratedClientConfig, } from "#config/provider_config.js";
+export function mapClientConfig(config, environment) {
+    const result = mapGeneratedClientConfig(config, environment);
+    if (config.auth?.bearerToken !== undefined &&
+        config.scope?.organizationId === undefined)
+        configInvalid("scope.organizationId", "organization ID is required with bearer authentication");
+    return result;
+}
+export function mapCreateRequest(request) {
+    validateProviderCreate(request);
+    const base = generatedMapCommonCreateFields(request);
+    mapRuntime(request, base);
+    mapIsolation(request, base);
+    mapSecurity(request, base);
+    mapNetwork(request, base);
+    mapLifetime(request, base);
+    mapProvisioning(request, base);
+    mapObservability(request, base);
+    if (request.placement !== undefined)
+        unsupported(CreateFieldPlacement, "per-request Daytona placement is unsupported; use Config.region");
+    if (request.readiness !== undefined)
+        unsupported(CreateFieldReadiness, "Daytona readiness probes are not mapped");
+    if (request.providerOptions !== undefined)
+        unsupported("providerOptions", "Daytona provider options are not mapped");
+    const source = request.source;
+    if (source?.warmPool !== undefined)
+        unsupported(CreateFieldSourceWarmPool, "explicit warm-pool creation mapping is unavailable");
+    if (source?.image !== undefined)
+        return {
+            ...base,
+            image: nonblank(source.image.reference, CreateFieldSourceImageReference),
+            ...(request.resources === undefined
+                ? {}
+                : { resources: mapResources(request.resources) }),
+        };
+    if (request.resources !== undefined)
+        unsupported(CreateFieldResources, "Daytona resources require an image source");
+    if (source?.snapshot !== undefined) {
+        const snapshot = source.snapshot;
+        if ((snapshot.kind ?? SnapshotKind.Default) !== SnapshotKind.Default)
+            unsupported(CreateFieldSourceSnapshotKind, "explicit snapshot-kind restore mapping is unavailable");
+        if (snapshot.providerKind !== undefined)
+            unsupported(CreateFieldSourceSnapshotProviderKind, "provider snapshot kind is unsupported");
+        return {
+            ...base,
+            snapshot: nonblank(snapshot.reference, CreateFieldSourceSnapshotReference),
+        };
+    }
+    return { ...base };
+}
+function mapRuntime(request, target) {
+    const value = request.runtime;
+    if (value === undefined)
+        return;
+    if (value.language !== undefined)
+        target.language = value.language;
+    if (value.user !== undefined)
+        target.user = nonblank(value.user, CreateFieldRuntimeUser);
+    if (value.version !== undefined ||
+        value.workingDirectory !== undefined ||
+        value.entrypoint !== undefined ||
+        value.pty !== undefined)
+        unsupported(CreateFieldRuntime, "runtime version, working directory, entrypoint, and PTY are not mapped by Daytona");
+}
+function mapIsolation(request, target) {
+    const value = request.isolation;
+    if (value === undefined)
+        return;
+    if ((value.kind ?? IsolationKind.Default) !== IsolationKind.Default ||
+        value.providerKind !== undefined)
+        unsupported(CreateFieldIsolation, "Daytona isolation class comes from the selected source");
+    if (value.nestedVirtualization !== undefined)
+        target.kvm = value.nestedVirtualization;
+}
+function mapSecurity(request, target) {
+    const value = request.security;
+    if (value === undefined)
+        return;
+    if (value.publicAccess !== undefined)
+        target.public = value.publicAccess;
+    if (value.workloadIdentity !== undefined)
+        unsupported(CreateFieldSecurityWorkloadIdentity, "Daytona workload identity is not mapped");
+    if (value.secrets !== undefined) {
+        const secrets = {};
+        for (const secret of value.secrets) {
+            const variable = secret.environmentVariable === undefined
+                ? ""
+                : nonblank(secret.environmentVariable, CreateFieldSecuritySecretsEnvironmentVariable);
+            if (variable === "")
+                invalid(CreateFieldSecuritySecretsEnvironmentVariable, "secret environment variable is required");
+            const injection = secret.injection ?? SecretInjection.Default;
+            if (injection !== SecretInjection.Default &&
+                injection !== SecretInjection.EgressPlaceholder)
+                unsupported(CreateFieldSecuritySecretsInjection, "Daytona secrets require egress-placeholder injection");
+            if (Object.hasOwn(secrets, variable))
+                invalid(CreateFieldSecuritySecretsEnvironmentVariable, "duplicate secret environment variable");
+            secrets[variable] = nonblank(secret.reference, CreateFieldSecuritySecretsReference);
+        }
+        target.secrets = secrets;
+    }
+}
+function mapNetwork(request, target) {
+    const value = request.network;
+    if (value === undefined)
+        return;
+    if (value.linkedSandbox !== undefined && request.lifetime?.ephemeral !== true)
+        invalid(CreateFieldNetworkLinkedSandbox, "linked sandboxes must be ephemeral");
+    const egress = value.egress ?? EgressMode.Default;
+    if (egress === EgressMode.BlockAll)
+        target.networkBlockAll = true;
+    else if (egress !== EgressMode.Default &&
+        egress !== EgressMode.AllowAll &&
+        egress !== EgressMode.Restricted)
+        invalid(CreateFieldNetworkEgress, "unknown egress mode");
+    if (value.outboundCidrs !== undefined) {
+        if (!value.outboundCidrs.length)
+            unsupported(CreateFieldNetworkOutboundCidrs, "empty CIDR allowlist mapping is not verified");
+        target.networkAllowList = value.outboundCidrs.join(",");
+    }
+    if (value.outboundDomains !== undefined) {
+        if (!value.outboundDomains.length)
+            unsupported(CreateFieldNetworkOutboundDomains, "empty domain allowlist mapping is not verified");
+        target.domainAllowList = value.outboundDomains.join(",");
+    }
+    if (value.linkedSandbox !== undefined)
+        target.linkedSandbox = nonblank(value.linkedSandbox, CreateFieldNetworkLinkedSandbox);
+    if (value.outboundProxyUrl !== undefined)
+        target.outboundProxyUrl = value.outboundProxyUrl;
+    if (value.inboundCidrs !== undefined ||
+        value.privateNetwork !== undefined ||
+        value.proxyReference !== undefined ||
+        value.customDomain !== undefined ||
+        value.ports !== undefined)
+        unsupported(CreateFieldNetwork, "one or more Daytona network fields are not mapped");
+}
+function mapLifetime(request, target) {
+    const value = request.lifetime;
+    if (value === undefined)
+        return;
+    Object.assign(target, generatedMapLifetimePolicies(value));
+    if (value.ephemeral !== undefined)
+        target.ephemeral = value.ephemeral;
+    if (value.maximumLifetime !== undefined)
+        target.ttlMinutes = wholeMinutes(value.maximumLifetime, "lifetime.maximumLifetime", true);
+    if (value.idleTerminate !== undefined)
+        unsupported(CreateFieldLifetimeIdleTerminate, "Daytona idle termination is not mapped");
+}
+function mapProvisioning(request, target) {
+    const value = request.provisioning;
+    if (value === undefined)
+        return;
+    if (value.queueTimeout !== undefined)
+        target.queueTimeout = wholeMinutes(value.queueTimeout, "provisioning.queueTimeout", false);
+    const waitFor = value.waitFor ?? WaitCondition.Default;
+    if (waitFor !== WaitCondition.Default && waitFor !== WaitCondition.Started)
+        unsupported(CreateFieldProvisioningWaitFor, "the Daytona TypeScript SDK only returns after startup");
+}
+function mapObservability(request, target) {
+    const value = request.observability;
+    if (value === undefined)
+        return;
+    if (value.telemetryEndpoint !== undefined)
+        target.otelEndpointOverride = nonblank(value.telemetryEndpoint, CreateFieldObservabilityTelemetryEndpoint);
+    if (value.verbose !== undefined)
+        unsupported(CreateFieldObservabilityVerbose, "Daytona verbose creation is not mapped");
+}
+function mapResources(value) {
+    if (value.cpuCores !== undefined && value.cpuCores <= 0)
+        invalid(CreateFieldResourcesCpuCores, "CPU must be positive");
+    if (value.cpuLimitCores !== undefined || value.memoryLimitMib !== undefined)
+        unsupported(CreateFieldResources, "Daytona resource limits are not mapped");
+    return generatedMapResources(value);
+}
+function wholeMinutes(value, field, zeroAllowed) {
+    if (!Number.isFinite(value) ||
+        value < 0 ||
+        value % 60_000 !== 0 ||
+        value / 60_000 > 2_147_483_647 ||
+        (!zeroAllowed && value === 0))
+        invalid(field, "duration must be representable in whole minutes");
+    return value / 60_000;
+}
+export function mapSandboxInfo(value, operation = "create") {
+    const mapped = generatedMapSandboxInfo(value, operation);
+    const origins = { ...(mapped.origins ?? {}) };
+    const state = mapState(value.state === undefined ? undefined : String(value.state));
+    const result = {
+        ...mapped,
+        id: mapped.id ?? value.id,
+        provider: "daytona",
+        state,
+        labels: mapped.labels ?? {},
+        origins,
+    };
+    const resources = generatedMapAllocatedResources(value, operation);
+    if (Object.keys(resources).length > 0) {
+        resultMutable(result).resources = resources;
+        origins.resources = ValueOrigin.Provider;
+    }
+    if (value.sandboxClass !== undefined) {
+        const native = String(value.sandboxClass);
+        resultMutable(result).isolation =
+            native === "container"
+                ? { kind: IsolationKind.Container }
+                : native === "linux-vm"
+                    ? { kind: IsolationKind.LinuxVm }
+                    : { kind: IsolationKind.ProviderSpecific, providerKind: native };
+        origins.isolation = ValueOrigin.Provider;
+    }
+    if (state === SandboxState.Deleted) {
+        resultMutable(result).terminal = true;
+        origins.terminal = ValueOrigin.Provider;
+    }
+    const metadata = {};
+    if (value.gpu > 0)
+        metadata.gpu_count = value.gpu;
+    if (value.gpuType !== undefined)
+        metadata.gpu_type = String(value.gpuType);
+    if (value.desiredState !== undefined)
+        metadata.desired_state = String(value.desiredState);
+    if (value.errorReason !== undefined)
+        metadata.error_reason = value.errorReason;
+    if (value.recoverable !== undefined)
+        metadata.recoverable = value.recoverable;
+    if (value.spot === true)
+        metadata.spot = true;
+    for (const [key, entry] of [
+        ["spot_evicted_at", value.spotEvictedAt],
+        ["backup_state", value.backupState],
+        ["backup_created_at", value.backupCreatedAt],
+        ["updated_at", value.updatedAt],
+        ["last_activity_at", value.lastActivityAt],
+        ["auto_destroy_at", value.autoDestroyAt],
+        ["queue_timed_out_at", value.queueTimedOutAt],
+        ["snapshot", value.snapshot],
+        ["warm_pool_id", value.warmPoolId],
+    ])
+        if (entry !== undefined)
+            metadata[key] = String(entry);
+    for (const [key, entry] of [
+        ["auto_stop_interval_minutes", value.autoStopInterval],
+        ["auto_pause_interval_minutes", value.autoPauseInterval],
+        ["auto_archive_interval_minutes", value.autoArchiveInterval],
+        ["auto_delete_interval_minutes", value.autoDeleteInterval],
+    ])
+        if (entry !== undefined)
+            metadata[key] = entry;
+    if (Object.keys(metadata).length > 0) {
+        const providerMetadata = metadataObjectFromMap(metadata);
+        if (providerMetadata !== undefined) {
+            resultMutable(result).providerMetadata = providerMetadata;
+            origins.provider_metadata = ValueOrigin.Provider;
+        }
+    }
+    if (value.createdAt !== undefined) {
+        const date = new Date(value.createdAt);
+        if (!Number.isNaN(date.valueOf())) {
+            resultMutable(result).createdAt = date;
+            origins.created_at = ValueOrigin.Provider;
+        }
+    }
+    return result;
+}
+function resultMutable(value) {
+    return value;
+}
+function mapState(value) {
+    switch (value) {
+        case "creating":
+        case "restoring":
+        case "pending_build":
+        case "building_snapshot":
+        case "pulling_snapshot":
+        case "forking":
+            return SandboxState.Queued;
+        case "starting":
+        case "resuming":
+            return SandboxState.Starting;
+        case "started":
+            return SandboxState.Running;
+        case "stopping":
+            return SandboxState.Stopping;
+        case "stopped":
+            return SandboxState.Stopped;
+        case "pausing":
+            return SandboxState.Pausing;
+        case "paused":
+            return SandboxState.Paused;
+        case "archiving":
+            return SandboxState.Archiving;
+        case "archived":
+            return SandboxState.Archived;
+        case "destroying":
+            return SandboxState.Deleting;
+        case "destroyed":
+            return SandboxState.Deleted;
+        case "error":
+        case "build_failed":
+            return SandboxState.Error;
+        default:
+            return SandboxState.Unknown;
+    }
+}
+function nonblank(value, field) {
+    if (value.trim() === "")
+        invalid(field, "value must not be blank");
+    return value;
+}
+function invalid(field, message) {
+    throw sandboxError({
+        kind: ErrorKind.InvalidArgument,
+        provider: "daytona",
+        operation: "create",
+        field,
+        message: "sandbox-kit daytona: " + message,
+    });
+}
+function unsupported(field, message) {
+    throw sandboxError({
+        kind: ErrorKind.Unsupported,
+        provider: "daytona",
+        operation: "create",
+        field,
+        message: "sandbox-kit daytona: " + message,
+    });
+}
+function configInvalid(field, message) {
+    throw sandboxError({
+        kind: ErrorKind.InvalidArgument,
+        provider: "daytona",
+        operation: "initialize",
+        field,
+        message: "sandbox-kit daytona: " + message,
+    });
+}

package/dist/mappings/provider_mappings.d.ts

@@ -0,0 +1,14 @@
+import { type SandboxInfo, type Scope } from "@sandbox-kit/sandbox";
+import type { APIKeyCredentials, BearerTokenCredentials, Config, CreateOptions, Resources } from "@sandbox-kit/sandbox";
+import type { CreateSandboxBaseParams as NativeCreateSandboxBaseParams, DaytonaConfig as NativeDaytonaConfig, Resources as NativeResources, Sandbox as NativeSandbox } from "@daytona/sdk";
+type PublicLifetime = NonNullable<CreateOptions["lifetime"]>;
+export declare function mapLifetimePolicies(source: PublicLifetime | undefined, operation?: string): NativeCreateSandboxBaseParams;
+export declare function mapCommonCreateFields(source: CreateOptions | undefined, operation?: string): NativeCreateSandboxBaseParams;
+export declare function mapResources(source: Resources | undefined, operation?: string): NativeResources;
+export declare function mapSandboxInfo(source: NativeSandbox | undefined, operation?: string): Partial<SandboxInfo>;
+export declare function mapAllocatedResources(source: NativeSandbox | undefined, operation?: string): Partial<Resources>;
+export declare function mapClientSettings(source: Config | undefined, operation?: string): NativeDaytonaConfig;
+export declare function mapAPIKeyCredentials(source: APIKeyCredentials | undefined, operation?: string): NativeDaytonaConfig;
+export declare function mapBearerAuth(source: BearerTokenCredentials | undefined, operation?: string): NativeDaytonaConfig;
+export declare function mapScope(source: Scope | undefined, operation?: string): NativeDaytonaConfig;
+export {};

package/dist/mappings/provider_mappings.js

@@ -0,0 +1,282 @@
+// Provider field mappings between shared CreateOptions/Config and the native SDK.
+// Inventoried in specs/providers/daytona.yaml groups; kept in sync by hand (not emitted).
+import { ErrorKind, PolicyMode, ValueOrigin, sandboxError, CreateFieldLifetimeIdlePause, CreateFieldLifetimeIdleStop, CreateFieldLifetimeStoppedArchive, CreateFieldLifetimeStoppedDelete, CreateFieldResourcesCpuCores, CreateFieldResourcesDiskMib, CreateFieldResourcesMemoryMib, InfoFieldId, InfoFieldLabels, InfoFieldName, InfoFieldProviderState, InfoFieldRegion, } from "@sandbox-kit/sandbox";
+export function mapLifetimePolicies(source, operation = "create") {
+    const target = {};
+    if (source === undefined)
+        return target;
+    if (source.idleStop !== undefined) {
+        const policy = source.idleStop;
+        const mode = policy.mode ?? PolicyMode.Default;
+        if (mode === PolicyMode.Disabled) {
+            target.autoStopInterval = 0;
+        }
+        else if (mode === PolicyMode.After) {
+            if (policy.after === undefined)
+                mappingError(ErrorKind.InvalidArgument, CreateFieldLifetimeIdleStop, "duration is required", operation);
+            const afterMs = policy.after;
+            if (afterMs === 0)
+                mappingError(ErrorKind.Unsupported, CreateFieldLifetimeIdleStop, "immediate action is not representable", operation);
+            if (!Number.isFinite(afterMs) || afterMs < 0 || afterMs % 60_000 !== 0)
+                mappingError(ErrorKind.InvalidArgument, CreateFieldLifetimeIdleStop, "delay cannot be represented in whole minutes", operation);
+            const minutes = afterMs / 60_000;
+            target.autoStopInterval = minutes;
+        }
+        else if (mode !== PolicyMode.Default) {
+            mappingError(ErrorKind.InvalidArgument, CreateFieldLifetimeIdleStop, "unknown policy mode", operation);
+        }
+    }
+    if (source.idlePause !== undefined) {
+        const policy = source.idlePause;
+        const mode = policy.mode ?? PolicyMode.Default;
+        if (mode === PolicyMode.Disabled) {
+            target.autoPauseInterval = 0;
+        }
+        else if (mode === PolicyMode.After) {
+            if (policy.after === undefined)
+                mappingError(ErrorKind.InvalidArgument, CreateFieldLifetimeIdlePause, "duration is required", operation);
+            const afterMs = policy.after;
+            if (afterMs === 0)
+                mappingError(ErrorKind.Unsupported, CreateFieldLifetimeIdlePause, "immediate action is not representable", operation);
+            if (!Number.isFinite(afterMs) || afterMs < 0 || afterMs % 60_000 !== 0)
+                mappingError(ErrorKind.InvalidArgument, CreateFieldLifetimeIdlePause, "delay cannot be represented in whole minutes", operation);
+            const minutes = afterMs / 60_000;
+            target.autoPauseInterval = minutes;
+        }
+        else if (mode !== PolicyMode.Default) {
+            mappingError(ErrorKind.InvalidArgument, CreateFieldLifetimeIdlePause, "unknown policy mode", operation);
+        }
+    }
+    if (source.stoppedArchive !== undefined) {
+        const policy = source.stoppedArchive;
+        const mode = policy.mode ?? PolicyMode.Default;
+        if (mode === PolicyMode.Disabled) {
+            mappingError(ErrorKind.Unsupported, CreateFieldLifetimeStoppedArchive, "explicit disabling is not representable", operation);
+        }
+        else if (mode === PolicyMode.After) {
+            if (policy.after === undefined)
+                mappingError(ErrorKind.InvalidArgument, CreateFieldLifetimeStoppedArchive, "duration is required", operation);
+            const afterMs = policy.after;
+            if (afterMs === 0)
+                mappingError(ErrorKind.Unsupported, CreateFieldLifetimeStoppedArchive, "immediate action is not representable", operation);
+            if (!Number.isFinite(afterMs) || afterMs < 0 || afterMs % 60_000 !== 0)
+                mappingError(ErrorKind.InvalidArgument, CreateFieldLifetimeStoppedArchive, "delay cannot be represented in whole minutes", operation);
+            const minutes = afterMs / 60_000;
+            if (minutes > 43200)
+                mappingError(ErrorKind.InvalidArgument, CreateFieldLifetimeStoppedArchive, "delay exceeds documented maximum", operation);
+            target.autoArchiveInterval = minutes;
+        }
+        else if (mode !== PolicyMode.Default) {
+            mappingError(ErrorKind.InvalidArgument, CreateFieldLifetimeStoppedArchive, "unknown policy mode", operation);
+        }
+    }
+    if (source.stoppedDelete !== undefined) {
+        const policy = source.stoppedDelete;
+        const mode = policy.mode ?? PolicyMode.Default;
+        if (mode === PolicyMode.Disabled) {
+            mappingError(ErrorKind.Unsupported, CreateFieldLifetimeStoppedDelete, "explicit disabling is not representable", operation);
+        }
+        else if (mode === PolicyMode.After) {
+            if (policy.after === undefined)
+                mappingError(ErrorKind.InvalidArgument, CreateFieldLifetimeStoppedDelete, "duration is required", operation);
+            const afterMs = policy.after;
+            if (!Number.isFinite(afterMs) || afterMs < 0 || afterMs % 60_000 !== 0)
+                mappingError(ErrorKind.InvalidArgument, CreateFieldLifetimeStoppedDelete, "delay cannot be represented in whole minutes", operation);
+            const minutes = afterMs / 60_000;
+            target.autoDeleteInterval = minutes;
+        }
+        else if (mode !== PolicyMode.Default) {
+            mappingError(ErrorKind.InvalidArgument, CreateFieldLifetimeStoppedDelete, "unknown policy mode", operation);
+        }
+    }
+    return target;
+}
+export function mapCommonCreateFields(source, operation = "create") {
+    const target = {};
+    if (source === undefined)
+        return target;
+    {
+        if (source.name !== undefined) {
+            const value = source.name;
+            target.name = value;
+        }
+    }
+    {
+        if (source.environment !== undefined) {
+            const value = source.environment;
+            target.envVars = { ...value };
+        }
+    }
+    {
+        if (source.labels !== undefined) {
+            const value = source.labels;
+            target.labels = { ...value };
+        }
+    }
+    return target;
+}
+export function mapResources(source, operation = "create") {
+    const target = {};
+    if (source === undefined)
+        return target;
+    {
+        if (source.cpuCores !== undefined) {
+            const value = source.cpuCores;
+            if (!Number.isInteger(value) || value > 2147483647)
+                mappingError(ErrorKind.InvalidArgument, CreateFieldResourcesCpuCores, "cpu_cores cannot be represented", operation);
+            target.cpu = Number(value);
+        }
+    }
+    {
+        if (source.memoryMib !== undefined) {
+            const value = source.memoryMib;
+            if (value % 1024n !== 0n || value / 1024n > 2147483647n)
+                mappingError(ErrorKind.InvalidArgument, CreateFieldResourcesMemoryMib, "memory_mib cannot be represented", operation);
+            target.memory = Number(value / 1024n);
+        }
+    }
+    {
+        if (source.diskMib !== undefined) {
+            const value = source.diskMib;
+            if (value % 1024n !== 0n || value / 1024n > 2147483647n)
+                mappingError(ErrorKind.InvalidArgument, CreateFieldResourcesDiskMib, "disk_mib cannot be represented", operation);
+            target.disk = Number(value / 1024n);
+        }
+    }
+    return target;
+}
+export function mapSandboxInfo(source, operation = "create") {
+    const target = {};
+    if (source === undefined)
+        return target;
+    const origins = {};
+    target.origins = origins;
+    {
+        if (source.id !== undefined) {
+            const value = source.id;
+            target.id = value;
+            origins[InfoFieldId] = ValueOrigin.Provider;
+        }
+    }
+    {
+        if (source.name !== undefined) {
+            const value = source.name;
+            target.name = value;
+            origins[InfoFieldName] = ValueOrigin.Provider;
+        }
+    }
+    {
+        if (source.state !== undefined) {
+            const value = source.state;
+            target.providerState = String(value);
+            origins[InfoFieldProviderState] = ValueOrigin.Provider;
+        }
+    }
+    {
+        if (source.target !== undefined) {
+            const value = source.target;
+            target.region = value;
+            origins[InfoFieldRegion] = ValueOrigin.Provider;
+        }
+    }
+    {
+        if (source.labels !== undefined) {
+            const value = source.labels;
+            target.labels = { ...value };
+            origins[InfoFieldLabels] = ValueOrigin.Provider;
+        }
+    }
+    target.provider = "daytona";
+    return target;
+}
+export function mapAllocatedResources(source, operation = "create") {
+    const target = {};
+    if (source === undefined)
+        return target;
+    if (!((source.cpu ?? 0) > 0 &&
+        (source.memory ?? 0) > 0 &&
+        (source.disk ?? 0) > 0))
+        return target;
+    {
+        if (source.cpu !== undefined) {
+            const value = source.cpu;
+            target.cpuCores = Number(value);
+        }
+    }
+    {
+        if (source.memory !== undefined) {
+            const value = source.memory;
+            if (!Number.isSafeInteger(value) || value < 0)
+                mappingError(ErrorKind.InvalidResponse, "memory", "memory cannot be represented", operation);
+            target.memoryMib = BigInt(value) * 1024n;
+        }
+    }
+    {
+        if (source.disk !== undefined) {
+            const value = source.disk;
+            if (!Number.isSafeInteger(value) || value < 0)
+                mappingError(ErrorKind.InvalidResponse, "disk", "disk cannot be represented", operation);
+            target.diskMib = BigInt(value) * 1024n;
+        }
+    }
+    return target;
+}
+export function mapClientSettings(source, operation = "initialize") {
+    const target = {};
+    if (source === undefined)
+        return target;
+    {
+        if (source.endpoint !== undefined) {
+            const value = source.endpoint;
+            target.apiUrl = value;
+        }
+    }
+    {
+        if (source.region !== undefined) {
+            const value = source.region;
+            target.target = value;
+        }
+    }
+    return target;
+}
+export function mapAPIKeyCredentials(source, operation = "initialize") {
+    const target = {};
+    if (source === undefined)
+        return target;
+    {
+        const value = source.key;
+        target.apiKey = value;
+    }
+    return target;
+}
+export function mapBearerAuth(source, operation = "initialize") {
+    const target = {};
+    if (source === undefined)
+        return target;
+    {
+        const value = source.token;
+        target.jwtToken = value;
+    }
+    return target;
+}
+export function mapScope(source, operation = "initialize") {
+    const target = {};
+    if (source === undefined)
+        return target;
+    {
+        if (source.organizationId !== undefined) {
+            const value = source.organizationId;
+            target.organizationId = value;
+        }
+    }
+    return target;
+}
+function mappingError(kind, field, message, operation) {
+    throw sandboxError({
+        kind,
+        provider: "daytona",
+        operation,
+        field,
+        message: "sandbox-kit daytona: " + message,
+    });
+}

package/dist/mappings.d.ts

@@ -0,0 +1,8 @@
+import { type Config, type CreateOptions, type SandboxInfo } from "@sandbox-kit/sandbox";
+import { type CreateSandboxFromImageParams, type CreateSandboxFromSnapshotParams, type DaytonaConfig, type Sandbox as DaytonaSandbox } from "@daytona/sdk";
+import { type Environment } from "./provider_config.js";
+export type DaytonaCreateParams = CreateSandboxFromImageParams | CreateSandboxFromSnapshotParams;
+export declare function mapClientConfig(config: Config, environment?: Environment): DaytonaConfig;
+export declare function mapCreateRequest(request: CreateOptions): DaytonaCreateParams;
+export declare function mapSandboxInfo(value: DaytonaSandbox, operation?: string): SandboxInfo;
+//# sourceMappingURL=mappings.d.ts.map