@archildata/client 0.1.12 → 0.8.1

package/README.md

@@ -1,168 +1,310 @@
 # @archildata/client
 
-High-performance Node.js bindings for the Archil distributed filesystem client.
+Node.js client for [Archil](https://archil.com) — a high-performance distributed filesystem that turns your cloud storage (S3, GCS, Azure Blob, R2) into something you can read, write, and run commands against like a local disk.
 
-## Overview
+## Quick Start: Connect an S3 Bucket
 
-This package provides low-level N-API bindings to the Archil client library, exposing the `ArchilService` trait methods directly to JavaScript/TypeScript. It's designed for use cases where you need direct protocol access without FUSE overhead.
+This walks you through creating an Archil disk backed by your S3 bucket and running bash commands on it. The whole thing takes about two minutes.
 
-## Installation
+### 1. Sign up
+
+Go to [console.archil.com](https://console.archil.com) and create an account.
+
+### 2. Install
 
 ```bash
 npm install @archildata/client
 ```
 
-## Supported Platforms
+### 3. Create a disk
+
+An Archil "disk" is a filesystem that sits in front of your cloud storage. You create one by telling Archil which bucket to use. This doesn't move or copy your data — Archil reads and writes directly to your bucket.
+
+You also need to authorize a mount token on the disk. This is a separate credential from your API key — it's what clients use to connect to the disk's data plane. Pick any string as the principal (it's just an identifier).
+
+```typescript
+import { Archil } from '@archildata/client/api';
+
+const archil = new Archil({
+  apiKey: 'your-api-key',
+  region: 'aws-us-east-1',
+});
+
+const MOUNT_TOKEN = 'my-secret-mount-token';
+
+const disk = await archil.disks.create({
+  name: 'my-disk',
+  mounts: [{
+    type: 's3',
+    bucketName: 'my-bucket',
+    accessKeyId: 'AKIA...',
+    secretAccessKey: '...',
+  }],
+  authMethods: [{
+    type: 'token',
+    principal: MOUNT_TOKEN,
+    nickname: 'my-mount-token',
+    tokenSuffix: MOUNT_TOKEN.slice(-4),
+  }],
+});
+
+console.log(`Created disk: ${disk.organization}/${disk.name}`);
+```
+
+You only do this once. After that, the disk is available by name whenever you want to connect.
+
+### 4. Run bash commands on it
+
+Install `@archildata/just-bash` to get a shell that runs against your disk:
+
+```bash
+npm install @archildata/just-bash
+```
+
+Then connect using the mount token you authorized above:
 
-This package includes pre-built binaries for:
+```bash
+ARCHIL_TOKEN=my-secret-mount-token npx @archildata/just-bash aws-us-east-1 myaccount/my-disk
+```
 
-- **macOS** (Apple Silicon) - `darwin-arm64`
-- **Linux** (x86_64) - `linux-x64-gnu`
-- **Linux** (ARM64) - `linux-arm64-gnu`
+This drops you into an interactive shell. The files you see are the contents of your S3 bucket:
 
-Other platforms are not currently supported.
+```
+$ ls
+data/  logs/  config.json
 
-> **Note:** For best performance, run your application in the same region as your Archil disk (e.g., if your disk is in `aws-us-east-1`, deploy your app to AWS us-east-1).
+$ cat config.json
+{"version": 2, "debug": false}
 
-## Usage
+$ echo "hello from archil" > greeting.txt
+```
+
+Everything you do here — reads, writes, renames, deletes — goes through Archil to your bucket.
+
+## Using just-bash Programmatically
+
+The interactive shell is great for poking around, but you can also run bash commands from your own code. This is useful for scripts, CI pipelines, or anywhere you want to run shell commands against your disk without mounting it.
 
 ```typescript
 import { ArchilClient } from '@archildata/client';
+import { ArchilFs, createArchilCommand } from '@archildata/just-bash';
+import { Bash } from 'just-bash';
 
-// Connect to Archil
+// Connect to your disk
 const client = await ArchilClient.connect({
   region: 'aws-us-east-1',
-  diskName: 'myaccount/mydisk',
-  authToken: process.env.ARCHIL_TOKEN, // optional, uses IAM if not provided
+  diskName: 'myaccount/my-disk',
+  authToken: 'my-secret-mount-token',
 });
 
-// Get root directory attributes
-const rootAttrs = await client.getAttributes(1);
-console.log('Root size:', rootAttrs.size);
+// Create a filesystem adapter and a bash executor
+const fs = await ArchilFs.create(client);
+const bash = new Bash({
+  fs,
+  customCommands: [createArchilCommand(client, fs)],
+});
 
-// List directory contents
-const entries = await client.readDirectory(1);
-for (const entry of entries) {
-  console.log(`${entry.name} (inode: ${entry.inodeId})`);
-}
+// Run commands just like you would in a terminal
+const result = await bash.exec('ls -la /');
+console.log(result.stdout);
+
+// Write a file
+await bash.exec('echo "hello world" > /greeting.txt');
 
-// Read a file
-const lookup = await client.lookupInode(1, 'myfile.txt');
-const data = await client.readInode(lookup.inodeId, 0, 1024);
-console.log('File content:', data.toString());
+// Read it back
+const cat = await bash.exec('cat /greeting.txt');
+console.log(cat.stdout); // "hello world"
 
-// Close when done
+// Clean up
 await client.close();
 ```
 
-## API
+You can also use the filesystem adapter directly without bash, if you just need standard file operations:
+
+```typescript
+const fs = await ArchilFs.create(client);
+
+// These work like their Node.js fs equivalents
+await fs.writeFile('/notes.txt', 'some content');
+const content = await fs.readFile('/notes.txt');
+const entries = await fs.readdir('/');
+const stats = await fs.stat('/notes.txt');
+await fs.mkdir('/mydir', { recursive: true });
+await fs.cp('/notes.txt', '/mydir/notes-copy.txt');
+await fs.rm('/notes.txt');
+```
+
+## Using the Native Client Directly
+
+For more control, you can use the `ArchilClient` directly. This gives you access to the full filesystem protocol — inodes, delegations, paginated directory reads, etc.
+
+### Connecting
+
+```typescript
+import { ArchilClient } from '@archildata/client';
+
+const client = await ArchilClient.connect({
+  region: 'aws-us-east-1',
+  diskName: 'myaccount/my-disk',
+  authToken: 'my-secret-mount-token',
+});
+```
+
+### Reading files
+
+Every file and directory on an Archil disk has an inode ID. The root directory is always inode `1`. You navigate by looking up names inside directories, then reading the inodes you find.
+
+```typescript
+// Look up a file by name in the root directory
+const entry = await client.lookupInode(1, 'config.json');
+
+// Read its contents
+const data = await client.readInode(entry.inodeId, 0, entry.attributes.size);
+console.log(data.toString());
+```
+
+### Listing directories
+
+```typescript
+const handle = await client.openDirectory(1);
+const page = await client.readDirectory(1, handle, 100);
+
+for (const entry of page.entries) {
+  console.log(`${entry.name} (${entry.inodeType})`);
+}
 
-### `ArchilClient`
+client.closeDirectory(1, handle);
+```
 
-The main client class for interacting with Archil filesystems.
+For large directories, pass the returned `page.nextCursor` back into `readDirectory` to get the next page. When `nextCursor` is `undefined`, you've seen everything.
 
-#### Connection Methods
+### Writing files
 
-- `connect(config)` - Connect using region and disk name (recommended)
-- `connectDirect(config)` - Connect directly to a server (for testing)
+Archil uses a delegation model for writes. Before you can write to a file, you "check out" a delegation on it — this tells the server you intend to modify it and gives you exclusive access. When you're done, you "check in" to release it so other clients can write.
 
-#### Metadata Operations
+```typescript
+// Check out the file to acquire a write delegation
+await client.checkout(inodeId);
 
-- `getAttributes(inodeId, options?)` - Get inode attributes
-- `lookupInode(parentInodeId, name, options?)` - Lookup entry by name
-- `readDirectory(inodeId, options?)` - List directory entries
-- `getExtendedAttribute(inodeId, name, options?)` - Get xattr value
-- `listExtendedAttributes(inodeId, options?)` - List xattr names
+// Write data
+await client.writeData(inodeId, 0, Buffer.from('new contents'));
 
-#### Data Operations
+// Make sure the write is durable on the server
+await client.sync();
 
-- `readInode(inodeId, offset, length, options?)` - Read file data
-- `writeData(inodeId, offset, data, options?)` - Write file data (requires delegation)
-- `sync()` - Sync all pending writes to server
+// Release the delegation so other clients can write
+await client.checkin(inodeId);
+```
 
-#### Delegation Operations
+### Creating files and directories
 
-- `checkout(inodeId, options?)` - Acquire write delegation
-- `checkin(inodeId, options?)` - Release delegation
-- `checkinAll()` - Release all delegations
-- `listDelegations()` - List currently held delegations
+```typescript
+// Create a directory in root (inode 1)
+const dir = await client.create(1, 'mydir', {
+  inodeType: 'Directory',
+  uid: 1000,
+  gid: 1000,
+  mode: 0o755,
+});
 
-#### Mutation Operations
+// Create a file inside it
+const file = await client.create(dir.inodeId, 'data.txt', {
+  inodeType: 'File',
+  uid: 1000,
+  gid: 1000,
+  mode: 0o644,
+});
 
-- `create(parentInodeId, name, attributes, options?)` - Create file/directory
-- `unlink(parentInodeId, name, options?)` - Delete file or empty directory
-- `rename(parentInodeId, name, newParentInodeId, newName, options?)` - Move/rename
-- `setattr(inodeId, attributes, options)` - Update file attributes (user required in options)
-- `setImmutable(inodeId)` - Mark subtree as immutable
-- `setMutable(inodeId)` - Mark subtree as mutable
-- `listImmutableSubtrees()` - List immutable roots
+// Write to the new file
+await client.checkout(file.inodeId);
+await client.writeData(file.inodeId, 0, Buffer.from('file contents'));
+await client.checkin(file.inodeId);
+```
 
-### Types
+### Renaming and deleting
 
 ```typescript
-interface SimpleConnectionConfig {
-  region: string;      // e.g., "aws-us-east-1"
-  diskName: string;    // e.g., "myaccount/mydisk"
-  authToken?: string;  // optional, uses IAM if not provided
-  logLevel?: string;   // optional: "trace", "debug", "info", "warn", "error"
-}
+await client.rename(parentInodeId, 'old.txt', parentInodeId, 'new.txt');
+await client.unlink(parentInodeId, 'new.txt');
+```
 
-interface UnixUser {
-  uid: number;
-  gid: number;
-}
+### Cleaning up
 
-interface InodeAttributes {
-  inodeId: number;
-  inodeType: 'File' | 'Directory' | 'Symlink' | ...;
-  size: number;
-  uid: number;
-  gid: number;
-  mode: number;
-  nlink: number;
-  ctimeMs: number;
-  atimeMs: number;
-  mtimeMs: number;
-  btimeMs: number;
-  rdev?: number;
-  symlinkTarget?: string;
-}
+Always close the client when you're done. This flushes pending writes and releases any delegations you're still holding.
 
-interface DirectoryEntry {
-  name: string;
-  inodeId: number;
-  inodeType: string;
-}
+```typescript
+await client.close();
+```
 
-interface OperationOptions {
-  user?: UnixUser;    // Unix user context for permission checks
-}
+## Managing Disks
 
-interface CheckoutOptions {
-  force?: boolean;    // Force revoke existing delegations (default: false)
-  user?: UnixUser;    // Unix user context for permission checks
-}
+The control plane API lets you manage disks and access control after initial setup.
 
-interface SetAttrAttributes {
-  mode?: number;
-  uid?: number;
-  gid?: number;
-  size?: number;
-  atimeMs?: number;   // use -1 for current time
-  mtimeMs?: number;   // use -1 for current time
-}
+```typescript
+import { Archil } from '@archildata/client/api';
+
+const archil = new Archil({
+  apiKey: 'your-api-key',
+  region: 'aws-us-east-1',
+});
+
+// List your disks
+const disks = await archil.disks.list();
+
+// Get a specific disk by ID
+const disk = await archil.disks.get('dsk-xxx');
+
+// Authorize another mount token on an existing disk
+const CI_TOKEN = 'ci-mount-token';
+await disk.addUser({
+  type: 'token',
+  principal: CI_TOKEN,
+  nickname: 'ci-token',
+  tokenSuffix: CI_TOKEN.slice(-4),
+});
+
+// Remove access
+await disk.removeUser('token', CI_TOKEN);
+
+// Delete a disk (this does not delete your bucket data)
+await disk.delete();
 ```
 
-## Building
+### Going from a disk to a client
 
-This package uses napi-rs for native bindings. To build from source:
+If you have a `Disk` object from the API, you can connect directly without specifying the region and name again:
 
-```bash
-cd rust-libs/archil-node
-npm install
-npm run build
+```typescript
+const disk = await archil.disks.get('dsk-xxx');
+const client = await disk.mount({ authToken: '<your-token>' });
+
+// client is an ArchilClient — use it for reads, writes, etc.
+await client.close();
 ```
 
-## License
+## Supported Regions
+
+| Region             | Provider |
+| ------------------ | -------- |
+| `aws-us-east-1`   | AWS      |
+| `aws-us-west-2`   | AWS      |
+| `aws-eu-west-1`   | AWS      |
+| `gcp-us-central1` | GCP      |
+
+## Supported Storage Backends
+
+- **Amazon S3** (`type: 's3'`)
+- **Google Cloud Storage** (`type: 'gcs'`)
+- **Azure Blob Storage** (`type: 'azure-blob'`)
+- **Cloudflare R2** (`type: 'r2'`)
+- **S3-compatible services** (`type: 's3-compatible'`)
+
+## Platform Support
+
+The control plane API (`@archildata/client/api`) works on any platform — macOS, Windows, Linux.
+
+The native filesystem client (connecting to disks, reading/writing files) supports **Linux** (x64 or arm64, glibc) and **macOS** (Apple Silicon / arm64). On other platforms, the API-only imports still work.
+
+## Support
 
-Proprietary - Archil Inc.
+Questions, feature requests, or issues? Reach us at **support@archil.com**.

package/main.d.ts

@@ -0,0 +1,2 @@
+export * from './native';
+export * from './dist/api/index';

package/main.js

@@ -0,0 +1,15 @@
+let native = {};
+try {
+  native = require('./native.js');
+} catch (e) {
+  // Only swallow "unsupported platform" errors so the API-only client
+  // still works on macOS/Windows/Alpine. Re-throw install failures on
+  // supported platforms — those need loud errors, not silent undefined.
+  if (e.message && !e.message.includes('does not support') &&
+      !e.message.includes('only supports') &&
+      !e.message.includes('cannot be loaded through a bundler')) {
+    throw e;
+  }
+}
+const api = require('./dist/api/index.js');
+module.exports = { ...native, ...api };

package/main.mjs

@@ -0,0 +1,17 @@
+export * from './dist/api/index.mjs';
+
+import { createRequire } from 'node:module';
+const esmRequire = createRequire(import.meta.url);
+let native = {};
+try {
+  native = esmRequire('./native.js');
+} catch (e) {
+  if (e.message && !e.message.includes('does not support') &&
+      !e.message.includes('only supports') &&
+      !e.message.includes('cannot be loaded through a bundler')) {
+    throw e;
+  }
+}
+export const ArchilClient = native.ArchilClient;
+export const initLogging = native.initLogging;
+export const JsInodeType = native.JsInodeType;

package/{index.d.ts → native.d.ts}

@@ -73,13 +73,49 @@ export interface DirectoryEntry {
   /** Type of the entry (File, Directory, etc.) */
   inodeType: string
 }
+/** Parameters for creating a new inode */
+export interface CreateInodeParams {
+  /** Type of inode to create (File, Directory, Symlink, etc.) */
+  inodeType: string
+  /** Owner user ID */
+  uid: number
+  /** Owner group ID */
+  gid: number
+  /** Unix permission mode */
+  mode: number
+  /** Device ID for block/char devices */
+  rdev?: number
+  /** Symlink target if creating a symlink */
+  symlinkTarget?: string
+}
+/** Result of creating a new inode */
+export interface CreateResult {
+  /** Inode ID of the created entry */
+  inodeId: number
+  /** Final attributes of the created inode (includes SGID inheritance, etc.) */
+  attributes: InodeAttributes
+}
+/** A page of directory entries for paginated reading */
+export interface DirectoryPage {
+  /** Entries in this page */
+  entries: Array<DirectoryEntry>
+  /** Opaque cursor for the next page, or undefined if this is the last page */
+  nextCursor?: string
+}
 /** Lookup response containing inode info */
 export interface LookupResponse {
-  /** Inode ID of the found entry (-1 if not found) */
+  /** Inode ID of the found entry */
   inodeId: number
   /** Attributes of the found inode */
   attributes: InodeAttributes
 }
+/** Result of opening a file */
+export interface OpenFileResult {
+  /** File handle to use for subsequent operations */
+  fileHandle: number
+  /** Whether auto-checkout occurred (delegation will be checked in on release) */
+  needsCheckin: boolean
+}
 /** Connection configuration for direct server connections */
 export interface DirectConnectionConfig {
   /** Server address (e.g., "localhost:8080") */
@@ -218,16 +254,14 @@ export declare class ArchilClient {
   close(): Promise<number>
   /** Get attributes for an inode (uses cache). */
   getAttributes(inodeId: number, options?: OperationOptions | undefined | null): Promise<InodeAttributes>
-  /** Lookup an entry by name in a directory (uses cache). */
-  lookupInode(parentInodeId: number, name: string, options?: OperationOptions | undefined | null): Promise<LookupResponse>
-  /**
-   * Read directory entries.
-   *
-   * Uses the cache layer via snapshot_and_synchronize_directory to ensure
-   * the dirent cache is properly populated. This ensures that subsequent
-   * lookup_inode calls can find the entries returned here.
-   */
-  readDirectory(inodeId: number, options?: OperationOptions | undefined | null): Promise<Array<DirectoryEntry>>
+  /** Lookup an entry by name in a directory (uses cache). Returns null if not found. */
+  lookupInode(parentInodeId: number, name: string, options?: OperationOptions | undefined | null): Promise<LookupResponse | null>
+  /** Open a directory for paginated reading. Returns a file handle. */
+  openDirectory(inodeId: number, options?: OperationOptions | undefined | null): Promise<number>
+  /** Read a page of directory entries using a handle from openDirectory. */
+  readDirectory(inodeId: number, fileHandle: number, limit: number, cursor?: string | undefined | null, options?: OperationOptions | undefined | null): Promise<DirectoryPage>
+  /** Close a directory handle opened with openDirectory. */
+  closeDirectory(inodeId: number, fileHandle: number): void
   /** Get an extended attribute value. */
   getExtendedAttribute(inodeId: number, name: string, options?: OperationOptions | undefined | null): Promise<Buffer | null>
   /** List all extended attribute names. */
@@ -336,10 +370,20 @@ export declare class ArchilClient {
    *
    * Automatically chooses between unconditional create (if we have a delegation
    * on the parent) and conditional create (if we need the server to issue a delegation).
+   */
+  create(parentInodeId: number, name: string, params: CreateInodeParams, options?: OperationOptions | undefined | null): Promise<CreateResult>
+  /**
+   * Open a file for reading or writing.
    *
-   * Returns the inode ID of the created file.
+   * @param accessType - 0 for read, 1 for write, 2 for read-write
    */
-  create(parentInodeId: number, name: string, attributes: InodeAttributes, options?: OperationOptions | undefined | null): Promise<number>
+  openFile(inodeId: number, accessType: number, options?: OperationOptions | undefined | null): Promise<OpenFileResult>
+  /** Release (close) a file handle. */
+  releaseFile(inodeId: number, fileHandle: number, options?: OperationOptions | undefined | null): Promise<void>
+  /** Read the target of a symlink. */
+  readlink(inodeId: number, options?: OperationOptions | undefined | null): Promise<string>
+  /** Check access permissions for an inode. */
+  checkAccess(inodeId: number, mask: number, options?: OperationOptions | undefined | null): Promise<void>
   /** Mark an inode subtree as immutable. */
   setImmutable(inodeId: number): Promise<void>
   /** Mark an inode subtree as mutable (reverse of set_immutable). */

package/native.js

@@ -0,0 +1,99 @@
+/* eslint-disable */
+
+const { existsSync } = require('fs')
+const { join } = require('path')
+
+const { platform, arch } = process
+
+// Bundlers (tsup, webpack, esbuild, etc.) cannot handle native .node addons.
+// They either silently drop the binary or replace require() with their own
+// resolution, which breaks at runtime. Detect this early with a clear message.
+if (typeof __dirname === 'undefined' || !existsSync(__dirname)) {
+  throw new Error(
+    '@archildata/client contains a native Node.js addon (.node binary) that cannot be loaded ' +
+    'through a bundler (tsup, webpack, esbuild, etc.). Import @archildata/client from ' +
+    'unbundled code only — for example, mark it as external in your bundler config.'
+  )
+}
+
+const SUPPORTED_PLATFORMS = {
+  'linux-x64-gnu': {
+    localFile: 'archildata-client.linux-x64-gnu.node',
+    package: '@archildata/client-linux-x64-gnu',
+  },
+  'linux-arm64-gnu': {
+    localFile: 'archildata-client.linux-arm64-gnu.node',
+    package: '@archildata/client-linux-arm64-gnu',
+  },
+  'darwin-arm64': {
+    localFile: 'archildata-client.darwin-arm64.node',
+    package: '@archildata/client-darwin-arm64',
+  },
+}
+
+function isMusl() {
+  const report = process.report && process.report.getReport && process.report.getReport()
+  if (report) {
+    return !report.header.glibcVersionRuntime
+  }
+  try {
+    const lddPath = require('child_process').execSync('which ldd').toString().trim()
+    return require('fs').readFileSync(lddPath, 'utf8').includes('musl')
+  } catch {
+    return true
+  }
+}
+
+let platformKey
+if (platform === 'darwin') {
+  platformKey = `darwin-${arch}`
+} else if (platform === 'linux') {
+  if (isMusl()) {
+    throw new Error(
+      `@archildata/client does not support musl-based Linux distros (e.g. Alpine). ` +
+      `Current platform: ${platform}/${arch}/musl.`
+    )
+  }
+  platformKey = `linux-${arch}-gnu`
+} else {
+  throw new Error(
+    `@archildata/client only supports Linux (x64, arm64) and macOS (arm64). ` +
+    `Current platform: ${platform}/${arch}.`
+  )
+}
+
+const target = SUPPORTED_PLATFORMS[platformKey]
+
+if (!target) {
+  throw new Error(
+    `@archildata/client does not support ${platform}/${arch}. ` +
+    `Supported platforms: Linux x64, Linux arm64, macOS arm64.`
+  )
+}
+
+let nativeBinding
+
+// Local .node file takes precedence (development builds)
+const localPath = join(__dirname, target.localFile)
+if (existsSync(localPath)) {
+  nativeBinding = require(localPath)
+} else {
+  try {
+    nativeBinding = require(target.package)
+  } catch (e) {
+    throw new Error(
+      `Failed to load native binding for ${platformKey}. ` +
+      `Tried platform package '${target.package}' but it was not installed.\n\n` +
+      `If you're using npm, reinstall with: npm install @archildata/client\n` +
+      `If you're using a bundler (tsup, webpack, esbuild), mark @archildata/client ` +
+      `as external — native .node addons cannot be bundled.\n\n` +
+      `Original error: ${e.message}`
+    )
+  }
+}
+
+const { initLogging, ArchilClient, JsInodeType } = nativeBinding
+
+module.exports.initLogging = initLogging
+module.exports.ArchilClient = ArchilClient
+module.exports.JsInodeType = JsInodeType

package/package.json

@@ -1,24 +1,46 @@
 {
   "name": "@archildata/client",
-  "version": "0.1.12",
+  "version": "0.8.1",
   "description": "High-performance Node.js client for Archil distributed filesystem",
-  "main": "index.js",
-  "types": "index.d.ts",
+  "main": "main.js",
+  "types": "main.d.ts",
+  "exports": {
+    ".": {
+      "types": "./main.d.ts",
+      "import": "./main.mjs",
+      "require": "./main.js"
+    },
+    "./api": {
+      "types": "./dist/api/index.d.ts",
+      "import": "./dist/api/index.mjs",
+      "require": "./dist/api/index.js"
+    },
+    "./native": {
+      "types": "./native.d.ts",
+      "require": "./native.js"
+    }
+  },
   "napi": {
     "name": "archildata-client",
     "triples": {
-      "defaults": true,
+      "defaults": false,
       "additional": [
-        "aarch64-apple-darwin",
         "aarch64-unknown-linux-gnu",
-        "x86_64-apple-darwin",
-        "x86_64-unknown-linux-gnu"
+        "x86_64-unknown-linux-gnu",
+        "aarch64-apple-darwin"
       ]
     }
   },
   "license": "UNLICENSED",
+  "dependencies": {
+    "openapi-fetch": "^0.13.5"
+  },
   "devDependencies": {
-    "@napi-rs/cli": "^2.18.0"
+    "@napi-rs/cli": "^2.18.0",
+    "@types/node": "^20.19.33",
+    "openapi-typescript": "^7.6.1",
+    "tsup": "^8.4.0",
+    "typescript": "^5.9.3"
   },
   "engines": {
     "node": ">= 18"
@@ -27,29 +49,17 @@
     "artifacts": "napi artifacts",
     "build": "napi build --platform --release",
     "build:debug": "napi build --platform",
-    "prepublishOnly": "napi prepublish -t npm",
-    "test": "node --test test/*.js",
-    "universal": "napi universal",
-    "version": "napi version"
+    "build:api": "npm run generate && tsup src/api/index.ts --format cjs,esm --dts --outDir dist/api",
+    "generate": "openapi-typescript ../../api/controlplane/openapi.yaml -o src/api/generated/openapi.d.ts"
   },
   "files": [
-    "index.js",
-    "index.d.ts",
+    "native.js",
+    "native.d.ts",
+    "main.js",
+    "main.mjs",
+    "main.d.ts",
+    "dist/",
     "*.node",
     "README.md"
-  ],
-  "keywords": [
-    "archil",
-    "filesystem",
-    "distributed",
-    "napi",
-    "native"
-  ],
-  "optionalDependencies": {
-    "@archildata/client-win32-x64-msvc": "0.1.12",
-    "@archildata/client-darwin-x64": "0.1.12",
-    "@archildata/client-linux-x64-gnu": "0.1.12",
-    "@archildata/client-darwin-arm64": "0.1.12",
-    "@archildata/client-linux-arm64-gnu": "0.1.12"
-  }
-}
+  ]
+}

package/index.js

@@ -1,317 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-/* prettier-ignore */
-
-/* auto-generated by NAPI-RS */
-
-const { existsSync, readFileSync } = require('fs')
-const { join } = require('path')
-
-const { platform, arch } = process
-
-let nativeBinding = null
-let localFileExisted = false
-let loadError = null
-
-function isMusl() {
-  // For Node 10
-  if (!process.report || typeof process.report.getReport !== 'function') {
-    try {
-      const lddPath = require('child_process').execSync('which ldd').toString().trim()
-      return readFileSync(lddPath, 'utf8').includes('musl')
-    } catch (e) {
-      return true
-    }
-  } else {
-    const { glibcVersionRuntime } = process.report.getReport().header
-    return !glibcVersionRuntime
-  }
-}
-
-switch (platform) {
-  case 'android':
-    switch (arch) {
-      case 'arm64':
-        localFileExisted = existsSync(join(__dirname, 'archildata-client.android-arm64.node'))
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./archildata-client.android-arm64.node')
-          } else {
-            nativeBinding = require('@archildata/client-android-arm64')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      case 'arm':
-        localFileExisted = existsSync(join(__dirname, 'archildata-client.android-arm-eabi.node'))
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./archildata-client.android-arm-eabi.node')
-          } else {
-            nativeBinding = require('@archildata/client-android-arm-eabi')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      default:
-        throw new Error(`Unsupported architecture on Android ${arch}`)
-    }
-    break
-  case 'win32':
-    switch (arch) {
-      case 'x64':
-        localFileExisted = existsSync(
-          join(__dirname, 'archildata-client.win32-x64-msvc.node')
-        )
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./archildata-client.win32-x64-msvc.node')
-          } else {
-            nativeBinding = require('@archildata/client-win32-x64-msvc')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      case 'ia32':
-        localFileExisted = existsSync(
-          join(__dirname, 'archildata-client.win32-ia32-msvc.node')
-        )
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./archildata-client.win32-ia32-msvc.node')
-          } else {
-            nativeBinding = require('@archildata/client-win32-ia32-msvc')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      case 'arm64':
-        localFileExisted = existsSync(
-          join(__dirname, 'archildata-client.win32-arm64-msvc.node')
-        )
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./archildata-client.win32-arm64-msvc.node')
-          } else {
-            nativeBinding = require('@archildata/client-win32-arm64-msvc')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      default:
-        throw new Error(`Unsupported architecture on Windows: ${arch}`)
-    }
-    break
-  case 'darwin':
-    localFileExisted = existsSync(join(__dirname, 'archildata-client.darwin-universal.node'))
-    try {
-      if (localFileExisted) {
-        nativeBinding = require('./archildata-client.darwin-universal.node')
-      } else {
-        nativeBinding = require('@archildata/client-darwin-universal')
-      }
-      break
-    } catch {}
-    switch (arch) {
-      case 'x64':
-        localFileExisted = existsSync(join(__dirname, 'archildata-client.darwin-x64.node'))
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./archildata-client.darwin-x64.node')
-          } else {
-            nativeBinding = require('@archildata/client-darwin-x64')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      case 'arm64':
-        localFileExisted = existsSync(
-          join(__dirname, 'archildata-client.darwin-arm64.node')
-        )
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./archildata-client.darwin-arm64.node')
-          } else {
-            nativeBinding = require('@archildata/client-darwin-arm64')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      default:
-        throw new Error(`Unsupported architecture on macOS: ${arch}`)
-    }
-    break
-  case 'freebsd':
-    if (arch !== 'x64') {
-      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`)
-    }
-    localFileExisted = existsSync(join(__dirname, 'archildata-client.freebsd-x64.node'))
-    try {
-      if (localFileExisted) {
-        nativeBinding = require('./archildata-client.freebsd-x64.node')
-      } else {
-        nativeBinding = require('@archildata/client-freebsd-x64')
-      }
-    } catch (e) {
-      loadError = e
-    }
-    break
-  case 'linux':
-    switch (arch) {
-      case 'x64':
-        if (isMusl()) {
-          localFileExisted = existsSync(
-            join(__dirname, 'archildata-client.linux-x64-musl.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./archildata-client.linux-x64-musl.node')
-            } else {
-              nativeBinding = require('@archildata/client-linux-x64-musl')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        } else {
-          localFileExisted = existsSync(
-            join(__dirname, 'archildata-client.linux-x64-gnu.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./archildata-client.linux-x64-gnu.node')
-            } else {
-              nativeBinding = require('@archildata/client-linux-x64-gnu')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        }
-        break
-      case 'arm64':
-        if (isMusl()) {
-          localFileExisted = existsSync(
-            join(__dirname, 'archildata-client.linux-arm64-musl.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./archildata-client.linux-arm64-musl.node')
-            } else {
-              nativeBinding = require('@archildata/client-linux-arm64-musl')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        } else {
-          localFileExisted = existsSync(
-            join(__dirname, 'archildata-client.linux-arm64-gnu.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./archildata-client.linux-arm64-gnu.node')
-            } else {
-              nativeBinding = require('@archildata/client-linux-arm64-gnu')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        }
-        break
-      case 'arm':
-        if (isMusl()) {
-          localFileExisted = existsSync(
-            join(__dirname, 'archildata-client.linux-arm-musleabihf.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./archildata-client.linux-arm-musleabihf.node')
-            } else {
-              nativeBinding = require('@archildata/client-linux-arm-musleabihf')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        } else {
-          localFileExisted = existsSync(
-            join(__dirname, 'archildata-client.linux-arm-gnueabihf.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./archildata-client.linux-arm-gnueabihf.node')
-            } else {
-              nativeBinding = require('@archildata/client-linux-arm-gnueabihf')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        }
-        break
-      case 'riscv64':
-        if (isMusl()) {
-          localFileExisted = existsSync(
-            join(__dirname, 'archildata-client.linux-riscv64-musl.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./archildata-client.linux-riscv64-musl.node')
-            } else {
-              nativeBinding = require('@archildata/client-linux-riscv64-musl')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        } else {
-          localFileExisted = existsSync(
-            join(__dirname, 'archildata-client.linux-riscv64-gnu.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./archildata-client.linux-riscv64-gnu.node')
-            } else {
-              nativeBinding = require('@archildata/client-linux-riscv64-gnu')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        }
-        break
-      case 's390x':
-        localFileExisted = existsSync(
-          join(__dirname, 'archildata-client.linux-s390x-gnu.node')
-        )
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./archildata-client.linux-s390x-gnu.node')
-          } else {
-            nativeBinding = require('@archildata/client-linux-s390x-gnu')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      default:
-        throw new Error(`Unsupported architecture on Linux: ${arch}`)
-    }
-    break
-  default:
-    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
-}
-
-if (!nativeBinding) {
-  if (loadError) {
-    throw loadError
-  }
-  throw new Error(`Failed to load native binding`)
-}
-
-const { initLogging, ArchilClient, JsInodeType } = nativeBinding
-
-module.exports.initLogging = initLogging
-module.exports.ArchilClient = ArchilClient
-module.exports.JsInodeType = JsInodeType