pilotprotocol 0.1.0

package/bin/libpilot.h

@@ -0,0 +1,158 @@
+/* Code generated by cmd/cgo; DO NOT EDIT. */
+
+/* package github.com/TeoSlayer/pilotprotocol/sdk/cgo */
+
+
+#line 1 "cgo-builtin-export-prolog"
+
+#include <stddef.h>
+
+#ifndef GO_CGO_EXPORT_PROLOGUE_H
+#define GO_CGO_EXPORT_PROLOGUE_H
+
+#ifndef GO_CGO_GOSTRING_TYPEDEF
+typedef struct { const char *p; ptrdiff_t n; } _GoString_;
+extern size_t _GoStringLen(_GoString_ s);
+extern const char *_GoStringPtr(_GoString_ s);
+#endif
+
+#endif
+
+/* Start of preamble from import "C" comments.  */
+
+
+#line 3 "bindings.go"
+
+#include <stdlib.h>
+#include <stdint.h>
+
+#line 1 "cgo-generated-wrapper"
+
+
+/* End of preamble from import "C" comments.  */
+
+
+/* Start of boilerplate cgo prologue.  */
+#line 1 "cgo-gcc-export-header-prolog"
+
+#ifndef GO_CGO_PROLOGUE_H
+#define GO_CGO_PROLOGUE_H
+
+typedef signed char GoInt8;
+typedef unsigned char GoUint8;
+typedef short GoInt16;
+typedef unsigned short GoUint16;
+typedef int GoInt32;
+typedef unsigned int GoUint32;
+typedef long long GoInt64;
+typedef unsigned long long GoUint64;
+typedef GoInt64 GoInt;
+typedef GoUint64 GoUint;
+typedef size_t GoUintptr;
+typedef float GoFloat32;
+typedef double GoFloat64;
+#ifdef _MSC_VER
+#if !defined(__cplusplus) || _MSVC_LANG <= 201402L
+#include <complex.h>
+typedef _Fcomplex GoComplex64;
+typedef _Dcomplex GoComplex128;
+#else
+#include <complex>
+typedef std::complex<float> GoComplex64;
+typedef std::complex<double> GoComplex128;
+#endif
+#else
+typedef float _Complex GoComplex64;
+typedef double _Complex GoComplex128;
+#endif
+
+/*
+  static assertion to make sure the file is being used on architecture
+  at least with matching size of GoInt.
+*/
+typedef char _check_for_64_bit_pointer_matching_GoInt[sizeof(void*)==64/8 ? 1:-1];
+
+#ifndef GO_CGO_GOSTRING_TYPEDEF
+typedef _GoString_ GoString;
+#endif
+typedef void *GoMap;
+typedef void *GoChan;
+typedef struct { void *t; void *v; } GoInterface;
+typedef struct { void *data; GoInt len; GoInt cap; } GoSlice;
+
+#endif
+
+/* End of boilerplate cgo prologue.  */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void FreeString(char* s);
+
+/* Return type for PilotConnect */
+struct PilotConnect_return {
+	uint64_t r0;
+	char* r1;
+};
+extern struct PilotConnect_return PilotConnect(char* socketPath);
+extern char* PilotClose(uint64_t h);
+extern char* PilotInfo(uint64_t h);
+extern char* PilotHandshake(uint64_t h, uint32_t nodeID, char* justification);
+extern char* PilotApproveHandshake(uint64_t h, uint32_t nodeID);
+extern char* PilotRejectHandshake(uint64_t h, uint32_t nodeID, char* reason);
+extern char* PilotPendingHandshakes(uint64_t h);
+extern char* PilotTrustedPeers(uint64_t h);
+extern char* PilotRevokeTrust(uint64_t h, uint32_t nodeID);
+extern char* PilotResolveHostname(uint64_t h, char* hostname);
+extern char* PilotSetHostname(uint64_t h, char* hostname);
+extern char* PilotSetVisibility(uint64_t h, int public);
+extern char* PilotSetTaskExec(uint64_t h, int enabled);
+extern char* PilotDeregister(uint64_t h);
+extern char* PilotSetTags(uint64_t h, char* tagsJSON);
+extern char* PilotSetWebhook(uint64_t h, char* url);
+extern char* PilotDisconnect(uint64_t h, uint32_t connID);
+
+/* Return type for PilotDial */
+struct PilotDial_return {
+	uint64_t r0;
+	char* r1;
+};
+extern struct PilotDial_return PilotDial(uint64_t h, char* addr);
+
+/* Return type for PilotListen */
+struct PilotListen_return {
+	uint64_t r0;
+	char* r1;
+};
+extern struct PilotListen_return PilotListen(uint64_t h, uint16_t port);
+
+/* Return type for PilotListenerAccept */
+struct PilotListenerAccept_return {
+	uint64_t r0;
+	char* r1;
+};
+extern struct PilotListenerAccept_return PilotListenerAccept(uint64_t lh);
+extern char* PilotListenerClose(uint64_t lh);
+
+/* Return type for PilotConnRead */
+struct PilotConnRead_return {
+	int r0;
+	char* r1;
+	char* r2;
+};
+extern struct PilotConnRead_return PilotConnRead(uint64_t ch, int bufSize);
+
+/* Return type for PilotConnWrite */
+struct PilotConnWrite_return {
+	int r0;
+	char* r1;
+};
+extern struct PilotConnWrite_return PilotConnWrite(uint64_t ch, void* data, int dataLen);
+extern char* PilotConnClose(uint64_t ch);
+extern char* PilotSendTo(uint64_t h, char* fullAddr, void* data, int dataLen);
+extern char* PilotRecvFrom(uint64_t h);
+
+#ifdef __cplusplus
+}
+#endif

package/bin-stubs/pilot-daemon.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { runDaemon } from '../dist/cli.js';
+runDaemon();

package/bin-stubs/pilot-gateway.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { runGateway } from '../dist/cli.js';
+runGateway();

package/bin-stubs/pilot-updater.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { runUpdater } from '../dist/cli.js';
+runUpdater();

package/bin-stubs/pilotctl.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { runPilotctl } from '../dist/cli.js';
+runPilotctl();

package/dist/cli.d.ts

@@ -0,0 +1,14 @@
+/**
+ * CLI wrappers for bundled Pilot Protocol binaries.
+ *
+ * These functions are used as npm "bin" entry points. Each wrapper:
+ * 1. Ensures ~/.pilot/ directory and default config.json exist
+ * 2. Locates the bundled Go binary
+ * 3. Executes it with all CLI arguments passed through
+ *
+ * This mirrors the Python SDK's cli.py approach.
+ */
+export declare function runPilotctl(): void;
+export declare function runDaemon(): void;
+export declare function runGateway(): void;
+export declare function runUpdater(): void;

package/dist/cli.js

@@ -0,0 +1,95 @@
+/**
+ * CLI wrappers for bundled Pilot Protocol binaries.
+ *
+ * These functions are used as npm "bin" entry points. Each wrapper:
+ * 1. Ensures ~/.pilot/ directory and default config.json exist
+ * 2. Locates the bundled Go binary
+ * 3. Executes it with all CLI arguments passed through
+ *
+ * This mirrors the Python SDK's cli.py approach.
+ */
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/**
+ * Ensure ~/.pilot/ directory and config.json exist.
+ * Called before every binary execution to initialize the runtime environment.
+ */
+function ensurePilotEnv() {
+    const home = homedir();
+    const pilotDir = join(home, '.pilot');
+    const configFile = join(pilotDir, 'config.json');
+    // Create ~/.pilot/ if it doesn't exist
+    if (!existsSync(pilotDir)) {
+        mkdirSync(pilotDir, { recursive: true });
+    }
+    // Create default config.json if it doesn't exist
+    if (!existsSync(configFile)) {
+        const defaultConfig = {
+            registry: '34.71.57.205:9000',
+            beacon: '34.71.57.205:9001',
+            socket: '/tmp/pilot.sock',
+            encrypt: true,
+            identity: join(pilotDir, 'identity.json'),
+        };
+        writeFileSync(configFile, JSON.stringify(defaultConfig, null, 2));
+    }
+}
+/**
+ * Get absolute path to a bundled binary.
+ * Searches in the package's bin/ directory (relative to this file's location).
+ */
+function getBinaryPath(binaryName) {
+    const thisDir = resolve(fileURLToPath(import.meta.url), '..');
+    // When compiled: dist/cli.js → look for ../bin/
+    const pkgBin = resolve(thisDir, '..', 'bin', binaryName);
+    if (existsSync(pkgBin))
+        return pkgBin;
+    // Development: src/cli.ts → look for ../../bin/ (through sdk/node/)
+    const devBin = resolve(thisDir, '..', '..', 'bin', binaryName);
+    if (existsSync(devBin))
+        return devBin;
+    throw new Error(`Binary '${binaryName}' not found.\n` +
+        '\n' +
+        'Expected locations:\n' +
+        `  - ${pkgBin} (npm package)\n` +
+        `  - ${devBin} (development)\n` +
+        '\n' +
+        'Build binaries with:\n' +
+        '  cd sdk/node && ./scripts/build-binaries.sh\n');
+}
+/**
+ * Execute a bundled binary with all CLI arguments passed through.
+ * Exits with the same code as the binary.
+ */
+function runBinary(binaryName) {
+    ensurePilotEnv();
+    const binaryPath = getBinaryPath(binaryName);
+    const args = process.argv.slice(2);
+    try {
+        execFileSync(binaryPath, args, {
+            stdio: 'inherit',
+            env: process.env,
+        });
+    }
+    catch (err) {
+        // execFileSync throws on non-zero exit codes
+        const exitCode = err.status ?? 1;
+        process.exit(exitCode);
+    }
+}
+// --- Entry points (one per binary) ---
+export function runPilotctl() {
+    runBinary('pilotctl');
+}
+export function runDaemon() {
+    runBinary('pilot-daemon');
+}
+export function runGateway() {
+    runBinary('pilot-gateway');
+}
+export function runUpdater() {
+    runBinary('pilot-updater');
+}

package/dist/client.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Pilot Protocol Node.js SDK — koffi wrapper around libpilot shared library.
+ *
+ * This module provides a TypeScript/JavaScript interface to the Pilot Protocol
+ * daemon by calling into the Go driver compiled as a C-shared library
+ * (.so/.dylib/.dll). The Go library is the *single source of truth*; this
+ * wrapper is a thin FFI boundary that marshals arguments and unmarshals JSON.
+ *
+ * Usage:
+ *
+ *   import { Driver } from 'pilotprotocol';
+ *
+ *   const d = new Driver();          // connects to /tmp/pilot.sock
+ *   console.log(d.info());           // returns object
+ *   d.close();
+ *
+ * Or with explicit resource management:
+ *
+ *   using d = new Driver();
+ *   console.log(d.info());
+ *   // auto-closed at end of scope
+ */
+import type { PilotLib } from './ffi.js';
+export { PilotError } from './ffi.js';
+export declare const DEFAULT_SOCKET_PATH = "/tmp/pilot.sock";
+/** Override the library instance (for testing). */
+export declare function _setLib(lib: PilotLib | null): void;
+/** Get the current library instance (for testing). */
+export declare function _getLib(): PilotLib | null;
+export declare class Conn {
+    private _h;
+    private _closed;
+    constructor(handle: bigint);
+    /** Read up to `size` bytes. Blocks until data arrives. */
+    read(size?: number): Buffer;
+    /** Write bytes to the connection. Returns bytes written. */
+    write(data: Buffer | Uint8Array | string): number;
+    /** Close the connection. Idempotent. */
+    close(): void;
+    /** Support TC39 explicit resource management. */
+    [Symbol.dispose](): void;
+}
+export declare class Listener {
+    private _h;
+    private _closed;
+    constructor(handle: bigint);
+    /** Block until a new connection arrives and return it. */
+    accept(): Conn;
+    /** Close the listener. Idempotent. */
+    close(): void;
+    /** Support TC39 explicit resource management. */
+    [Symbol.dispose](): void;
+}
+export declare class Driver {
+    private _h;
+    private _closed;
+    constructor(socketPath?: string);
+    /** Disconnect from the daemon. Idempotent. */
+    close(): void;
+    /** Support TC39 explicit resource management. */
+    [Symbol.dispose](): void;
+    private _callJSON;
+    /** Return the daemon's status information. */
+    info(): Record<string, unknown>;
+    /** Send a trust handshake request to a remote node. */
+    handshake(nodeId: number, justification?: string): Record<string, unknown>;
+    /** Approve a pending handshake request. */
+    approveHandshake(nodeId: number): Record<string, unknown>;
+    /** Reject a pending handshake request. */
+    rejectHandshake(nodeId: number, reason?: string): Record<string, unknown>;
+    /** Return pending trust handshake requests. */
+    pendingHandshakes(): Record<string, unknown>;
+    /** Return all trusted peers. */
+    trustedPeers(): Record<string, unknown>;
+    /** Remove a peer from the trusted set. */
+    revokeTrust(nodeId: number): Record<string, unknown>;
+    /** Resolve a hostname to node info. */
+    resolveHostname(hostname: string): Record<string, unknown>;
+    /** Set or clear the daemon's hostname. */
+    setHostname(hostname: string): Record<string, unknown>;
+    /** Set the daemon's visibility on the registry. */
+    setVisibility(isPublic: boolean): Record<string, unknown>;
+    /** Enable or disable task execution capability. */
+    setTaskExec(enabled: boolean): Record<string, unknown>;
+    /** Remove the daemon from the registry. */
+    deregister(): Record<string, unknown>;
+    /** Set capability tags for this node. */
+    setTags(tags: string[]): Record<string, unknown>;
+    /** Set or clear the webhook URL. */
+    setWebhook(url: string): Record<string, unknown>;
+    /** Close a connection by ID (administrative). */
+    disconnect(connId: number): void;
+    /** Open a stream connection to addr (format: "N:XXXX.YYYY.YYYY:PORT"). */
+    dial(addr: string): Conn;
+    /** Bind a port and return a Listener that accepts connections. */
+    listen(port: number): Listener;
+    /** Send an unreliable datagram. addr = "N:XXXX.YYYY.YYYY:PORT". */
+    sendTo(addr: string, data: Buffer | Uint8Array): void;
+    /** Receive the next incoming datagram (blocks). */
+    recvFrom(): Record<string, unknown>;
+    /** Resolve a target to a protocol address. Passes through if already an address. */
+    private _resolveTarget;
+    /**
+     * Send a message via the data exchange service (port 1001).
+     *
+     * @param target - Hostname or protocol address (N:XXXX.YYYY.YYYY)
+     * @param data - Message data
+     * @param msgType - Message type: "text", "json", or "binary"
+     */
+    sendMessage(target: string, data: Buffer | string, msgType?: 'text' | 'json' | 'binary'): Record<string, unknown>;
+    /**
+     * Send a file via the data exchange service (port 1001).
+     *
+     * @param target - Hostname or protocol address
+     * @param filePath - Path to file to send
+     */
+    sendFile(target: string, filePath: string): Record<string, unknown>;
+    /**
+     * Publish an event via the event stream service (port 1002).
+     *
+     * Wire format: [2-byte topic len][topic][4-byte payload len][payload]
+     * Protocol: first event = subscribe, subsequent events = publish
+     *
+     * @param target - Hostname or protocol address of event stream server
+     * @param topic - Event topic (e.g., "sensor/temperature")
+     * @param data - Event payload
+     */
+    publishEvent(target: string, topic: string, data: Buffer | string): Record<string, unknown>;
+    /**
+     * Subscribe to events from the event stream service (port 1002).
+     *
+     * @param target - Hostname or protocol address
+     * @param topic - Topic pattern to subscribe to (use "*" for all)
+     * @param callback - Callback function(topic, data) for each event
+     * @param timeout - Timeout in seconds (default: 30)
+     */
+    subscribeEvent(target: string, topic: string, callback: (eventTopic: string, eventData: Buffer) => void, timeout?: number): void;
+    /**
+     * Submit a task via the task submit service (port 1003).
+     *
+     * @param target - Hostname or protocol address of task execution server
+     * @param taskData - Task specification. Must include 'task_description'.
+     */
+    submitTask(target: string, taskData: Record<string, unknown>): Record<string, unknown>;
+}

package/dist/client.js

@@ -0,0 +1,491 @@
+/**
+ * Pilot Protocol Node.js SDK — koffi wrapper around libpilot shared library.
+ *
+ * This module provides a TypeScript/JavaScript interface to the Pilot Protocol
+ * daemon by calling into the Go driver compiled as a C-shared library
+ * (.so/.dylib/.dll). The Go library is the *single source of truth*; this
+ * wrapper is a thin FFI boundary that marshals arguments and unmarshals JSON.
+ *
+ * Usage:
+ *
+ *   import { Driver } from 'pilotprotocol';
+ *
+ *   const d = new Driver();          // connects to /tmp/pilot.sock
+ *   console.log(d.info());           // returns object
+ *   d.close();
+ *
+ * Or with explicit resource management:
+ *
+ *   using d = new Driver();
+ *   console.log(d.info());
+ *   // auto-closed at end of scope
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { basename } from 'node:path';
+import { PilotError, checkErr, loadLibrary, parseJSON, unwrapHandleErr, } from './ffi.js';
+// Re-export PilotError for public API
+export { PilotError } from './ffi.js';
+export const DEFAULT_SOCKET_PATH = '/tmp/pilot.sock';
+// Module-level singleton for the loaded library
+let _lib = null;
+function getLib() {
+    if (!_lib) {
+        _lib = loadLibrary();
+    }
+    return _lib;
+}
+/** Override the library instance (for testing). */
+export function _setLib(lib) {
+    _lib = lib;
+}
+/** Get the current library instance (for testing). */
+export function _getLib() {
+    return _lib;
+}
+// ---------------------------------------------------------------------------
+// Conn — stream connection wrapper
+// ---------------------------------------------------------------------------
+export class Conn {
+    _h;
+    _closed = false;
+    constructor(handle) {
+        this._h = handle;
+    }
+    /** Read up to `size` bytes. Blocks until data arrives. */
+    read(size = 4096) {
+        if (this._closed)
+            throw new PilotError('connection closed');
+        if (size <= 0)
+            return Buffer.alloc(0);
+        if (size > 16 * 1024 * 1024)
+            size = 16 * 1024 * 1024; // cap at 16MB
+        const lib = getLib();
+        const res = lib.PilotConnRead(this._h, size);
+        if (res.err) {
+            const obj = JSON.parse(res.err);
+            throw new PilotError(obj.error ?? 'read error');
+        }
+        if (res.n === 0 || !res.data)
+            return Buffer.alloc(0);
+        return res.data;
+    }
+    /** Write bytes to the connection. Returns bytes written. */
+    write(data) {
+        if (this._closed)
+            throw new PilotError('connection closed');
+        const lib = getLib();
+        // Allocate a dedicated Buffer to avoid shared-pool byteOffset issues
+        const src = typeof data === 'string' ? Buffer.from(data) : data;
+        const buf = Buffer.allocUnsafe(src.length);
+        Buffer.from(src).copy(buf);
+        const res = lib.PilotConnWrite(this._h, buf, buf.length);
+        if (res.err) {
+            const obj = JSON.parse(res.err);
+            throw new PilotError(obj.error ?? 'write error');
+        }
+        return res.n;
+    }
+    /** Close the connection. Idempotent. */
+    close() {
+        if (this._closed)
+            return;
+        this._closed = true;
+        const lib = getLib();
+        const ptr = lib.PilotConnClose(this._h);
+        checkErr(ptr);
+    }
+    /** Support TC39 explicit resource management. */
+    [Symbol.dispose]() {
+        this.close();
+    }
+}
+// ---------------------------------------------------------------------------
+// Listener — server socket wrapper
+// ---------------------------------------------------------------------------
+export class Listener {
+    _h;
+    _closed = false;
+    constructor(handle) {
+        this._h = handle;
+    }
+    /** Block until a new connection arrives and return it. */
+    accept() {
+        if (this._closed)
+            throw new PilotError('listener closed');
+        const lib = getLib();
+        const res = lib.PilotListenerAccept(this._h);
+        const handle = unwrapHandleErr(res);
+        return new Conn(handle);
+    }
+    /** Close the listener. Idempotent. */
+    close() {
+        if (this._closed)
+            return;
+        this._closed = true;
+        const lib = getLib();
+        const ptr = lib.PilotListenerClose(this._h);
+        checkErr(ptr);
+    }
+    /** Support TC39 explicit resource management. */
+    [Symbol.dispose]() {
+        this.close();
+    }
+}
+// ---------------------------------------------------------------------------
+// Driver — main SDK entry point
+// ---------------------------------------------------------------------------
+export class Driver {
+    _h;
+    _closed = false;
+    constructor(socketPath = DEFAULT_SOCKET_PATH) {
+        const lib = getLib();
+        const res = lib.PilotConnect(socketPath);
+        this._h = unwrapHandleErr(res);
+    }
+    /** Disconnect from the daemon. Idempotent. */
+    close() {
+        if (this._closed)
+            return;
+        this._closed = true;
+        const lib = getLib();
+        const ptr = lib.PilotClose(this._h);
+        checkErr(ptr);
+    }
+    /** Support TC39 explicit resource management. */
+    [Symbol.dispose]() {
+        this.close();
+    }
+    // -- JSON-RPC helper --
+    _callJSON(fnName, ...args) {
+        const lib = getLib();
+        const fn = lib[fnName];
+        const str = fn(this._h, ...args);
+        return parseJSON(str);
+    }
+    // -- Info --
+    /** Return the daemon's status information. */
+    info() {
+        return this._callJSON('PilotInfo');
+    }
+    // -- Handshake / Trust --
+    /** Send a trust handshake request to a remote node. */
+    handshake(nodeId, justification = '') {
+        return this._callJSON('PilotHandshake', nodeId, justification);
+    }
+    /** Approve a pending handshake request. */
+    approveHandshake(nodeId) {
+        return this._callJSON('PilotApproveHandshake', nodeId);
+    }
+    /** Reject a pending handshake request. */
+    rejectHandshake(nodeId, reason = '') {
+        return this._callJSON('PilotRejectHandshake', nodeId, reason);
+    }
+    /** Return pending trust handshake requests. */
+    pendingHandshakes() {
+        return this._callJSON('PilotPendingHandshakes');
+    }
+    /** Return all trusted peers. */
+    trustedPeers() {
+        return this._callJSON('PilotTrustedPeers');
+    }
+    /** Remove a peer from the trusted set. */
+    revokeTrust(nodeId) {
+        return this._callJSON('PilotRevokeTrust', nodeId);
+    }
+    // -- Hostname --
+    /** Resolve a hostname to node info. */
+    resolveHostname(hostname) {
+        return this._callJSON('PilotResolveHostname', hostname);
+    }
+    /** Set or clear the daemon's hostname. */
+    setHostname(hostname) {
+        return this._callJSON('PilotSetHostname', hostname);
+    }
+    // -- Visibility / capabilities --
+    /** Set the daemon's visibility on the registry. */
+    setVisibility(isPublic) {
+        return this._callJSON('PilotSetVisibility', isPublic ? 1 : 0);
+    }
+    /** Enable or disable task execution capability. */
+    setTaskExec(enabled) {
+        return this._callJSON('PilotSetTaskExec', enabled ? 1 : 0);
+    }
+    /** Remove the daemon from the registry. */
+    deregister() {
+        return this._callJSON('PilotDeregister');
+    }
+    /** Set capability tags for this node. */
+    setTags(tags) {
+        return this._callJSON('PilotSetTags', JSON.stringify(tags));
+    }
+    /** Set or clear the webhook URL. */
+    setWebhook(url) {
+        return this._callJSON('PilotSetWebhook', url);
+    }
+    // -- Connection management --
+    /** Close a connection by ID (administrative). */
+    disconnect(connId) {
+        const lib = getLib();
+        const ptr = lib.PilotDisconnect(this._h, connId);
+        checkErr(ptr);
+    }
+    // -- Streams --
+    /** Open a stream connection to addr (format: "N:XXXX.YYYY.YYYY:PORT"). */
+    dial(addr) {
+        const lib = getLib();
+        const res = lib.PilotDial(this._h, addr);
+        const handle = unwrapHandleErr(res);
+        return new Conn(handle);
+    }
+    /** Bind a port and return a Listener that accepts connections. */
+    listen(port) {
+        const lib = getLib();
+        const res = lib.PilotListen(this._h, port);
+        const handle = unwrapHandleErr(res);
+        return new Listener(handle);
+    }
+    // -- Datagrams --
+    /** Send an unreliable datagram. addr = "N:XXXX.YYYY.YYYY:PORT". */
+    sendTo(addr, data) {
+        const lib = getLib();
+        // Allocate a dedicated Buffer to avoid shared-pool byteOffset issues
+        const buf = Buffer.allocUnsafe(data.length);
+        Buffer.from(data).copy(buf);
+        const ptr = lib.PilotSendTo(this._h, addr, buf, buf.length);
+        checkErr(ptr);
+    }
+    /** Receive the next incoming datagram (blocks). */
+    recvFrom() {
+        return this._callJSON('PilotRecvFrom');
+    }
+    // -- High-level service methods --
+    /** Resolve a target to a protocol address. Passes through if already an address. */
+    _resolveTarget(target) {
+        if (!target.startsWith('0:')) {
+            const result = this.resolveHostname(target);
+            const addr = result['address'];
+            if (!addr)
+                throw new PilotError(`Could not resolve hostname: ${target}`);
+            return addr;
+        }
+        return target;
+    }
+    /**
+     * Send a message via the data exchange service (port 1001).
+     *
+     * @param target - Hostname or protocol address (N:XXXX.YYYY.YYYY)
+     * @param data - Message data
+     * @param msgType - Message type: "text", "json", or "binary"
+     */
+    sendMessage(target, data, msgType = 'text') {
+        const buf = typeof data === 'string' ? Buffer.from(data) : Buffer.from(data);
+        const addr = this._resolveTarget(target);
+        // Map type to frame type: 1=text, 2=binary, 3=json, 4=file
+        const typeMap = { text: 1, binary: 2, json: 3, file: 4 };
+        const frameType = typeMap[msgType] ?? 1;
+        // Build frame: [4-byte type][4-byte length][payload]
+        const header = Buffer.alloc(8);
+        header.writeUInt32BE(frameType, 0);
+        header.writeUInt32BE(buf.length, 4);
+        const frame = Buffer.concat([header, buf]);
+        const conn = this.dial(`${addr}:1001`);
+        try {
+            conn.write(frame);
+            try {
+                const ackHeader = conn.read(8);
+                if (ackHeader && ackHeader.length === 8) {
+                    const ackLen = ackHeader.readUInt32BE(4);
+                    const ackPayload = conn.read(ackLen);
+                    if (ackPayload && ackPayload.length > 0) {
+                        const ackMsg = ackPayload.toString('utf-8');
+                        return { sent: buf.length, type: msgType, target: addr, ack: ackMsg };
+                    }
+                }
+            }
+            catch {
+                // ACK read failed, but message was sent
+            }
+            return { sent: buf.length, type: msgType, target: addr };
+        }
+        finally {
+            conn.close();
+        }
+    }
+    /**
+     * Send a file via the data exchange service (port 1001).
+     *
+     * @param target - Hostname or protocol address
+     * @param filePath - Path to file to send
+     */
+    sendFile(target, filePath) {
+        if (!existsSync(filePath)) {
+            throw new PilotError(`File not found: ${filePath}`);
+        }
+        const fileData = readFileSync(filePath);
+        const filename = basename(filePath);
+        const filenameBytes = Buffer.from(filename, 'utf-8');
+        // For TypeFile: payload = [2-byte name len][name][file data]
+        const nameHeader = Buffer.alloc(2);
+        nameHeader.writeUInt16BE(filenameBytes.length, 0);
+        const payload = Buffer.concat([nameHeader, filenameBytes, fileData]);
+        // Build frame: [4-byte type=4][4-byte length][payload]
+        const header = Buffer.alloc(8);
+        header.writeUInt32BE(4, 0);
+        header.writeUInt32BE(payload.length, 4);
+        const frame = Buffer.concat([header, payload]);
+        const addr = this._resolveTarget(target);
+        const conn = this.dial(`${addr}:1001`);
+        try {
+            conn.write(frame);
+            try {
+                const ackHeader = conn.read(8);
+                if (ackHeader && ackHeader.length === 8) {
+                    const ackLen = ackHeader.readUInt32BE(4);
+                    const ackPayload = conn.read(ackLen);
+                    if (ackPayload && ackPayload.length > 0) {
+                        const ackMsg = ackPayload.toString('utf-8');
+                        return { sent: fileData.length, filename, target: addr, ack: ackMsg };
+                    }
+                }
+            }
+            catch {
+                // ACK read failed, but file was sent
+            }
+            return { sent: fileData.length, filename, target: addr };
+        }
+        finally {
+            conn.close();
+        }
+    }
+    /**
+     * Publish an event via the event stream service (port 1002).
+     *
+     * Wire format: [2-byte topic len][topic][4-byte payload len][payload]
+     * Protocol: first event = subscribe, subsequent events = publish
+     *
+     * @param target - Hostname or protocol address of event stream server
+     * @param topic - Event topic (e.g., "sensor/temperature")
+     * @param data - Event payload
+     */
+    publishEvent(target, topic, data) {
+        const addr = this._resolveTarget(target);
+        const payload = typeof data === 'string' ? Buffer.from(data) : Buffer.from(data);
+        const conn = this.dial(`${addr}:1002`);
+        try {
+            // Subscribe to topic first (empty payload)
+            conn.write(buildEventFrame(topic, Buffer.alloc(0)));
+            // Now publish the actual event
+            conn.write(buildEventFrame(topic, payload));
+            return { status: 'published', topic, bytes: payload.length };
+        }
+        finally {
+            conn.close();
+        }
+    }
+    /**
+     * Subscribe to events from the event stream service (port 1002).
+     *
+     * @param target - Hostname or protocol address
+     * @param topic - Topic pattern to subscribe to (use "*" for all)
+     * @param callback - Callback function(topic, data) for each event
+     * @param timeout - Timeout in seconds (default: 30)
+     */
+    subscribeEvent(target, topic, callback, timeout = 30) {
+        const addr = this._resolveTarget(target);
+        const conn = this.dial(`${addr}:1002`);
+        try {
+            // Send subscription (empty payload)
+            conn.write(buildEventFrame(topic, Buffer.alloc(0)));
+            const deadline = Date.now() + timeout * 1000;
+            while (Date.now() < deadline) {
+                try {
+                    const event = readEventFrame(conn);
+                    if (!event)
+                        break;
+                    callback(event.topic, event.data);
+                }
+                catch (e) {
+                    const msg = String(e);
+                    if (msg.includes('connection closed') || msg.includes('EOF'))
+                        break;
+                    throw e;
+                }
+            }
+        }
+        finally {
+            conn.close();
+        }
+    }
+    /**
+     * Submit a task via the task submit service (port 1003).
+     *
+     * @param target - Hostname or protocol address of task execution server
+     * @param taskData - Task specification. Must include 'task_description'.
+     */
+    submitTask(target, taskData) {
+        const addr = this._resolveTarget(target);
+        const nodeInfo = this.info();
+        const fromAddr = nodeInfo['address'] ?? 'unknown';
+        const submitReq = {
+            task_id: taskData['task_id'] ?? crypto.randomUUID(),
+            task_description: taskData['task_description'] ?? JSON.stringify(taskData),
+            from_addr: fromAddr,
+            to_addr: addr,
+        };
+        const taskJson = Buffer.from(JSON.stringify(submitReq), 'utf-8');
+        // Build submit frame: [4-byte type=1][4-byte length][JSON payload]
+        const header = Buffer.alloc(8);
+        header.writeUInt32BE(1, 0);
+        header.writeUInt32BE(taskJson.length, 4);
+        const frame = Buffer.concat([header, taskJson]);
+        const conn = this.dial(`${addr}:1003`);
+        try {
+            conn.write(frame);
+            // Read response frame: [4-byte type][4-byte length][JSON payload]
+            const respHeader = conn.read(8);
+            if (!respHeader || respHeader.length < 8) {
+                throw new PilotError('No response from task submit service');
+            }
+            const respLen = respHeader.readUInt32BE(4);
+            const respData = conn.read(respLen);
+            if (!respData || respData.length < respLen) {
+                throw new PilotError('Incomplete response from task submit service');
+            }
+            return JSON.parse(respData.toString('utf-8'));
+        }
+        finally {
+            conn.close();
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Event stream helpers
+// ---------------------------------------------------------------------------
+/** Build an event frame: [2-byte topic len][topic][4-byte payload len][payload]. */
+function buildEventFrame(topic, payload) {
+    const topicBytes = Buffer.from(topic, 'utf-8');
+    const header = Buffer.alloc(2 + topicBytes.length + 4);
+    header.writeUInt16BE(topicBytes.length, 0);
+    topicBytes.copy(header, 2);
+    header.writeUInt32BE(payload.length, 2 + topicBytes.length);
+    return Buffer.concat([header, payload]);
+}
+/** Read an event frame from a connection. Returns null on incomplete read. */
+function readEventFrame(conn) {
+    const topicLenBuf = conn.read(2);
+    if (!topicLenBuf || topicLenBuf.length < 2)
+        return null;
+    const topicLen = topicLenBuf.readUInt16BE(0);
+    const topicBuf = conn.read(topicLen);
+    if (!topicBuf || topicBuf.length < topicLen)
+        return null;
+    const topic = topicBuf.toString('utf-8');
+    const payloadLenBuf = conn.read(4);
+    if (!payloadLenBuf || payloadLenBuf.length < 4)
+        return null;
+    const payloadLen = payloadLenBuf.readUInt32BE(0);
+    const data = conn.read(payloadLen);
+    if (!data || data.length < payloadLen)
+        return null;
+    return { topic, data };
+}

package/dist/ffi.d.ts

@@ -0,0 +1,78 @@
+/**
+ * FFI binding layer — loads libpilot and declares all C function signatures.
+ *
+ * Uses koffi (pure-JS FFI, no native compilation) to call into the Go
+ * shared library that is the single source of truth for the protocol.
+ *
+ * IMPORTANT: All char* returns from Go are allocated with C.CString (malloc).
+ * We MUST call FreeString on every returned pointer to avoid memory leaks.
+ * To achieve this, loadLibrary() returns wrapper functions that:
+ *   1. Declare return types as 'void *' (not 'char *') to get raw pointers
+ *   2. Decode the string with koffi.decode()
+ *   3. Free the pointer with FreeString()
+ *   4. Return clean JS types (string | null, Buffer)
+ *
+ * This mirrors the Python SDK's approach of using c_void_p instead of c_char_p
+ * (see Python client.py lines 122-126).
+ */
+export declare class PilotError extends Error {
+    constructor(message: string);
+}
+export declare function findLibrary(): string;
+export interface PilotLib {
+    PilotConnect(socketPath: string): {
+        handle: bigint;
+        err: string | null;
+    };
+    PilotClose(h: bigint): string | null;
+    PilotInfo(h: bigint): string | null;
+    PilotHandshake(h: bigint, nodeId: number, justification: string): string | null;
+    PilotApproveHandshake(h: bigint, nodeId: number): string | null;
+    PilotRejectHandshake(h: bigint, nodeId: number, reason: string): string | null;
+    PilotPendingHandshakes(h: bigint): string | null;
+    PilotTrustedPeers(h: bigint): string | null;
+    PilotRevokeTrust(h: bigint, nodeId: number): string | null;
+    PilotResolveHostname(h: bigint, hostname: string): string | null;
+    PilotSetHostname(h: bigint, hostname: string): string | null;
+    PilotSetVisibility(h: bigint, public_: number): string | null;
+    PilotSetTaskExec(h: bigint, enabled: number): string | null;
+    PilotDeregister(h: bigint): string | null;
+    PilotSetTags(h: bigint, tagsJson: string): string | null;
+    PilotSetWebhook(h: bigint, url: string): string | null;
+    PilotDisconnect(h: bigint, connId: number): string | null;
+    PilotRecvFrom(h: bigint): string | null;
+    PilotDial(h: bigint, addr: string): {
+        handle: bigint;
+        err: string | null;
+    };
+    PilotListen(h: bigint, port: number): {
+        handle: bigint;
+        err: string | null;
+    };
+    PilotListenerAccept(h: bigint): {
+        handle: bigint;
+        err: string | null;
+    };
+    PilotListenerClose(h: bigint): string | null;
+    PilotConnRead(h: bigint, bufSize: number): {
+        n: number;
+        data: Buffer | null;
+        err: string | null;
+    };
+    PilotConnWrite(h: bigint, data: Buffer, dataLen: number): {
+        n: number;
+        err: string | null;
+    };
+    PilotConnClose(h: bigint): string | null;
+    PilotSendTo(h: bigint, addr: string, data: Buffer, dataLen: number): string | null;
+}
+export declare function loadLibrary(path?: string): PilotLib;
+/** Parse a JSON string return. Raises PilotError if it contains {"error": ...}. */
+export declare function parseJSON(str: string | null): Record<string, unknown>;
+/** Check a string error result. Raises PilotError if non-null. */
+export declare function checkErr(str: string | null): void;
+/** Check HandleErr result and throw if err is set. Returns handle. */
+export declare function unwrapHandleErr(res: {
+    handle: bigint;
+    err: string | null;
+}): bigint;

package/dist/ffi.js

@@ -0,0 +1,228 @@
+/**
+ * FFI binding layer — loads libpilot and declares all C function signatures.
+ *
+ * Uses koffi (pure-JS FFI, no native compilation) to call into the Go
+ * shared library that is the single source of truth for the protocol.
+ *
+ * IMPORTANT: All char* returns from Go are allocated with C.CString (malloc).
+ * We MUST call FreeString on every returned pointer to avoid memory leaks.
+ * To achieve this, loadLibrary() returns wrapper functions that:
+ *   1. Declare return types as 'void *' (not 'char *') to get raw pointers
+ *   2. Decode the string with koffi.decode()
+ *   3. Free the pointer with FreeString()
+ *   4. Return clean JS types (string | null, Buffer)
+ *
+ * This mirrors the Python SDK's approach of using c_void_p instead of c_char_p
+ * (see Python client.py lines 122-126).
+ */
+import koffi from 'koffi';
+import { existsSync } from 'node:fs';
+import { homedir, platform } from 'node:os';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+// ---------------------------------------------------------------------------
+// Error class (defined here to avoid circular deps with client.ts)
+// ---------------------------------------------------------------------------
+export class PilotError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PilotError';
+    }
+}
+// ---------------------------------------------------------------------------
+// Library discovery
+// ---------------------------------------------------------------------------
+const LIB_NAMES = {
+    darwin: 'libpilot.dylib',
+    linux: 'libpilot.so',
+    win32: 'libpilot.dll',
+};
+export function findLibrary() {
+    const libName = LIB_NAMES[platform()];
+    if (!libName) {
+        throw new Error(`unsupported platform: ${platform()}`);
+    }
+    // 1. PILOT_LIB_PATH env var
+    const envPath = process.env['PILOT_LIB_PATH'];
+    if (envPath) {
+        if (existsSync(envPath))
+            return envPath;
+        throw new Error(`PILOT_LIB_PATH=${envPath} does not exist`);
+    }
+    // 2. ~/.pilot/bin/
+    const pilotBin = join(homedir(), '.pilot', 'bin', libName);
+    if (existsSync(pilotBin))
+        return pilotBin;
+    // 3. <package>/bin/ (npm package layout: dist/ffi.js → ../bin/)
+    const thisDir = resolve(fileURLToPath(import.meta.url), '..');
+    const pkgBin = resolve(thisDir, '..', 'bin', libName);
+    if (existsSync(pkgBin))
+        return pkgBin;
+    // 4. Same directory as this file
+    const colocated = join(thisDir, libName);
+    if (existsSync(colocated))
+        return colocated;
+    // 5. <repo>/bin/ (development layout — 3 levels up from dist/)
+    const repoBin = resolve(thisDir, '..', '..', '..', 'bin', libName);
+    if (existsSync(repoBin))
+        return repoBin;
+    throw new Error(`Cannot find ${libName}.\n` +
+        '\n' +
+        'Expected locations:\n' +
+        `  - ~/.pilot/bin/${libName}\n` +
+        `  - ${pkgBin} (npm package)\n` +
+        `  - ${colocated} (colocated)\n` +
+        `  - ${repoBin} (development)\n` +
+        '\n' +
+        'Build it with:\n' +
+        '  cd sdk/node && ./scripts/build-binaries.sh\n' +
+        '\n' +
+        'Or set PILOT_LIB_PATH:\n' +
+        `  export PILOT_LIB_PATH=/path/to/${libName}`);
+}
+// ---------------------------------------------------------------------------
+// Library loading with memory-safe wrappers
+// ---------------------------------------------------------------------------
+/**
+ * Struct definitions use 'void *' for all char* fields to preserve raw
+ * pointers. koffi's 'char *' auto-decodes to JS string and discards the
+ * pointer — making it impossible to call FreeString. Using 'void *' gives
+ * us the raw pointer so we can decode + free explicitly.
+ */
+const HandleErrStruct = koffi.struct('HandleErr', {
+    handle: 'uint64',
+    err: 'void *',
+});
+const ReadResultStruct = koffi.struct('ReadResult', {
+    n: 'int',
+    data: 'void *',
+    err: 'void *',
+});
+const WriteResultStruct = koffi.struct('WriteResult', {
+    n: 'int',
+    err: 'void *',
+});
+export function loadLibrary(path) {
+    const libPath = path ?? findLibrary();
+    const lib = koffi.load(libPath);
+    // Raw FFI declarations — all char* returns use 'void *'
+    const rawFree = lib.func('FreeString', 'void', ['void *']);
+    const rawConnect = lib.func('PilotConnect', HandleErrStruct, ['str']);
+    const rawClose = lib.func('PilotClose', 'void *', ['uint64']);
+    const rawInfo = lib.func('PilotInfo', 'void *', ['uint64']);
+    const rawHandshake = lib.func('PilotHandshake', 'void *', ['uint64', 'uint32', 'str']);
+    const rawApproveHandshake = lib.func('PilotApproveHandshake', 'void *', ['uint64', 'uint32']);
+    const rawRejectHandshake = lib.func('PilotRejectHandshake', 'void *', ['uint64', 'uint32', 'str']);
+    const rawPendingHandshakes = lib.func('PilotPendingHandshakes', 'void *', ['uint64']);
+    const rawTrustedPeers = lib.func('PilotTrustedPeers', 'void *', ['uint64']);
+    const rawRevokeTrust = lib.func('PilotRevokeTrust', 'void *', ['uint64', 'uint32']);
+    const rawResolveHostname = lib.func('PilotResolveHostname', 'void *', ['uint64', 'str']);
+    const rawSetHostname = lib.func('PilotSetHostname', 'void *', ['uint64', 'str']);
+    const rawSetVisibility = lib.func('PilotSetVisibility', 'void *', ['uint64', 'int']);
+    const rawSetTaskExec = lib.func('PilotSetTaskExec', 'void *', ['uint64', 'int']);
+    const rawDeregister = lib.func('PilotDeregister', 'void *', ['uint64']);
+    const rawSetTags = lib.func('PilotSetTags', 'void *', ['uint64', 'str']);
+    const rawSetWebhook = lib.func('PilotSetWebhook', 'void *', ['uint64', 'str']);
+    const rawDisconnect = lib.func('PilotDisconnect', 'void *', ['uint64', 'uint32']);
+    const rawRecvFrom = lib.func('PilotRecvFrom', 'void *', ['uint64']);
+    const rawDial = lib.func('PilotDial', HandleErrStruct, ['uint64', 'str']);
+    const rawListen = lib.func('PilotListen', HandleErrStruct, ['uint64', 'uint16']);
+    const rawListenerAccept = lib.func('PilotListenerAccept', HandleErrStruct, ['uint64']);
+    const rawListenerClose = lib.func('PilotListenerClose', 'void *', ['uint64']);
+    const rawConnRead = lib.func('PilotConnRead', ReadResultStruct, ['uint64', 'int']);
+    const rawConnWrite = lib.func('PilotConnWrite', WriteResultStruct, ['uint64', 'void *', 'int']);
+    const rawConnClose = lib.func('PilotConnClose', 'void *', ['uint64']);
+    const rawSendTo = lib.func('PilotSendTo', 'void *', ['uint64', 'str', 'void *', 'int']);
+    /** Decode a void* C string, free the pointer, return JS string. */
+    function decodeAndFree(ptr) {
+        if (!ptr)
+            return null;
+        const str = koffi.decode(ptr, 'char', -1);
+        rawFree(ptr);
+        return str;
+    }
+    /** Unwrap a HandleErr struct: decode+free err, return clean result. */
+    function unwrapHandle(res) {
+        return { handle: res.handle, err: decodeAndFree(res.err) };
+    }
+    /** Wrap a raw FFI function that returns void* (JSON char*). */
+    function wrapJSON(fn) {
+        return (...args) => decodeAndFree(fn(...args));
+    }
+    return {
+        PilotConnect: (socketPath) => unwrapHandle(rawConnect(socketPath)),
+        PilotClose: (h) => decodeAndFree(rawClose(h)),
+        PilotInfo: wrapJSON(rawInfo),
+        PilotHandshake: wrapJSON(rawHandshake),
+        PilotApproveHandshake: wrapJSON(rawApproveHandshake),
+        PilotRejectHandshake: wrapJSON(rawRejectHandshake),
+        PilotPendingHandshakes: wrapJSON(rawPendingHandshakes),
+        PilotTrustedPeers: wrapJSON(rawTrustedPeers),
+        PilotRevokeTrust: wrapJSON(rawRevokeTrust),
+        PilotResolveHostname: wrapJSON(rawResolveHostname),
+        PilotSetHostname: wrapJSON(rawSetHostname),
+        PilotSetVisibility: wrapJSON(rawSetVisibility),
+        PilotSetTaskExec: wrapJSON(rawSetTaskExec),
+        PilotDeregister: wrapJSON(rawDeregister),
+        PilotSetTags: wrapJSON(rawSetTags),
+        PilotSetWebhook: wrapJSON(rawSetWebhook),
+        PilotDisconnect: wrapJSON(rawDisconnect),
+        PilotRecvFrom: wrapJSON(rawRecvFrom),
+        PilotDial: (h, addr) => unwrapHandle(rawDial(h, addr)),
+        PilotListen: (h, port) => unwrapHandle(rawListen(h, port)),
+        PilotListenerAccept: (h) => unwrapHandle(rawListenerAccept(h)),
+        PilotListenerClose: (h) => decodeAndFree(rawListenerClose(h)),
+        PilotConnRead(h, bufSize) {
+            const res = rawConnRead(h, bufSize);
+            const err = decodeAndFree(res.err);
+            let data = null;
+            if (res.data && res.n > 0) {
+                // Decode n bytes from the C.CBytes-allocated pointer into a Buffer
+                const bytes = koffi.decode(res.data, 'uint8', res.n);
+                data = Buffer.from(bytes);
+                rawFree(res.data); // Free the C.CBytes allocation
+            }
+            return { n: res.n, data, err };
+        },
+        PilotConnWrite(h, buf, dataLen) {
+            // Pass Buffer directly — koffi handles byteOffset correctly for void*
+            const res = rawConnWrite(h, buf, dataLen);
+            return { n: res.n, err: decodeAndFree(res.err) };
+        },
+        PilotConnClose: (h) => decodeAndFree(rawConnClose(h)),
+        PilotSendTo(h, addr, buf, dataLen) {
+            // Pass Buffer directly — koffi handles byteOffset correctly for void*
+            return decodeAndFree(rawSendTo(h, addr, buf, dataLen));
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Helpers (operate on clean JS types, not raw pointers)
+// ---------------------------------------------------------------------------
+/** Parse a JSON string return. Raises PilotError if it contains {"error": ...}. */
+export function parseJSON(str) {
+    if (!str)
+        return {};
+    const obj = JSON.parse(str);
+    if (obj.error) {
+        throw new PilotError(obj.error);
+    }
+    return obj;
+}
+/** Check a string error result. Raises PilotError if non-null. */
+export function checkErr(str) {
+    if (!str)
+        return;
+    const obj = JSON.parse(str);
+    if (obj.error) {
+        throw new PilotError(obj.error);
+    }
+}
+/** Check HandleErr result and throw if err is set. Returns handle. */
+export function unwrapHandleErr(res) {
+    if (res.err) {
+        const obj = JSON.parse(res.err);
+        throw new PilotError(obj.error ?? 'unknown error');
+    }
+    return res.handle;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { Driver, Conn, Listener, DEFAULT_SOCKET_PATH, PilotError } from './client.js';
+export { findLibrary, loadLibrary } from './ffi.js';
+export type { PilotLib } from './ffi.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+export { Driver, Conn, Listener, DEFAULT_SOCKET_PATH, PilotError } from './client.js';
+export { findLibrary, loadLibrary } from './ffi.js';

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "pilotprotocol",
+  "version": "0.1.0",
+  "description": "Node.js SDK for Pilot Protocol — the network stack for AI agents",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "bin": {
+    "pilotctl": "bin-stubs/pilotctl.js",
+    "pilot-daemon": "bin-stubs/pilot-daemon.js",
+    "pilot-gateway": "bin-stubs/pilot-gateway.js",
+    "pilot-updater": "bin-stubs/pilot-updater.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "clean": "rm -rf dist/",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "pilot-protocol",
+    "networking",
+    "p2p",
+    "agent",
+    "ai",
+    "protocol",
+    "overlay",
+    "udp",
+    "encryption",
+    "ffi"
+  ],
+  "license": "AGPL-3.0-or-later",
+  "author": {
+    "name": "Alexandru Godoroja",
+    "email": "alex@vulturelabs.com"
+  },
+  "contributors": [
+    {
+      "name": "Teodor Calin",
+      "email": "teodor@vulturelabs.com"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TeoSlayer/pilotprotocol",
+    "directory": "sdk/node"
+  },
+  "homepage": "https://pilotprotocol.network",
+  "bugs": {
+    "url": "https://github.com/TeoSlayer/pilotprotocol/issues"
+  },
+  "dependencies": {
+    "koffi": "^2.9.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "os": [
+    "darwin",
+    "linux"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "files": [
+    "dist/",
+    "bin/",
+    "bin-stubs/"
+  ]
+}