@totemsdk/edge-coap 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -3,3 +3,5 @@ export { createCoapGateway } from './gateway.js';
 export type { CoapGatewayConfig, CoapGateway } from './gateway.js';
 export { createCoapSensorBridge } from './sensor-bridge.js';
 export type { CoapSensorBinding, CoapSensorBridgeConfig, CoapSensorBridge } from './sensor-bridge.js';
+export { NativeCoapTransport } from './native-transport.js';
+export type { NativeCoapConfig } from './native-transport.js';

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCoapSensorBridge = exports.createCoapGateway = void 0;
+exports.NativeCoapTransport = exports.createCoapSensorBridge = exports.createCoapGateway = void 0;
 var gateway_js_1 = require("./gateway.js");
 Object.defineProperty(exports, "createCoapGateway", { enumerable: true, get: function () { return gateway_js_1.createCoapGateway; } });
 var sensor_bridge_js_1 = require("./sensor-bridge.js");
 Object.defineProperty(exports, "createCoapSensorBridge", { enumerable: true, get: function () { return sensor_bridge_js_1.createCoapSensorBridge; } });
+var native_transport_js_1 = require("./native-transport.js");
+Object.defineProperty(exports, "NativeCoapTransport", { enumerable: true, get: function () { return native_transport_js_1.NativeCoapTransport; } });

package/dist/native-transport.d.ts

@@ -0,0 +1,31 @@
+/**
+ * NativeCoapTransport — connects to the edge-coap Go binary over TCP.
+ *
+ * The Go binary listens on a local TCP socket (default 127.0.0.1:15003)
+ * and accepts newline-delimited JSON requests. This class implements
+ * CoapTransportPort by forwarding all calls to the Go process.
+ */
+import type { CoapTransportPort } from './transport.js';
+export interface NativeCoapConfig {
+    host?: string;
+    port?: number;
+    connectTimeoutMs?: number;
+    requestTimeoutMs?: number;
+}
+export declare class NativeCoapTransport implements CoapTransportPort {
+    private socket;
+    private buffer;
+    private pending;
+    private messageHandlers;
+    private errorHandlers;
+    private readonly config;
+    constructor(config?: NativeCoapConfig);
+    bind(_port: number): Promise<void>;
+    close(): Promise<void>;
+    send(host: string, port: number, message: Uint8Array): Promise<void>;
+    onMessage(handler: (message: Uint8Array, remote: {
+        host: string;
+        port: number;
+    }) => void): () => void;
+    onError(handler: (err: Error) => void): () => void;
+}

package/dist/native-transport.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * NativeCoapTransport — connects to the edge-coap Go binary over TCP.
+ *
+ * The Go binary listens on a local TCP socket (default 127.0.0.1:15003)
+ * and accepts newline-delimited JSON requests. This class implements
+ * CoapTransportPort by forwarding all calls to the Go process.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeCoapTransport = void 0;
+let requestCounter = 0;
+class NativeCoapTransport {
+    constructor(config = {}) {
+        this.socket = null;
+        this.buffer = '';
+        this.pending = new Map();
+        this.messageHandlers = [];
+        this.errorHandlers = [];
+        this.config = {
+            host: config.host ?? '127.0.0.1',
+            port: config.port ?? 15003,
+            connectTimeoutMs: config.connectTimeoutMs ?? 5000,
+            requestTimeoutMs: config.requestTimeoutMs ?? 10000,
+        };
+    }
+    async bind(_port) {
+        const net = await import('net');
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.socket?.destroy();
+                reject(new Error(`NativeCoapTransport: connect timeout`));
+            }, this.config.connectTimeoutMs);
+            this.socket = net.createConnection({ host: this.config.host, port: this.config.port }, () => {
+                clearTimeout(timer);
+                resolve();
+            });
+            this.socket.on('data', (chunk) => {
+                this.buffer += chunk.toString('utf-8');
+                const lines = this.buffer.split('\n');
+                this.buffer = lines.pop() ?? '';
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const msg = JSON.parse(line);
+                        if (msg.type === 'message') {
+                            const push = msg;
+                            const data = hexToBytes(push.data);
+                            for (const handler of this.messageHandlers) {
+                                try {
+                                    handler(data, { host: push.host, port: push.port });
+                                }
+                                catch { }
+                            }
+                        }
+                        else if (msg.id && this.pending.has(msg.id)) {
+                            const { resolve: res, reject: rej } = this.pending.get(msg.id);
+                            this.pending.delete(msg.id);
+                            if (msg.ok)
+                                res();
+                            else
+                                rej(new Error(msg.error ?? 'unknown error'));
+                        }
+                    }
+                    catch { }
+                }
+            });
+            this.socket.on('error', (err) => {
+                for (const handler of this.errorHandlers) {
+                    try {
+                        handler(err);
+                    }
+                    catch { }
+                }
+            });
+            this.socket.on('close', () => {
+                for (const [, p] of this.pending)
+                    p.reject(new Error('connection closed'));
+                this.pending.clear();
+            });
+        });
+    }
+    async close() {
+        if (this.socket) {
+            this.socket.destroy();
+            this.socket = null;
+        }
+    }
+    async send(host, port, message) {
+        if (!this.socket)
+            throw new Error('NativeCoapTransport: not connected');
+        const id = `coap-${++requestCounter}`;
+        const req = { id, host, port, data: bytesToHex(message) };
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`NativeCoapTransport: request ${id} timed out`));
+            }, this.config.requestTimeoutMs);
+            this.pending.set(id, {
+                resolve: () => { clearTimeout(timer); resolve(); },
+                reject: (err) => { clearTimeout(timer); reject(err); },
+            });
+            this.socket.write(JSON.stringify(req) + '\n');
+        });
+    }
+    onMessage(handler) {
+        this.messageHandlers.push(handler);
+        return () => { this.messageHandlers = this.messageHandlers.filter(h => h !== handler); };
+    }
+    onError(handler) {
+        this.errorHandlers.push(handler);
+        return () => { this.errorHandlers = this.errorHandlers.filter(h => h !== handler); };
+    }
+}
+exports.NativeCoapTransport = NativeCoapTransport;
+function bytesToHex(bytes) {
+    return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
+}
+function hexToBytes(hex) {
+    if (hex.length % 2 !== 0)
+        throw new Error('Invalid hex string');
+    const arr = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < arr.length; i++) {
+        arr[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    }
+    return arr;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@totemsdk/edge-coap",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Edge runtime adapter for CoAP — constrained devices, RFC 7252, UDP transport",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,15 +11,13 @@
       "import": "./dist/index.js"
     }
   },
-  "scripts": {
-    "build": "tsc",
-    "prepare": "tsc",
-    "clean": "rm -rf dist",
-    "test": "jest --passWithNoTests"
-  },
-  "files": ["dist", "README.md", "LICENSE"],
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
   "dependencies": {
-    "@totemsdk/edge": "^0.1.3"
+    "@totemsdk/edge": "^1.0.0"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",
@@ -28,16 +26,36 @@
     "ts-jest": "^29.0.0",
     "typescript": "^7.0.2"
   },
-  "engines": { "node": ">=18.0.0" },
-  "publishConfig": { "access": "public" },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
   "license": "MIT",
   "author": "Totem SDK",
   "homepage": "https://totem.ing",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/totem-sdk/totem-sdk.git",
-    "directory": "packages/totem-sdk/packages/edge-coap"
+    "url": "git+https://github.com/Totem-Edge/totem-sdk.git",
+    "directory": "packages/edge-coap"
+  },
+  "keywords": [
+    "totem",
+    "totemsdk",
+    "minima",
+    "blockchain",
+    "edge",
+    "coap",
+    "transport"
+  ],
+  "bugs": {
+    "url": "https://github.com/Totem-Edge/totem-sdk/issues"
   },
-  "keywords": ["totem", "totemsdk", "minima", "blockchain", "edge", "coap", "transport"],
-  "bugs": { "url": "https://github.com/totem-sdk/totem-sdk/issues" }
-}
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist bin",
+    "test": "jest",
+    "build:go": "cd go && go build -o ../bin/edge-coap ."
+  }
+}