@indexable/sdk 0.0.4 → 0.2.1

package/npm/linux-x64-gnu/package.json

@@ -1,10 +1,17 @@
 {
 	"name": "@indexable/sdk-linux-x64-gnu",
-	"version": "0.0.4",
-	"os": ["linux"],
-	"cpu": ["x64"],
+	"version": "0.2.1",
+	"os": [
+		"linux"
+	],
+	"cpu": [
+		"x64"
+	],
 	"main": "ix-sdk.linux-x64-gnu.node",
-	"files": ["ix-sdk.linux-x64-gnu.node"],
+	"files": [
+		"ix-sdk.linux-x64-gnu.node",
+		"libix_sdk_ffi.so"
+	],
 	"license": "MIT",
 	"engines": {
 		"node": ">= 18"

package/package.json

@@ -1,25 +1,28 @@
 {
 	"name": "@indexable/sdk",
-	"version": "0.0.4",
+	"version": "0.2.1",
 	"type": "module",
 	"main": "./src/index.ts",
 	"exports": {
 		".": "./src/index.ts"
 	},
-	"files": ["src/", "npm/"],
+	"files": [
+		"src/",
+		"npm/"
+	],
 	"scripts": {
-		"build": "cargo build -p ix-sdk-napi --profile release-external --target x86_64-unknown-linux-gnu && cp ../../target/x86_64-unknown-linux-gnu/release-external/libix_sdk_napi.so npm/linux-x64-gnu/ix-sdk.linux-x64-gnu.node",
-		"test": "bun test src/",
+		"build": "bunx tsc --noEmit",
+		"build:native": "RUSTFLAGS='--cfg reqwest_unstable' cargo build -p ix-sdk-napi -p ix-sdk-ffi --profile release-external --target x86_64-unknown-linux-gnu && cp ../../target/x86_64-unknown-linux-gnu/release-external/libix_sdk_napi.so npm/linux-x64-gnu/ix-sdk.linux-x64-gnu.node && cp ../../target/x86_64-unknown-linux-gnu/release-external/libix_sdk_ffi.so npm/linux-x64-gnu/libix_sdk_ffi.so",
 		"typecheck": "bunx tsc --noEmit"
 	},
-	"optionalDependencies": {
-		"@indexable/sdk-linux-x64-gnu": "0.0.4"
+	"dependencies": {
+		"koffi": "^2.9.0"
 	},
 	"devDependencies": {
 		"bun-types": "latest"
 	},
 	"engines": {
-		"node": ">= 18"
+		"bun": ">= 1.0.0"
 	},
 	"license": "MIT"
 }

package/src/bindings.ts

@@ -0,0 +1,174 @@
+// UniFFI-generated TypeScript bindings for ix-sdk-ffi remain the public API.
+//
+// On Linux, Bun crashes in the koffi/UniFFI path for a narrow set of async VM
+// methods. Those methods are patched to a napi-rs backend built from the same
+// Rust SDK so Rust remains the single behavior owner.
+
+import { existsSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import {
+  IxSdkClient as GeneratedIxSdkClient,
+  type FfiBillingStatus,
+  type FfiCreateVmResult,
+  type FfiExecResult,
+  type FfiSpawnOptions,
+} from './generated/ix_sdk_ffi'
+
+export * from './generated/ix_sdk_ffi'
+
+type NativeIxSdkLinuxClient = {
+  billingStatus(): Promise<FfiBillingStatus>
+  spawn(
+    image: string,
+    name: string | null,
+    memoryMib: bigint | null,
+    cpuCores: bigint | null,
+    ipv4: boolean | null
+  ): Promise<string>
+  createVm(
+    id: string | null,
+    image: string,
+    name: string | null,
+    maxMemoryMib: bigint | null,
+    maxCpuCores: bigint | null,
+    enableIpv4: boolean | null,
+    waitUntilReady: boolean | null,
+    region: string | null
+  ): Promise<FfiCreateVmResult>
+  execVm(
+    vmId: string,
+    command: string[],
+    workingDir: string | null
+  ): Promise<FfiExecResult>
+  deleteVm(vmId: string): Promise<void>
+}
+
+type NativeAddon = {
+  IxSdkLinuxClient: new (server: string, token: string) => NativeIxSdkLinuxClient
+}
+
+const isLinux = process.platform === 'linux'
+const isBun = typeof process.versions?.bun === 'string'
+const linuxTripleDir = `${process.platform}-${process.arch}-gnu`
+const linuxAddonName = `ix-sdk.${linuxTripleDir}.node`
+const nativeClients = new WeakMap<GeneratedIxSdkClient, NativeIxSdkLinuxClient>()
+
+function loadNativeAddon(): NativeAddon {
+  const require = createRequire(import.meta.url)
+  const filename = fileURLToPath(import.meta.url)
+  const dirname = path.dirname(filename)
+  const addonPath = path.resolve(
+    dirname,
+    '..',
+    'npm',
+    linuxTripleDir,
+    linuxAddonName
+  )
+  if (!existsSync(addonPath)) {
+    throw new Error(`Missing Linux SDK addon at ${addonPath}`)
+  }
+  return require(addonPath) as NativeAddon
+}
+
+function nativeClient(client: GeneratedIxSdkClient): NativeIxSdkLinuxClient {
+  const native = nativeClients.get(client)
+  if (native) {
+    return native
+  }
+  throw new Error('Linux native SDK backend not initialized; use IxSdkClient.create()')
+}
+
+if (isLinux) {
+  const addon = loadNativeAddon()
+  const create = GeneratedIxSdkClient.create.bind(GeneratedIxSdkClient)
+  const supportedBunLinuxMethods = new Set([
+    'billingStatus',
+    'close',
+    'constructor',
+    'createVm',
+    'deleteVm',
+    'describe',
+    'execVm',
+    'filter',
+    'getFs',
+    'spawn',
+  ])
+
+  GeneratedIxSdkClient.create = (server: string, token: string): GeneratedIxSdkClient => {
+    const client = create(server, token)
+    nativeClients.set(client, new addon.IxSdkLinuxClient(server, token))
+    return client
+  }
+
+  GeneratedIxSdkClient.prototype.billingStatus = function (): Promise<FfiBillingStatus> {
+    return nativeClient(this).billingStatus()
+  }
+
+  GeneratedIxSdkClient.prototype.spawn = function (
+    image: string,
+    options: FfiSpawnOptions | null
+  ): Promise<string> {
+    return nativeClient(this).spawn(
+      image,
+      options?.name ?? null,
+      options?.memoryMib ?? null,
+      options?.cpuCores ?? null,
+      options?.ipv4 ?? null
+    )
+  }
+
+  GeneratedIxSdkClient.prototype.createVm = function (
+    id: string | null,
+    image: string,
+    name: string | null,
+    maxMemoryMib: bigint | null,
+    maxCpuCores: bigint | null,
+    enableIpv4: boolean | null,
+    waitUntilReady: boolean | null,
+    region: string | null
+  ): Promise<FfiCreateVmResult> {
+    return nativeClient(this).createVm(
+      id,
+      image,
+      name,
+      maxMemoryMib,
+      maxCpuCores,
+      enableIpv4,
+      waitUntilReady,
+      region
+    )
+  }
+
+  GeneratedIxSdkClient.prototype.execVm = function (
+    vmId: string,
+    command: string[],
+    workingDir: string | null
+  ): Promise<FfiExecResult> {
+    return nativeClient(this).execVm(vmId, command, workingDir)
+  }
+
+  GeneratedIxSdkClient.prototype.deleteVm = function (vmId: string): Promise<void> {
+    return nativeClient(this).deleteVm(vmId)
+  }
+
+  if (isBun) {
+    const prototype = GeneratedIxSdkClient.prototype as unknown as Record<string, unknown>
+    for (const methodName of Object.getOwnPropertyNames(prototype)) {
+      if (supportedBunLinuxMethods.has(methodName)) {
+        continue
+      }
+      const method = prototype[methodName]
+      if (typeof method !== 'function') {
+        continue
+      }
+      prototype[methodName] = function (): never {
+        throw new Error(
+          `IxSdkClient.${methodName} is disabled on Bun/Linux until it is ported to the native backend`
+        )
+      }
+    }
+  }
+}