jiren 1.0.6 → 1.0.9

package/components/client.ts

@@ -1,5 +1,4 @@
-import { CString, type Pointer } from "bun:ffi";
-import { lib } from "./native";
+import { lib, readCString } from "./native";
 import type {
   RequestOptions,
   GetRequestOptions,
@@ -7,8 +6,10 @@ import type {
   HttpResponse,
 } from "../types";
 
+// Runtime-agnostic pointer type
+type Pointer = any;
 export class JirenClient {
-  private ptr: Pointer | null;
+  private ptr: unknown | null;
 
   constructor() {
     this.ptr = lib.symbols.zclient_new();
@@ -21,7 +22,7 @@ export class JirenClient {
    */
   public close(): void {
     if (this.ptr) {
-      lib.symbols.zclient_free(this.ptr);
+      lib.symbols.zclient_free(this.ptr as Pointer);
       this.ptr = null;
     }
   }
@@ -59,7 +60,7 @@ export class JirenClient {
     }
 
     const respPtr = lib.symbols.zclient_request(
-      this.ptr,
+      this.ptr as Pointer,
       methodBuffer,
       urlBuffer,
       headersBuffer,
@@ -132,7 +133,7 @@ export class JirenClient {
 
     for (const url of urls) {
       const urlBuffer = Buffer.from(url + "\0");
-      lib.symbols.zclient_prefetch(this.ptr, urlBuffer);
+      lib.symbols.zclient_prefetch(this.ptr as Pointer, urlBuffer);
     }
   }
 
@@ -151,15 +152,12 @@ export class JirenClient {
 
       let bodyString = "";
       if (bodyLen > 0 && bodyPtr) {
-        // CString uses the full length if not null-terminated or we can just read the ptr
-        // Since we know the length, we can be more precise, but CString assumes null-terminated
-        // for now we trust it is null terminated from Zig
-        bodyString = new CString(bodyPtr).toString();
+        bodyString = readCString(bodyPtr);
       }
 
       const headers: Record<string, string> = {};
       if (headersLen > 0 && headersPtr) {
-        const headersStr = new CString(headersPtr).toString();
+        const headersStr = readCString(headersPtr);
         const lines = headersStr.split("\r\n");
         for (const line of lines) {
           if (!line) continue;

package/components/native.ts

@@ -1,64 +1,182 @@
-import { dlopen, FFIType, suffix } from "bun:ffi";
-import { join } from "path";
+import { isBun } from "./runtime";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
 
-// Resolve library path relative to this module
-const libPath = join(import.meta.dir, `../lib/libhttpclient.${suffix}`);
+// Helper to get library path
+function getLibPath(): string {
+  if (isBun) {
+    // @ts-ignore - Bun-specific
+    const { suffix } = await import("bun:ffi");
+    return join(import.meta.dir, `../lib/libhttpclient.${suffix}`);
+  } else {
+    // Node.js
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const platform = process.platform;
+    const ext =
+      platform === "darwin" ? "dylib" : platform === "win32" ? "dll" : "so";
+    return join(__dirname, `../lib/libhttpclient.${ext}`);
+  }
+}
 
-export const ffiDef = {
-  zclient_new: {
-    args: [],
-    returns: FFIType.ptr,
-  },
-  zclient_free: {
-    args: [FFIType.ptr],
-    returns: FFIType.void,
-  },
-  zclient_get: {
-    args: [FFIType.ptr, FFIType.cstring],
-    returns: FFIType.ptr,
-  },
-  zclient_post: {
-    args: [FFIType.ptr, FFIType.cstring, FFIType.cstring],
-    returns: FFIType.ptr,
-  },
-  zclient_prefetch: {
-    args: [FFIType.ptr, FFIType.cstring],
-    returns: FFIType.void,
-  },
-  zclient_response_status: {
-    args: [FFIType.ptr],
-    returns: FFIType.u16,
-  },
-  zclient_response_body: {
-    args: [FFIType.ptr],
-    returns: FFIType.ptr,
-  },
-  zclient_response_body_len: {
-    args: [FFIType.ptr],
-    returns: FFIType.u64,
-  },
-  zclient_response_headers: {
-    args: [FFIType.ptr],
-    returns: FFIType.ptr,
-  },
-  zclient_response_headers_len: {
-    args: [FFIType.ptr],
-    returns: FFIType.u64,
-  },
-  zclient_response_free: {
-    args: [FFIType.ptr],
-    returns: FFIType.void,
-  },
-  zclient_request: {
-    args: [
-      FFIType.ptr, // client
-      FFIType.cstring, // method
-      FFIType.cstring, // url
-      FFIType.cstring, // headers (nullable)
-      FFIType.cstring, // body (nullable)
-    ],
-    returns: FFIType.ptr,
-  },
-} as const;
+// Type definitions for our FFI symbols
+export type NativeLib = {
+  symbols: {
+    zclient_new: () => any;
+    zclient_free: (ptr: any) => void;
+    zclient_get: (client: any, url: any) => any;
+    zclient_post: (client: any, url: any, body: any) => any;
+    zclient_prefetch: (client: any, url: any) => void;
+    zclient_response_status: (resp: any) => number;
+    zclient_response_body: (resp: any) => any;
+    zclient_response_body_len: (resp: any) => bigint | number;
+    zclient_response_headers: (resp: any) => any;
+    zclient_response_headers_len: (resp: any) => bigint | number;
+    zclient_response_free: (resp: any) => void;
+    zclient_request: (
+      client: any,
+      method: any,
+      url: any,
+      headers: any,
+      body: any
+    ) => any;
+  };
+};
 
-export const lib = dlopen(libPath, ffiDef);
+// Load the appropriate FFI library
+async function loadLibrary(): Promise<NativeLib> {
+  const libPath = getLibPath();
+
+  if (isBun) {
+    // Use Bun FFI
+    const { dlopen, FFIType } = await import("bun:ffi");
+
+    const ffiDef = {
+      zclient_new: { args: [], returns: FFIType.ptr },
+      zclient_free: { args: [FFIType.ptr], returns: FFIType.void },
+      zclient_get: {
+        args: [FFIType.ptr, FFIType.cstring],
+        returns: FFIType.ptr,
+      },
+      zclient_post: {
+        args: [FFIType.ptr, FFIType.cstring, FFIType.cstring],
+        returns: FFIType.ptr,
+      },
+      zclient_prefetch: {
+        args: [FFIType.ptr, FFIType.cstring],
+        returns: FFIType.void,
+      },
+      zclient_response_status: { args: [FFIType.ptr], returns: FFIType.u16 },
+      zclient_response_body: { args: [FFIType.ptr], returns: FFIType.ptr },
+      zclient_response_body_len: { args: [FFIType.ptr], returns: FFIType.u64 },
+      zclient_response_headers: { args: [FFIType.ptr], returns: FFIType.ptr },
+      zclient_response_headers_len: {
+        args: [FFIType.ptr],
+        returns: FFIType.u64,
+      },
+      zclient_response_free: { args: [FFIType.ptr], returns: FFIType.void },
+      zclient_request: {
+        args: [
+          FFIType.ptr,
+          FFIType.cstring,
+          FFIType.cstring,
+          FFIType.cstring,
+          FFIType.cstring,
+        ],
+        returns: FFIType.ptr,
+      },
+    };
+
+    return dlopen(libPath, ffiDef) as NativeLib;
+  } else {
+    // Use koffi for Node.js
+    const koffi = await import("koffi");
+
+    const nativeLib = koffi.load(libPath);
+
+    return {
+      symbols: {
+        zclient_new: nativeLib.func("zclient_new", "void*", []),
+        zclient_free: nativeLib.func("zclient_free", "void", ["void*"]),
+        zclient_get: nativeLib.func("zclient_get", "void*", ["void*", "str"]),
+        zclient_post: nativeLib.func("zclient_post", "void*", [
+          "void*",
+          "str",
+          "str",
+        ]),
+        zclient_prefetch: nativeLib.func("zclient_prefetch", "void", [
+          "void*",
+          "str",
+        ]),
+        zclient_response_status: nativeLib.func(
+          "zclient_response_status",
+          "uint16",
+          ["void*"]
+        ),
+        zclient_response_body: nativeLib.func(
+          "zclient_response_body",
+          "void*",
+          ["void*"]
+        ),
+        zclient_response_body_len: nativeLib.func(
+          "zclient_response_body_len",
+          "uint64",
+          ["void*"]
+        ),
+        zclient_response_headers: nativeLib.func(
+          "zclient_response_headers",
+          "void*",
+          ["void*"]
+        ),
+        zclient_response_headers_len: nativeLib.func(
+          "zclient_response_headers_len",
+          "uint64",
+          ["void*"]
+        ),
+        zclient_response_free: nativeLib.func("zclient_response_free", "void", [
+          "void*",
+        ]),
+        zclient_request: nativeLib.func("zclient_request", "void*", [
+          "void*",
+          "str",
+          "str",
+          "str",
+          "str",
+        ]),
+      },
+    };
+  }
+}
+
+// Export the loaded library (initialized on first import)
+export const lib: NativeLib = await loadLibrary();
+
+// Helper to read C string from pointer (runtime-agnostic)
+export function readCString(ptr: any): string {
+  if (!ptr) return "";
+
+  if (isBun) {
+    // For Bun, we need to dynamically get CString
+    // Use a simple approach: read bytes until null terminator
+    const view = new DataView(new ArrayBuffer(0));
+    try {
+      // In Bun, pointers can be read as buffers
+      // @ts-ignore - Bun specific
+      const buf = Buffer.from(ptr as any);
+      const nullIdx = buf.indexOf(0);
+      return buf.toString("utf8", 0, nullIdx >= 0 ? nullIdx : undefined);
+    } catch {
+      // Fallback: try to read as string directly
+      return String(ptr);
+    }
+  } else {
+    // Node.js with koffi
+    try {
+      const koffi = require("koffi");
+      return koffi.decode(ptr, "string");
+    } catch (e) {
+      console.error("Failed to decode C string:", e);
+      return "";
+    }
+  }
+}

package/components/runtime.ts

@@ -0,0 +1,17 @@
+/**
+ * Runtime detection utility for Jiren
+ * Detects whether we're running in Bun or Node.js
+ */
+
+export const isBun = typeof Bun !== "undefined";
+export const isNode =
+  !isBun &&
+  typeof process !== "undefined" &&
+  process.versions &&
+  process.versions.node;
+
+export function getRuntime(): "bun" | "node" | "unknown" {
+  if (isBun) return "bun";
+  if (isNode) return "node";
+  return "unknown";
+}

package/dist/components/native.d.ts

@@ -1,101 +1,18 @@
-import { FFIType } from "bun:ffi";
-export declare const ffiDef: {
-    readonly zclient_new: {
-        readonly args: readonly [];
-        readonly returns: FFIType.ptr;
-    };
-    readonly zclient_free: {
-        readonly args: readonly [FFIType.ptr];
-        readonly returns: FFIType.void;
-    };
-    readonly zclient_get: {
-        readonly args: readonly [FFIType.ptr, FFIType.cstring];
-        readonly returns: FFIType.ptr;
-    };
-    readonly zclient_post: {
-        readonly args: readonly [FFIType.ptr, FFIType.cstring, FFIType.cstring];
-        readonly returns: FFIType.ptr;
-    };
-    readonly zclient_prefetch: {
-        readonly args: readonly [FFIType.ptr, FFIType.cstring];
-        readonly returns: FFIType.void;
-    };
-    readonly zclient_response_status: {
-        readonly args: readonly [FFIType.ptr];
-        readonly returns: FFIType.uint16_t;
-    };
-    readonly zclient_response_body: {
-        readonly args: readonly [FFIType.ptr];
-        readonly returns: FFIType.ptr;
-    };
-    readonly zclient_response_body_len: {
-        readonly args: readonly [FFIType.ptr];
-        readonly returns: FFIType.uint64_t;
-    };
-    readonly zclient_response_headers: {
-        readonly args: readonly [FFIType.ptr];
-        readonly returns: FFIType.ptr;
-    };
-    readonly zclient_response_headers_len: {
-        readonly args: readonly [FFIType.ptr];
-        readonly returns: FFIType.uint64_t;
-    };
-    readonly zclient_response_free: {
-        readonly args: readonly [FFIType.ptr];
-        readonly returns: FFIType.void;
-    };
-    readonly zclient_request: {
-        readonly args: readonly [FFIType.ptr, FFIType.cstring, FFIType.cstring, FFIType.cstring, FFIType.cstring];
-        readonly returns: FFIType.ptr;
+export type NativeLib = {
+    symbols: {
+        zclient_new: () => any;
+        zclient_free: (ptr: any) => void;
+        zclient_get: (client: any, url: any) => any;
+        zclient_post: (client: any, url: any, body: any) => any;
+        zclient_prefetch: (client: any, url: any) => void;
+        zclient_response_status: (resp: any) => number;
+        zclient_response_body: (resp: any) => any;
+        zclient_response_body_len: (resp: any) => bigint | number;
+        zclient_response_headers: (resp: any) => any;
+        zclient_response_headers_len: (resp: any) => bigint | number;
+        zclient_response_free: (resp: any) => void;
+        zclient_request: (client: any, method: any, url: any, headers: any, body: any) => any;
     };
 };
-export declare const lib: import("bun:ffi").Library<{
-    readonly zclient_new: {
-        readonly args: readonly [];
-        readonly returns: FFIType.ptr;
-    };
-    readonly zclient_free: {
-        readonly args: readonly [FFIType.ptr];
-        readonly returns: FFIType.void;
-    };
-    readonly zclient_get: {
-        readonly args: readonly [FFIType.ptr, FFIType.cstring];
-        readonly returns: FFIType.ptr;
-    };
-    readonly zclient_post: {
-        readonly args: readonly [FFIType.ptr, FFIType.cstring, FFIType.cstring];
-        readonly returns: FFIType.ptr;
-    };
-    readonly zclient_prefetch: {
-        readonly args: readonly [FFIType.ptr, FFIType.cstring];
-        readonly returns: FFIType.void;
-    };
-    readonly zclient_response_status: {
-        readonly args: readonly [FFIType.ptr];
-        readonly returns: FFIType.uint16_t;
-    };
-    readonly zclient_response_body: {
-        readonly args: readonly [FFIType.ptr];
-        readonly returns: FFIType.ptr;
-    };
-    readonly zclient_response_body_len: {
-        readonly args: readonly [FFIType.ptr];
-        readonly returns: FFIType.uint64_t;
-    };
-    readonly zclient_response_headers: {
-        readonly args: readonly [FFIType.ptr];
-        readonly returns: FFIType.ptr;
-    };
-    readonly zclient_response_headers_len: {
-        readonly args: readonly [FFIType.ptr];
-        readonly returns: FFIType.uint64_t;
-    };
-    readonly zclient_response_free: {
-        readonly args: readonly [FFIType.ptr];
-        readonly returns: FFIType.void;
-    };
-    readonly zclient_request: {
-        readonly args: readonly [FFIType.ptr, FFIType.cstring, FFIType.cstring, FFIType.cstring, FFIType.cstring];
-        readonly returns: FFIType.ptr;
-    };
-}>;
+export declare const lib: NativeLib;
+export declare function readCString(ptr: any): string;

package/dist/components/runtime.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Runtime detection utility for Jiren
+ * Detects whether we're running in Bun or Node.js
+ */
+export declare const isBun: boolean;
+export declare const isNode: string | false;
+export declare function getRuntime(): "bun" | "node" | "unknown";

package/package.json

@@ -1,15 +1,17 @@
 {
   "name": "jiren",
-  "version": "1.0.6",
+  "version": "1.0.9",
   "author": "",
   "main": "index.ts",
   "module": "index.ts",
   "types": "dist/index.d.ts",
-  "dependencies": {
-    "@types/bun": "^1.3.4"
+  "dependencies": {},
+  "optionalDependencies": {
+    "koffi": "^2.9.0"
   },
   "devDependencies": {
-    "typescript": "^5"
+    "typescript": "^5",
+    "@types/bun": "^1.3.4"
   },
   "peerDependencies": {
     "typescript": "^5"