@wuyuchentr/webassembly-runtime-embed 2.0.0 → 4.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wuyuchentr/webassembly-runtime-embed",
-  "version": "2.0.0",
+  "version": "4.0.0",
   "description": "Embed WebAssembly runtime in Node.js with WASI support, multi-instance isolation, resource limits, and remote loading with cache.",
   "bin": {
     "webassembly-runtime-embed": "bin/cli.js"

package/src/cluster.js

@@ -0,0 +1,365 @@
+const net = require('net');
+const crypto = require('crypto');
+const EventEmitter = require('events');
+
+const PROTOCOL_VERSION = 1;
+
+function pack(msg) {
+  return JSON.stringify(msg) + '\n';
+}
+
+function unpack(data) {
+  const lines = data.toString('utf8').trim().split('\n');
+  return lines.filter(Boolean).map(l => JSON.parse(l));
+}
+
+class WasmWorker extends EventEmitter {
+  constructor(runtime, options = {}) {
+    super();
+    this.runtime = runtime;
+    this.port = options.port || 0;
+    this.host = options.host || '0.0.0.0';
+    this.authToken = options.authToken || null;
+    this._instances = new Map();
+    this._server = null;
+    this._sockets = new Set();
+  }
+
+  register(name, instance) {
+    this._instances.set(name, instance);
+    this.emit('register', name, instance);
+  }
+
+  unregister(name) {
+    this._instances.delete(name);
+    this.emit('unregister', name);
+  }
+
+  list() {
+    return Array.from(this._instances.keys());
+  }
+
+  async listen() {
+    return new Promise((resolve, reject) => {
+      this._server = net.createServer((socket) => this._handleSocket(socket));
+      this._server.once('error', reject);
+      this._server.listen(this.port, this.host, () => {
+        const addr = this._server.address();
+        this.port = addr.port;
+        this.emit('listening', { port: addr.port, host: this.host });
+        resolve(addr);
+      });
+    });
+  }
+
+  async close() {
+    for (const socket of this._sockets) {
+      socket.destroy();
+    }
+    this._sockets.clear();
+    return new Promise((resolve) => {
+      if (!this._server) { resolve(); return; }
+      this._server.close(() => resolve());
+    });
+  }
+
+  _handleSocket(socket) {
+    const conn = { socket, buffer: Buffer.alloc(0), authenticated: !this.authToken };
+    this._sockets.add(socket);
+
+    socket.on('data', (data) => this._onData(conn, data));
+    socket.on('close', () => this._sockets.delete(socket));
+    socket.on('error', () => this._sockets.delete(socket));
+  }
+
+  _onData(conn, data) {
+    conn.buffer = Buffer.concat([conn.buffer, data]);
+
+    while (true) {
+      const nlIdx = conn.buffer.indexOf(0x0a);
+      if (nlIdx === -1) break;
+
+      const line = conn.buffer.slice(0, nlIdx);
+      conn.buffer = conn.buffer.slice(nlIdx + 1);
+
+      if (line.length === 0) continue;
+
+      try {
+        const msg = JSON.parse(line.toString('utf8'));
+        this._handleMessage(conn, msg);
+      } catch {
+        this._sendError(conn.socket, null, 'invalid JSON');
+      }
+    }
+  }
+
+  async _handleMessage(conn, msg) {
+    if (msg.type === 'auth') {
+      if (this.authToken && msg.token !== this.authToken) {
+        this._sendError(conn.socket, msg.id, 'auth failed');
+        conn.socket.destroy();
+        return;
+      }
+      conn.authenticated = true;
+      this._sendResponse(conn.socket, msg.id, { authenticated: true, version: PROTOCOL_VERSION });
+      return;
+    }
+
+    if (!conn.authenticated) {
+      this._sendError(conn.socket, msg.id, 'not authenticated');
+      return;
+    }
+
+    switch (msg.type) {
+      case 'call': {
+        await this._handleCall(conn, msg);
+        break;
+      }
+      case 'list': {
+        this._sendResponse(conn.socket, msg.id, { instances: this.list() });
+        break;
+      }
+      case 'ping': {
+        this._sendResponse(conn.socket, msg.id, 'pong');
+        break;
+      }
+      default:
+        this._sendError(conn.socket, msg.id, `unknown type: ${msg.type}`);
+    }
+  }
+
+  async _handleCall(conn, msg) {
+    const { instance: name, function: funcName, args } = msg;
+    const inst = this._instances.get(name);
+    if (!inst) {
+      this._sendError(conn.socket, msg.id, `instance '${name}' not found`);
+      return;
+    }
+    if (!inst.hasExport(funcName)) {
+      this._sendError(conn.socket, msg.id, `function '${funcName}' not found on '${name}'`);
+      return;
+    }
+    try {
+      const convertedArgs = (args || []).map(a => {
+        if (typeof a === 'number') return a;
+        if (typeof a === 'bigint') return a;
+        return a;
+      });
+      const result = await inst.call(funcName, ...convertedArgs);
+      this._sendResponse(conn.socket, msg.id, { result });
+    } catch (err) {
+      this._sendError(conn.socket, msg.id, err.message);
+    }
+  }
+
+  _sendResponse(socket, id, data) {
+    const msg = { id, type: 'response' };
+    if (data !== null && data !== undefined && typeof data === 'object' && !Array.isArray(data)) {
+      Object.assign(msg, data);
+    } else {
+      msg.result = data;
+    }
+    socket.write(pack(msg));
+  }
+
+  _sendError(socket, id, message) {
+    socket.write(pack({ id, type: 'error', error: message }));
+  }
+}
+
+class WasmClient {
+  constructor(options = {}) {
+    this.host = options.host || '127.0.0.1';
+    this.port = options.port;
+    this.authToken = options.authToken || null;
+    this.autoReconnect = options.autoReconnect !== false;
+    this.reconnectDelay = options.reconnectDelay || 1000;
+    this._socket = null;
+    this._buffer = Buffer.alloc(0);
+    this._pending = new Map();
+    this._nextId = 1;
+    this._connected = false;
+    this._reconnectTimer = null;
+    this._closed = false;
+    this._connectPromise = null;
+  }
+
+  async connect() {
+    if (this._connected) return;
+    if (this._connectPromise) return this._connectPromise;
+
+    this._connectPromise = new Promise((resolve, reject) => {
+      const socket = new net.Socket();
+      socket.connect(this.port, this.host, async () => {
+        this._socket = socket;
+        this._connected = true;
+        this._onConnected();
+        if (this.authToken) {
+          await this._send({ type: 'auth', token: this.authToken });
+        }
+        this._connectPromise = null;
+        resolve();
+      });
+      socket.on('data', (data) => this._onData(data));
+      socket.on('close', () => this._onDisconnect());
+      socket.on('error', (err) => {
+        this._connectPromise = null;
+        reject(err);
+      });
+    });
+
+    return this._connectPromise;
+  }
+
+  _onConnected() {
+    this._socket.on('data', (data) => this._onData(data));
+    this._socket.on('close', () => this._onDisconnect());
+    this._socket.on('error', () => {});
+  }
+
+  _onData(data) {
+    this._buffer = Buffer.concat([this._buffer, data]);
+    while (true) {
+      const nlIdx = this._buffer.indexOf(0x0a);
+      if (nlIdx === -1) break;
+      const line = this._buffer.slice(0, nlIdx);
+      this._buffer = this._buffer.slice(nlIdx + 1);
+      if (line.length === 0) continue;
+      try {
+        const msg = JSON.parse(line.toString('utf8'));
+        this._handleResponse(msg);
+      } catch {}
+    }
+  }
+
+  _handleResponse(msg) {
+    const pending = this._pending.get(msg.id);
+    if (!pending) return;
+    this._pending.delete(msg.id);
+    if (msg.type === 'error') {
+      pending.reject(new Error(msg.error));
+      return;
+    }
+    if (msg.result !== undefined) {
+      pending.resolve(msg.result);
+      return;
+    }
+    const { id, type, ...rest } = msg;
+    pending.resolve(Object.keys(rest).length === 1 ? Object.values(rest)[0] : rest);
+  }
+
+  _onDisconnect() {
+    this._connected = false;
+    this._socket = null;
+
+    for (const [, pending] of this._pending) {
+      pending.reject(new Error('connection closed'));
+    }
+    this._pending.clear();
+
+    if (this.autoReconnect && !this._closed) {
+      this._reconnectTimer = setTimeout(() => this.connect(), this.reconnectDelay);
+    }
+  }
+
+  async close() {
+    this._closed = true;
+    if (this._reconnectTimer) clearTimeout(this._reconnectTimer);
+    if (this._socket) {
+      this._socket.destroy();
+      this._socket = null;
+    }
+    this._connected = false;
+  }
+
+  async _send(msg) {
+    if (!this._connected) await this.connect();
+    return new Promise((resolve, reject) => {
+      const id = this._nextId++;
+      msg.id = id;
+      this._pending.set(id, { resolve, reject });
+      try {
+        this._socket.write(pack(msg));
+      } catch (err) {
+        this._pending.delete(id);
+        reject(err);
+      }
+    });
+  }
+
+  async call(instance, func, args = []) {
+    const response = await this._send({ type: 'call', instance, function: func, args });
+    return response;
+  }
+
+  async list() {
+    const response = await this._send({ type: 'list' });
+    return Array.isArray(response) ? response : (response.instances || []);
+  }
+
+  async ping() {
+    const response = await this._send({ type: 'ping' });
+    return response === 'pong';
+  }
+}
+
+class WasmCluster {
+  constructor(options = {}) {
+    this.workers = options.workers || [];
+    this.strategy = options.strategy || 'round-robin';
+    this._clients = this.workers.map(w => {
+      const c = new WasmClient({ host: w.host, port: w.port, autoReconnect: true });
+      return { client: c, weight: w.weight || 1 };
+    });
+    this._rrIndex = 0;
+    this._connected = false;
+  }
+
+  async connect() {
+    const results = await Promise.allSettled(
+      this._clients.map(c => c.client.connect())
+    );
+    this._connected = results.some(r => r.status === 'fulfilled');
+  }
+
+  _nextClient() {
+    const available = this._clients.filter(c => c.client._connected);
+    if (available.length === 0) throw new Error('no connected workers');
+
+    switch (this.strategy) {
+      case 'round-robin': {
+        const idx = this._rrIndex % available.length;
+        this._rrIndex++;
+        return available[idx];
+      }
+      case 'first': return available[0];
+      case 'random': return available[Math.floor(Math.random() * available.length)];
+      default: return available[0];
+    }
+  }
+
+  async call(instance, func, args = []) {
+    const entry = this._nextClient();
+    return entry.client.call(instance, func, args);
+  }
+
+  async list() {
+    const results = {};
+    for (const entry of this._clients) {
+      try {
+        const instances = await entry.client.list();
+        results[`${entry.client.host}:${entry.client.port}`] = instances;
+      } catch {}
+    }
+    return results;
+  }
+
+  async close() {
+    for (const entry of this._clients) {
+      await entry.client.close();
+    }
+    this._connected = false;
+  }
+}
+
+module.exports = { WasmWorker, WasmClient, WasmCluster };

package/src/index.js

@@ -3,6 +3,9 @@ const { MemoryView } = require('./memory.js');
 const { HostRegistry } = require('./host.js');
 const { ResourceLimits } = require('./limits.js');
 const { WasiContext } = require('./wasi.js');
+const { WasmPool, InstanceLease } = require('./pool.js');
+const { HotReload } = require('./watcher.js');
+const { WasmWorker, WasmClient, WasmCluster } = require('./cluster.js');
 const loader = require('./loader.js');
 
 function createRuntime(options = {}) {
@@ -24,5 +27,11 @@ module.exports = {
   HostRegistry,
   ResourceLimits,
   WasiContext,
+  WasmPool,
+  InstanceLease,
+  HotReload,
+  WasmWorker,
+  WasmClient,
+  WasmCluster,
   loader,
 };

package/src/pool.js

@@ -0,0 +1,204 @@
+const crypto = require('crypto');
+
+class InstanceLease {
+  constructor(pool, instance) {
+    this.pool = pool;
+    this.instance = instance;
+    this._released = false;
+    this.id = crypto.randomUUID();
+  }
+
+  release() {
+    if (this._released) return false;
+    this._released = true;
+    this.pool._release(this);
+    return true;
+  }
+
+  async call(name, ...args) {
+    return this.instance.call(name, ...args);
+  }
+}
+
+class WasmPool {
+  constructor(runtime, options = {}) {
+    this.runtime = runtime;
+    this.source = options.source || null;
+    this.sourceOptions = options.sourceOptions || {};
+    this.maxSize = options.maxSize || 10;
+    this.minSize = options.minSize || 0;
+    this.acquireTimeout = options.acquireTimeout || 0;
+    this.idleTimeout = options.idleTimeout || 60000;
+    this._idle = [];
+    this._busy = new Map();
+    this._pending = [];
+    this._closed = false;
+    this._warmPromise = null;
+    this._reaperTimer = null;
+    this._instanceIdCounter = 0;
+    this._creating = 0;
+
+    if (this.idleTimeout > 0) {
+      this._startReaper();
+    }
+  }
+
+  _startReaper() {
+    this._reaperTimer = setInterval(() => {
+      this._reapIdle();
+    }, Math.min(this.idleTimeout, 30000));
+    if (this._reaperTimer.unref) this._reaperTimer.unref();
+  }
+
+  async warm() {
+    if (this._warmPromise) return this._warmPromise;
+    this._warmPromise = this._warmInternal();
+    return this._warmPromise;
+  }
+
+  async _warmInternal() {
+    const target = this.minSize;
+    const toCreate = Math.max(0, target - this._countTotal());
+    const tasks = [];
+    for (let i = 0; i < toCreate; i++) {
+      tasks.push(this._createInstance());
+    }
+    const instances = await Promise.all(tasks);
+    for (const inst of instances) {
+      this._idle.push(inst);
+    }
+  }
+
+  async _createInstance() {
+    const id = ++this._instanceIdCounter;
+    const inst = await this.runtime.load(this.source, this.sourceOptions);
+    inst._poolId = id;
+    inst._createdAt = Date.now();
+    return inst;
+  }
+
+  _countTotal() {
+    return this._idle.length + this._busy.size;
+  }
+
+  async acquire() {
+    if (this._closed) throw new Error('Pool is closed');
+
+    if (this._idle.length > 0) {
+      const inst = this._idle.pop();
+      this._busy.set(inst._poolId, inst);
+      return new InstanceLease(this, inst);
+    }
+
+    if (this._countTotal() + this._creating >= this.maxSize) {
+      return this._enqueue();
+    }
+
+    this._creating++;
+    try {
+      const inst = await this._createInstance();
+      this._creating--;
+      this._busy.set(inst._poolId, inst);
+      return new InstanceLease(this, inst);
+    } catch (err) {
+      this._creating--;
+      throw err;
+    }
+  }
+
+  _enqueue() {
+    return new Promise((resolve, reject) => {
+      let timer = null;
+      const entry = { resolve, reject, timer: null };
+
+      if (this.acquireTimeout > 0) {
+        timer = setTimeout(() => {
+          const idx = this._pending.indexOf(entry);
+          if (idx !== -1) this._pending.splice(idx, 1);
+          reject(new Error(`Acquire timed out after ${this.acquireTimeout}ms`));
+        }, this.acquireTimeout);
+        entry.timer = timer;
+      }
+
+      this._pending.push(entry);
+    });
+  }
+
+  _release(lease) {
+    const inst = lease.instance;
+    this._busy.delete(inst._poolId);
+
+    if (this._closed) return;
+
+    if (this._pending.length > 0) {
+      this._busy.set(inst._poolId, inst);
+      const entry = this._pending.shift();
+      if (entry.timer) clearTimeout(entry.timer);
+      entry.resolve(new InstanceLease(this, inst));
+      return;
+    }
+
+    inst._lastUsedAt = Date.now();
+    this._idle.push(inst);
+  }
+
+  async exec(fn) {
+    const lease = await this.acquire();
+    try {
+      return await fn(lease.instance, lease);
+    } finally {
+      lease.release();
+    }
+  }
+
+  async drain() {
+    this._closed = true;
+
+    for (const entry of this._pending) {
+      if (entry.timer) clearTimeout(entry.timer);
+      entry.reject(new Error('Pool is draining'));
+    }
+    this._pending = [];
+
+    const all = [...this._idle, ...Array.from(this._busy.values())];
+    this._idle = [];
+    this._busy.clear();
+
+    if (this._reaperTimer) {
+      clearInterval(this._reaperTimer);
+      this._reaperTimer = null;
+    }
+  }
+
+  _reapIdle() {
+    if (this._idle.length === 0) return;
+    const now = Date.now();
+    const keep = Math.max(0, this.minSize);
+    const reapable = this._idle
+      .filter(i => now - (i._lastUsedAt || i._createdAt) > this.idleTimeout)
+      .sort((a, b) => (a._lastUsedAt || a._createdAt) - (b._lastUsedAt || b._createdAt));
+
+    const toRemove = Math.max(0, reapable.length - keep);
+    const removeSet = new Set(reapable.slice(0, toRemove).map(i => i._poolId));
+    this._idle = this._idle.filter(i => {
+      if (removeSet.has(i._poolId)) {
+        this.runtime.removeInstance(i);
+        return false;
+      }
+      return true;
+    });
+  }
+
+  stats() {
+    return {
+      idle: this._idle.length,
+      busy: this._busy.size,
+      pending: this._pending.length,
+      total: this._countTotal(),
+      maxSize: this.maxSize,
+      minSize: this.minSize,
+    };
+  }
+}
+
+module.exports = { WasmPool, InstanceLease };

package/src/runtime.js

@@ -1,6 +1,9 @@
 const { MemoryView } = require('./memory.js');
 const { HostRegistry } = require('./host.js');
 const { ResourceLimits } = require('./limits.js');
+const { WasmPool } = require('./pool.js');
+const { HotReload } = require('./watcher.js');
+const { WasmWorker, WasmClient, WasmCluster } = require('./cluster.js');
 const loader = require('./loader.js');
 
 class WasmInstance {
@@ -135,6 +138,30 @@ class WasmRuntime {
     this.instances = [];
   }
 
+  createPool(options = {}) {
+    if (!options.source && !options.sourceOptions) {
+      options.sourceOptions = { ...this.options };
+    }
+    return new WasmPool(this, options);
+  }
+
+  watch(source, options = {}) {
+    const hr = new HotReload(this, source, options);
+    return hr;
+  }
+
+  createWorker(options = {}) {
+    return new WasmWorker(this, options);
+  }
+
+  createClient(options = {}) {
+    return new WasmClient(options);
+  }
+
+  createCluster(options = {}) {
+    return new WasmCluster(options);
+  }
+
   getStats() {
     return {
       instances: this.instances.length,

package/src/watcher.js

@@ -0,0 +1,128 @@
+const fs = require('fs');
+const path = require('path');
+const EventEmitter = require('events');
+
+class HotReload extends EventEmitter {
+  constructor(runtime, source, options = {}) {
+    super();
+    this.runtime = runtime;
+    this.source = path.resolve(source);
+    this.options = options;
+    this.pollInterval = options.pollInterval || 1000;
+    this._currentModule = null;
+    this._currentInstance = null;
+    this._watcher = null;
+    this._pollTimer = null;
+    this._active = false;
+    this._reloading = false;
+  }
+
+  async start() {
+    if (this._active) return;
+    this._active = true;
+
+    const mode = this.options.mode || 'poll';
+
+    if (mode === 'watch') {
+      this._startWatcher();
+    } else {
+      this._startPolling();
+    }
+
+    await this._loadModule();
+  }
+
+  _startWatcher() {
+    try {
+      this._watcher = fs.watch(this.source, (eventType) => {
+        if (eventType === 'change') {
+          this._scheduleReload();
+        }
+      });
+    } catch {
+      this._startPolling();
+    }
+  }
+
+  _startPolling() {
+    this._lastMtime = this._getMtime();
+    this._pollTimer = setInterval(() => {
+      const mtime = this._getMtime();
+      if (mtime && mtime !== this._lastMtime) {
+        this._lastMtime = mtime;
+        this._scheduleReload();
+      }
+    }, this.pollInterval);
+    if (this._pollTimer.unref) this._pollTimer.unref();
+  }
+
+  _getMtime() {
+    try {
+      return fs.statSync(this.source).mtimeMs;
+    } catch {
+      return null;
+    }
+  }
+
+  _scheduleReload() {
+    if (this._reloading) return;
+    this._reloading = true;
+
+    const debounceMs = this.options.debounce || 200;
+    if (this._reloadTimer) clearTimeout(this._reloadTimer);
+
+    this._reloadTimer = setTimeout(async () => {
+      try {
+        await this._loadModule();
+        this.emit('reload', this._currentInstance);
+      } catch (err) {
+        this.emit('error', err);
+      } finally {
+        this._reloading = false;
+      }
+    }, debounceMs);
+  }
+
+  async _loadModule() {
+    const oldInstance = this._currentInstance;
+    const newInstance = await this.runtime.load(this.source, this.options.sourceOptions);
+
+    this._currentInstance = newInstance;
+    this._currentModule = true;
+    this.emit('load', newInstance);
+
+    if (oldInstance) {
+      this.runtime.removeInstance(oldInstance);
+    }
+  }
+
+  getInstance() {
+    return this._currentInstance;
+  }
+
+  async call(name, ...args) {
+    if (!this._currentInstance) {
+      throw new Error('Module not loaded yet');
+    }
+    return this._currentInstance.call(name, ...args);
+  }
+
+  close() {
+    this._active = false;
+    if (this._watcher) {
+      this._watcher.close();
+      this._watcher = null;
+    }
+    if (this._pollTimer) {
+      clearInterval(this._pollTimer);
+      this._pollTimer = null;
+    }
+    if (this._reloadTimer) {
+      clearTimeout(this._reloadTimer);
+      this._reloadTimer = null;
+    }
+    this.removeAllListeners();
+  }
+}
+
+module.exports = { HotReload };