@totemsdk/edge-coap 0.1.0 → 0.3.0

package/dist/cjs/native-transport.js

@@ -0,0 +1,183 @@
+"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 send requests. Inbound datagrams are pushed
+ * back as `message` events; token correlation stays in the gateway.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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.closedByUser = false;
+        this.config = {
+            host: config.host ?? '127.0.0.1',
+            port: config.port ?? 15003,
+            connectTimeoutMs: config.connectTimeoutMs ?? 5000,
+            requestTimeoutMs: config.requestTimeoutMs ?? 10000,
+        };
+    }
+    emitError(error) {
+        for (const handler of this.errorHandlers) {
+            try {
+                handler(error);
+            }
+            catch { }
+        }
+    }
+    async bind(_port) {
+        const net = await Promise.resolve().then(() => __importStar(require('net')));
+        this.closedByUser = false;
+        this.buffer = '';
+        return new Promise((resolve, reject) => {
+            let connected = false;
+            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);
+                connected = true;
+                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') {
+                            if (typeof msg.host !== 'string' || typeof msg.port !== 'number' || typeof msg.data !== 'string')
+                                continue;
+                            const data = hexToBytes(msg.data);
+                            for (const handler of this.messageHandlers) {
+                                try {
+                                    handler(data, { host: msg.host, port: msg.port });
+                                }
+                                catch { }
+                            }
+                        }
+                        else if (msg.type === 'error') {
+                            this.emitError(new Error(`NativeCoapTransport: ${msg.code ?? 'error'}: ${msg.error ?? 'unknown error'}`));
+                        }
+                        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) => {
+                if (!connected) {
+                    clearTimeout(timer);
+                    this.socket?.destroy();
+                    reject(err);
+                }
+                this.emitError(err);
+            });
+            this.socket.on('close', () => {
+                for (const [, p] of this.pending)
+                    p.reject(new Error('connection closed'));
+                this.pending.clear();
+                if (!this.closedByUser)
+                    this.emitError(new Error('NativeCoapTransport: connection closed'));
+            });
+        });
+    }
+    async close() {
+        this.closedByUser = true;
+        if (this.socket) {
+            this.socket.destroy();
+            this.socket = null;
+        }
+        for (const [, p] of this.pending)
+            p.reject(new Error('connection closed'));
+        this.pending.clear();
+    }
+    async send(host, port, message) {
+        if (!this.socket || this.socket.destroyed)
+            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/dist/cjs/oscore.d.ts

@@ -0,0 +1,32 @@
+/**
+ * OSCORE (RFC 8613) security context for Node.js.
+ *
+ * The connector stays crypto-free; this adapter implements the OSCORE client
+ * and server roles behind `CoapSecurityPort` using Node's `aes-128-ccm` and
+ * HKDF-SHA-256. It is validated against the RFC 8613 Appendix C vectors.
+ *
+ * Supported profile: AES-CCM-16-64-128 (alg 10), HKDF-SHA-256, no Class I
+ * options (none are currently defined), and the CoAP fields modeled by
+ * `CoapMessage`. Uri-Host/Uri-Port remain outer (Class U); Uri-Path and
+ * Uri-Query are inner (Class E). Block options are inner. Blockwise
+ * observations and multicast are outside this adapter's scope.
+ */
+import type { CoapSecurityPort } from './security.js';
+export interface OscoreContextConfig {
+    masterSecret: Uint8Array;
+    /** Optional master salt; defaults to the empty byte string. */
+    masterSalt?: Uint8Array;
+    senderId: Uint8Array;
+    recipientId: Uint8Array;
+    idContext?: Uint8Array;
+    /** Initial sender sequence number (Partial IV). Default 0. */
+    senderSequenceNumber?: number;
+    /** Anti-replay window for inbound Partial IVs. Default 32. */
+    replayWindowSize?: number;
+    /** Restrict protection to these endpoints. Default: all endpoints. */
+    endpoints?: Array<{
+        host: string;
+        port: number;
+    }>;
+}
+export declare function createOscoreContext(config: OscoreContextConfig): Promise<CoapSecurityPort>;