@sandbox-kit/daytona 0.0.0-stage → 0.1.0

package/dist/provider_mappings.js

@@ -0,0 +1,274 @@
+// 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 } 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, "lifetime.idle_stop", "duration is required", operation);
+            const afterMs = policy.after;
+            if (afterMs === 0)
+                mappingError(ErrorKind.Unsupported, "lifetime.idle_stop", "immediate action is not representable", operation);
+            if (!Number.isFinite(afterMs) || afterMs < 0 || afterMs % 60_000 !== 0)
+                mappingError(ErrorKind.InvalidArgument, "lifetime.idle_stop", "delay cannot be represented in whole minutes", operation);
+            const minutes = afterMs / 60_000;
+            target.autoStopInterval = minutes;
+        }
+        else if (mode !== PolicyMode.Default) {
+            mappingError(ErrorKind.InvalidArgument, "lifetime.idle_stop", "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, "lifetime.idle_pause", "duration is required", operation);
+            const afterMs = policy.after;
+            if (afterMs === 0)
+                mappingError(ErrorKind.Unsupported, "lifetime.idle_pause", "immediate action is not representable", operation);
+            if (!Number.isFinite(afterMs) || afterMs < 0 || afterMs % 60_000 !== 0)
+                mappingError(ErrorKind.InvalidArgument, "lifetime.idle_pause", "delay cannot be represented in whole minutes", operation);
+            const minutes = afterMs / 60_000;
+            target.autoPauseInterval = minutes;
+        }
+        else if (mode !== PolicyMode.Default) {
+            mappingError(ErrorKind.InvalidArgument, "lifetime.idle_pause", "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, "lifetime.stopped_archive", "explicit disabling is not representable", operation);
+        }
+        else if (mode === PolicyMode.After) {
+            if (policy.after === undefined)
+                mappingError(ErrorKind.InvalidArgument, "lifetime.stopped_archive", "duration is required", operation);
+            const afterMs = policy.after;
+            if (afterMs === 0)
+                mappingError(ErrorKind.Unsupported, "lifetime.stopped_archive", "immediate action is not representable", operation);
+            if (!Number.isFinite(afterMs) || afterMs < 0 || afterMs % 60_000 !== 0)
+                mappingError(ErrorKind.InvalidArgument, "lifetime.stopped_archive", "delay cannot be represented in whole minutes", operation);
+            const minutes = afterMs / 60_000;
+            if (minutes > 43200)
+                mappingError(ErrorKind.InvalidArgument, "lifetime.stopped_archive", "delay exceeds documented maximum", operation);
+            target.autoArchiveInterval = minutes;
+        }
+        else if (mode !== PolicyMode.Default) {
+            mappingError(ErrorKind.InvalidArgument, "lifetime.stopped_archive", "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, "lifetime.stopped_delete", "explicit disabling is not representable", operation);
+        }
+        else if (mode === PolicyMode.After) {
+            if (policy.after === undefined)
+                mappingError(ErrorKind.InvalidArgument, "lifetime.stopped_delete", "duration is required", operation);
+            const afterMs = policy.after;
+            if (!Number.isFinite(afterMs) || afterMs < 0 || afterMs % 60_000 !== 0)
+                mappingError(ErrorKind.InvalidArgument, "lifetime.stopped_delete", "delay cannot be represented in whole minutes", operation);
+            const minutes = afterMs / 60_000;
+            target.autoDeleteInterval = minutes;
+        }
+        else if (mode !== PolicyMode.Default) {
+            mappingError(ErrorKind.InvalidArgument, "lifetime.stopped_delete", "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, "resources.cpu_cores", "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, "resources.memory_mib", "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, "resources.disk_mib", "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["id"] = ValueOrigin.Provider;
+        }
+    }
+    {
+        if (source.name !== undefined) {
+            const value = source.name;
+            target.name = value;
+            origins["name"] = ValueOrigin.Provider;
+        }
+    }
+    {
+        if (source.state !== undefined) {
+            const value = source.state;
+            target.providerState = String(value);
+            origins["provider_state"] = ValueOrigin.Provider;
+        }
+    }
+    {
+        if (source.target !== undefined) {
+            const value = source.target;
+            target.region = value;
+            origins["region"] = ValueOrigin.Provider;
+        }
+    }
+    {
+        if (source.labels !== undefined) {
+            const value = source.labels;
+            target.labels = { ...value };
+            origins["labels"] = 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/package.json

@@ -1,6 +1,65 @@
 {
   "name": "@sandbox-kit/daytona",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "daytona provider for sandbox kit",
+  "license": "MIT",
+  "type": "module",
+  "packageManager": "npm@11.19.0",
+  "engines": {
+    "node": "^20.0.0 || ^22.0.0 || >=24.15.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sandbox-kit/kit.git",
+    "directory": "sdks/typescript/providers/daytona"
+  },
+  "homepage": "https://github.com/sandbox-kit/kit/tree/main/sdks/typescript/providers/daytona",
+  "bugs": {
+    "url": "https://github.com/sandbox-kit/kit/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "imports": {
+    "#mappings/*.js": {
+      "@sandbox-kit/source": "./src/mappings/*.ts",
+      "default": "./dist/mappings/*.js"
+    },
+    "#checks/*.js": {
+      "@sandbox-kit/source": "./src/checks/*.ts",
+      "default": "./dist/checks/*.js"
+    },
+    "#config/*.js": {
+      "@sandbox-kit/source": "./src/config/*.ts",
+      "default": "./dist/config/*.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run build",
+    "test": "tsc -p tsconfig.test.json && vitest run"
+  },
+  "dependencies": {
+    "@bufbuild/protobuf": "2.16.0",
+    "@daytona/sdk": "0.225.0",
+    "@sandbox-kit/sandbox": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "24.10.1",
+    "typescript": "5.9.3",
+    "vitest": "4.1.11"
+  }
+}