@arker-ai/sdk 0.5.1 → 0.6.2

package/dist/modal.d.cts

@@ -0,0 +1,49 @@
+import { U as UniversalSandbox } from './common-C5zJ-LkS.cjs';
+import { A as ArkerComputeProviderConfig } from './arker-provider-DwUib5ZW.cjs';
+import 'computesdk';
+import './index.cjs';
+
+interface ModalCompatConfig {
+    /** Modal token ID used only for native Modal fallback. */
+    tokenId?: string;
+    /** Modal token secret used only for native Modal fallback. */
+    tokenSecret?: string;
+    /** Arker provider options. Falls back to ARKER_* environment variables. */
+    arker?: ArkerComputeProviderConfig;
+}
+interface ModalExecOptions {
+    workdir?: string;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+    stdout?: "pipe";
+    stderr?: "pipe";
+    mode?: "text";
+}
+declare class ModalProcess {
+    #private;
+    readonly stdout: {
+        readText: () => Promise<string>;
+    };
+    readonly stderr: {
+        readText: () => Promise<string>;
+    };
+    constructor(out: string, err: string, exitCode: number);
+    wait(): Promise<number>;
+}
+declare class Sandbox {
+    #private;
+    readonly sandboxId: string;
+    constructor(box: UniversalSandbox);
+    exec(cmd: string[] | string, opts?: ModalExecOptions): Promise<ModalProcess>;
+    terminate(): Promise<void>;
+}
+declare class ModalClient {
+    #private;
+    constructor(config?: ModalCompatConfig);
+    readonly sandboxes: {
+        create: (...args: unknown[]) => Promise<Sandbox>;
+        fromId: (sandboxId: string) => Promise<Sandbox>;
+    };
+}
+
+export { ModalClient, type ModalCompatConfig, Sandbox };

package/dist/modal.d.ts

@@ -0,0 +1,49 @@
+import { U as UniversalSandbox } from './common-C5zJ-LkS.js';
+import { A as ArkerComputeProviderConfig } from './arker-provider-BNIL8NdM.js';
+import 'computesdk';
+import './index.js';
+
+interface ModalCompatConfig {
+    /** Modal token ID used only for native Modal fallback. */
+    tokenId?: string;
+    /** Modal token secret used only for native Modal fallback. */
+    tokenSecret?: string;
+    /** Arker provider options. Falls back to ARKER_* environment variables. */
+    arker?: ArkerComputeProviderConfig;
+}
+interface ModalExecOptions {
+    workdir?: string;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+    stdout?: "pipe";
+    stderr?: "pipe";
+    mode?: "text";
+}
+declare class ModalProcess {
+    #private;
+    readonly stdout: {
+        readText: () => Promise<string>;
+    };
+    readonly stderr: {
+        readText: () => Promise<string>;
+    };
+    constructor(out: string, err: string, exitCode: number);
+    wait(): Promise<number>;
+}
+declare class Sandbox {
+    #private;
+    readonly sandboxId: string;
+    constructor(box: UniversalSandbox);
+    exec(cmd: string[] | string, opts?: ModalExecOptions): Promise<ModalProcess>;
+    terminate(): Promise<void>;
+}
+declare class ModalClient {
+    #private;
+    constructor(config?: ModalCompatConfig);
+    readonly sandboxes: {
+        create: (...args: unknown[]) => Promise<Sandbox>;
+        fromId: (sandboxId: string) => Promise<Sandbox>;
+    };
+}
+
+export { ModalClient, type ModalCompatConfig, Sandbox };

package/dist/modal.js

@@ -0,0 +1,130 @@
+import {
+  argvToCommand,
+  assertNoUnsupportedArgs,
+  assertSupportedObjectKeys,
+  createCompatSdk,
+  guardUnsupported,
+  isStringRecord
+} from "./chunk-35IEV6BU.js";
+import "./chunk-7BHPVQNG.js";
+
+// src/modal.ts
+import { modal as createModalProvider } from "@computesdk/modal";
+var MODAL_CONFIG_KEYS = ["tokenId", "tokenSecret", "arker"];
+var MODAL_EXEC_OPTION_KEYS = ["workdir", "env", "timeoutMs", "stdout", "stderr", "mode"];
+function lazyModalProvider(config) {
+  let provider = null;
+  const getProvider = () => {
+    provider ??= createModalProvider({
+      tokenId: config?.tokenId,
+      tokenSecret: config?.tokenSecret
+    });
+    return provider;
+  };
+  return {
+    name: "modal",
+    sandbox: {
+      create: (options) => getProvider().sandbox.create(options),
+      getById: (sandboxId) => getProvider().sandbox.getById(sandboxId),
+      destroy: (sandboxId) => getProvider().sandbox.destroy(sandboxId),
+      list: () => getProvider().sandbox.list()
+    }
+  };
+}
+function assertOptionValue(condition, message) {
+  if (!condition) throw new Error(message);
+}
+function toRunCommandOptions(opts) {
+  assertSupportedObjectKeys(opts, MODAL_EXEC_OPTION_KEYS, "modal", "Sandbox.exec");
+  if (opts === void 0) return void 0;
+  const modalOpts = opts;
+  assertOptionValue(
+    modalOpts.workdir === void 0 || typeof modalOpts.workdir === "string",
+    "Sandbox.exec option 'workdir' must be a string in the Arker compatibility layer for modal."
+  );
+  assertOptionValue(
+    modalOpts.timeoutMs === void 0 || typeof modalOpts.timeoutMs === "number",
+    "Sandbox.exec option 'timeoutMs' must be a number in the Arker compatibility layer for modal."
+  );
+  assertOptionValue(
+    modalOpts.env === void 0 || isStringRecord(modalOpts.env),
+    "Sandbox.exec option 'env' must be an object in the Arker compatibility layer for modal."
+  );
+  assertOptionValue(
+    modalOpts.stdout === void 0 || modalOpts.stdout === "pipe",
+    "Sandbox.exec only supports stdout: 'pipe' in the Arker compatibility layer for modal."
+  );
+  assertOptionValue(
+    modalOpts.stderr === void 0 || modalOpts.stderr === "pipe",
+    "Sandbox.exec only supports stderr: 'pipe' in the Arker compatibility layer for modal."
+  );
+  assertOptionValue(
+    modalOpts.mode === void 0 || modalOpts.mode === "text",
+    "Sandbox.exec only supports mode: 'text' in the Arker compatibility layer for modal."
+  );
+  const runOptions = {};
+  if (modalOpts.workdir !== void 0) runOptions.cwd = modalOpts.workdir;
+  if (modalOpts.env !== void 0) runOptions.env = modalOpts.env;
+  if (modalOpts.timeoutMs !== void 0) runOptions.timeout = modalOpts.timeoutMs;
+  return Object.keys(runOptions).length > 0 ? runOptions : void 0;
+}
+var ModalProcess = class {
+  stdout;
+  stderr;
+  #exitCode;
+  constructor(out, err, exitCode) {
+    this.#exitCode = exitCode;
+    this.stdout = { readText: async () => out };
+    this.stderr = { readText: async () => err };
+  }
+  async wait() {
+    return this.#exitCode;
+  }
+};
+var Sandbox = class {
+  sandboxId;
+  #box;
+  constructor(box) {
+    this.#box = box;
+    this.sandboxId = box.sandboxId;
+  }
+  async exec(cmd, opts) {
+    const command = argvToCommand(cmd);
+    const runOptions = toRunCommandOptions(opts);
+    const result = runOptions ? await this.#box.runCommand(command, runOptions) : await this.#box.runCommand(command);
+    return new ModalProcess(result.stdout, result.stderr, result.exitCode);
+  }
+  async terminate() {
+    await this.#box.destroy();
+  }
+};
+var ModalClient = class {
+  #sdk;
+  constructor(config) {
+    assertSupportedObjectKeys(config, MODAL_CONFIG_KEYS, "modal", "new ModalClient");
+    this.#sdk = createCompatSdk({
+      arker: config?.arker,
+      fallbackProvider: lazyModalProvider({
+        tokenId: config?.tokenId,
+        tokenSecret: config?.tokenSecret
+      })
+    });
+    return guardUnsupported(this, "modal");
+  }
+  sandboxes = {
+    create: async (...args) => {
+      assertNoUnsupportedArgs(args, "modal", "ModalClient.sandboxes.create");
+      const box = await this.#sdk.sandbox.create({});
+      return guardUnsupported(new Sandbox(box), "modal");
+    },
+    fromId: async (sandboxId) => {
+      const box = await this.#sdk.sandbox.getById(sandboxId);
+      if (!box) throw new Error(`Sandbox ${sandboxId} not found`);
+      return guardUnsupported(new Sandbox(box), "modal");
+    }
+  };
+};
+export {
+  ModalClient,
+  Sandbox
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arker-ai/sdk",
-  "version": "0.5.1",
-  "description": "TypeScript SDK for the Arker virtual computer platform — spawn sandboxed VMs, run code, sync files.",
+  "version": "0.6.2",
+  "description": "TypeScript SDK for the Arker virtual computer platform \u2014 spawn sandboxed VMs, run code, sync files.",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
@@ -14,6 +14,21 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
+    },
+    "./daytona": {
+      "types": "./dist/daytona.d.ts",
+      "import": "./dist/daytona.js",
+      "require": "./dist/daytona.cjs"
+    },
+    "./e2b": {
+      "types": "./dist/e2b.d.ts",
+      "import": "./dist/e2b.js",
+      "require": "./dist/e2b.cjs"
+    },
+    "./modal": {
+      "types": "./dist/modal.d.ts",
+      "import": "./dist/modal.js",
+      "require": "./dist/modal.cjs"
     }
   },
   "files": [
@@ -25,12 +40,15 @@
     "node": ">=18"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/cli.ts --format esm,cjs --dts --clean --target=node18",
+    "build": "tsup src/index.ts src/cli.ts src/daytona.ts src/e2b.ts src/modal.ts --format esm,cjs --dts --clean --target=node18",
     "check:api-types": "openapi-typescript ../contract/openapi.json --default-non-nullable false -o src/generated/api-types.ts --check",
     "demo": "tsx tests/demo.ts",
     "generate:api-types": "openapi-typescript ../contract/openapi.json --default-non-nullable false -o src/generated/api-types.ts",
     "smoke": "tsx tests/conformance/fork-run-sync.ts",
-    "test": "tsx tests/unit.ts",
+    "test": "tsx tests/unit.ts && tsx tests/compat.ts && tsx tests/cli.ts",
+    "test:compat": "tsx tests/compat.ts",
+    "test:compat-live": "tsx tests/compat-live.ts",
+    "test:compat-fallback-live": "tsx tests/compat-fallback-live.ts",
     "typecheck": "tsc -p tsconfig.test.json",
     "prepublishOnly": "npm run build"
   },
@@ -51,9 +69,17 @@
   "bugs": "https://github.com/ArkerHQ/arker-sdk/issues",
   "devDependencies": {
     "@types/node": "^25.6.0",
+    "@types/ws": "^8.18.1",
     "openapi-typescript": "^7.13.0",
     "tsup": "^8.3.0",
     "tsx": "^4.19.0",
     "typescript": "^5.6.0"
+  },
+  "dependencies": {
+    "@computesdk/daytona": "^1.7.30",
+    "@computesdk/e2b": "^1.7.51",
+    "@computesdk/modal": "^1.9.3",
+    "computesdk": "^4.1.3",
+    "ws": "^8.21.0"
   }
 }