@vdoninja/mcp 0.4.0

package/scripts/lib/bridge-utils.js

@@ -0,0 +1,185 @@
+'use strict';
+
+const crypto = require('node:crypto');
+
+function nowISO() {
+  return new Date().toISOString();
+}
+
+function boolFromEnv(value, fallback) {
+  if (value === undefined) return fallback;
+  const normalized = String(value).trim().toLowerCase();
+  if (['1', 'true', 'yes', 'y', 'on'].includes(normalized)) return true;
+  if (['0', 'false', 'no', 'n', 'off'].includes(normalized)) return false;
+  return fallback;
+}
+
+function intFromEnv(value, fallback) {
+  if (value === undefined || value === null) return fallback;
+  const parsed = Number.parseInt(String(value), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function intFromValue(value, fallback) {
+  if (value === undefined || value === null) return fallback;
+  const parsed = Number.parseInt(String(value), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function nonNegativeIntFromValue(value, fallback) {
+  if (value === undefined || value === null) return fallback;
+  const parsed = Number.parseInt(String(value), 10);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+}
+
+function clampInt(value, fallback, minValue, maxValue) {
+  const parsed = Number.parseInt(String(value), 10);
+  const safe = Number.isFinite(parsed) ? parsed : fallback;
+  const floor = Number.isFinite(minValue) ? minValue : safe;
+  const ceil = Number.isFinite(maxValue) ? maxValue : safe;
+  return Math.min(Math.max(safe, floor), ceil);
+}
+
+function sanitizeId(value, fallback) {
+  const source = String(value || fallback || '').trim();
+  const safe = source.replace(/\W+/g, '_').replace(/^_+|_+$/g, '');
+  return safe || fallback || null;
+}
+
+function parsePassword(raw) {
+  if (raw === undefined || raw === null) return undefined;
+  if (raw === false) return false;
+  if (raw === true) return undefined;
+  const text = String(raw).trim().toLowerCase();
+  if (text === 'false') return false;
+  if (text === 'true' || text === '') return undefined;
+  return raw;
+}
+
+function generateShortId(prefix) {
+  const rand = crypto.randomBytes(4).toString('hex');
+  return prefix ? `${prefix}_${rand}` : rand;
+}
+
+function randomUUID() {
+  if (typeof crypto.randomUUID === 'function') {
+    return crypto.randomUUID();
+  }
+  return [
+    crypto.randomBytes(4).toString('hex'),
+    crypto.randomBytes(2).toString('hex'),
+    '4' + crypto.randomBytes(2).toString('hex').slice(1),
+    ((8 + Math.floor(Math.random() * 4)).toString(16) + crypto.randomBytes(2).toString('hex').slice(1)),
+    crypto.randomBytes(6).toString('hex')
+  ].join('-');
+}
+
+function sha256Hex(data) {
+  const hash = crypto.createHash('sha256');
+  hash.update(data);
+  return hash.digest('hex');
+}
+
+function hmacSha256Hex(secret, data) {
+  return crypto.createHmac('sha256', secret).update(data).digest('hex');
+}
+
+function base64UrlEncode(bufferOrText) {
+  const buf = Buffer.isBuffer(bufferOrText) ? bufferOrText : Buffer.from(String(bufferOrText), 'utf8');
+  return buf
+    .toString('base64')
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=+$/g, '');
+}
+
+function base64UrlDecode(text) {
+  if (!text || typeof text !== 'string') {
+    throw new Error('base64url input must be a non-empty string');
+  }
+  const normalized = text.replace(/-/g, '+').replace(/_/g, '/');
+  const padLen = (4 - (normalized.length % 4)) % 4;
+  return Buffer.from(normalized + '='.repeat(padLen), 'base64');
+}
+
+function createJoinToken(payload, secret) {
+  if (!secret) throw new Error('secret is required');
+  if (!payload || typeof payload !== 'object') throw new Error('payload must be an object');
+  const body = base64UrlEncode(JSON.stringify(payload));
+  const sig = base64UrlEncode(crypto.createHmac('sha256', secret).update(body).digest());
+  return `${body}.${sig}`;
+}
+
+function verifyJoinToken(token, secret) {
+  if (!secret) throw new Error('secret is required');
+  if (!token || typeof token !== 'string') {
+    return { ok: false, error: 'token must be a non-empty string' };
+  }
+  const parts = token.split('.');
+  if (parts.length !== 2) {
+    return { ok: false, error: 'invalid token format' };
+  }
+
+  const [body, sig] = parts;
+  const expectedSig = base64UrlEncode(crypto.createHmac('sha256', secret).update(body).digest());
+  if (sig !== expectedSig) {
+    return { ok: false, error: 'invalid token signature' };
+  }
+
+  let payload;
+  try {
+    payload = JSON.parse(base64UrlDecode(body).toString('utf8'));
+  } catch (error) {
+    return { ok: false, error: `invalid token payload: ${error.message}` };
+  }
+
+  return {
+    ok: true,
+    payload
+  };
+}
+
+function ensureStringArray(value) {
+  if (value === undefined || value === null) return [];
+  if (Array.isArray(value)) {
+    return value
+      .map((item) => String(item || '').trim())
+      .filter((item) => item.length > 0);
+  }
+  if (typeof value === 'string') {
+    return value
+      .split(',')
+      .map((item) => item.trim())
+      .filter((item) => item.length > 0);
+  }
+  return [];
+}
+
+function safeJsonParse(value, fallback) {
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    return fallback;
+  }
+}
+
+module.exports = {
+  boolFromEnv,
+  intFromEnv,
+  intFromValue,
+  nonNegativeIntFromValue,
+  clampInt,
+  sanitizeId,
+  parsePassword,
+  nowISO,
+  generateShortId,
+  randomUUID,
+  sha256Hex,
+  hmacSha256Hex,
+  base64UrlEncode,
+  base64UrlDecode,
+  createJoinToken,
+  verifyJoinToken,
+  ensureStringArray,
+  safeJsonParse
+};

package/scripts/lib/fake-network-sdk.js

@@ -0,0 +1,293 @@
+'use strict';
+
+const { randomUUID } = require('./bridge-utils');
+
+function clonePayload(data) {
+  if (data === null || data === undefined) return data;
+  if (Buffer.isBuffer(data)) return Buffer.from(data);
+  if (data instanceof ArrayBuffer) return Buffer.from(data);
+  if (typeof data === 'object') {
+    try {
+      return JSON.parse(JSON.stringify(data));
+    } catch (error) {
+      return data;
+    }
+  }
+  return data;
+}
+
+class FakeNetworkBus {
+  constructor(options = {}) {
+    this.rooms = new Map();
+    this.options = options || {};
+    this.messageCounter = 0;
+  }
+
+  getRoom(name) {
+    if (!this.rooms.has(name)) {
+      this.rooms.set(name, {
+        members: new Set(),
+        publishers: new Map()
+      });
+    }
+    return this.rooms.get(name);
+  }
+
+  join(sdk, roomName) {
+    const room = this.getRoom(roomName);
+    room.members.add(sdk);
+  }
+
+  announce(sdk) {
+    const room = this.getRoom(sdk.room);
+    room.publishers.set(sdk.streamID, sdk);
+  }
+
+  connectViewer(viewer, targetStreamID) {
+    const room = this.getRoom(viewer.room);
+    const publisher = room.publishers.get(targetStreamID);
+    if (!publisher) {
+      throw new Error(`target stream not found: ${targetStreamID}`);
+    }
+    this.connectPeers(viewer, publisher);
+  }
+
+  connectPeers(a, b) {
+    if (a.peers.has(b)) return;
+    a.peers.add(b);
+    b.peers.add(a);
+
+    a.emit('peerConnected', {
+      uuid: b.uuid,
+      streamID: b.streamID || null,
+      connection: { type: 'viewer' }
+    });
+    b.emit('peerConnected', {
+      uuid: a.uuid,
+      streamID: a.streamID || null,
+      connection: { type: 'publisher' }
+    });
+
+    a.emit('dataChannelOpen', { uuid: b.uuid, streamID: b.streamID || null });
+    b.emit('dataChannelOpen', { uuid: a.uuid, streamID: a.streamID || null });
+  }
+
+  resolveRecipients(sender, target) {
+    const peers = Array.from(sender.peers);
+    if (!target) return peers;
+
+    if (typeof target === 'string') {
+      return peers.filter((peer) => peer.uuid === target || (peer.streamID && peer.streamID === target));
+    }
+
+    if (typeof target === 'object' && target.uuid) {
+      return peers.filter((peer) => peer.uuid === target.uuid);
+    }
+
+    return peers;
+  }
+
+  resolveDeliveryDecision(context) {
+    const opts = this.options || {};
+    const decision = {
+      drop: false,
+      duplicate: false,
+      delayMs: intOrZero(opts.fixedDelayMs),
+      data: context.data
+    };
+
+    if (opts.dropEveryNth && opts.dropEveryNth > 0 && (context.messageIndex % opts.dropEveryNth === 0)) {
+      decision.drop = true;
+    }
+
+    if (opts.duplicateEveryNth && opts.duplicateEveryNth > 0 && (context.messageIndex % opts.duplicateEveryNth === 0)) {
+      decision.duplicate = true;
+    }
+
+    if (typeof opts.transformMessage === 'function') {
+      const transformed = opts.transformMessage({
+        senderUuid: context.sender.uuid,
+        senderStreamID: context.sender.streamID || null,
+        receiverUuid: context.receiver.uuid,
+        receiverStreamID: context.receiver.streamID || null,
+        data: clonePayload(context.data),
+        target: context.target,
+        messageIndex: context.messageIndex
+      });
+
+      if (transformed && typeof transformed === 'object') {
+        if (typeof transformed.drop === 'boolean') decision.drop = transformed.drop;
+        if (typeof transformed.duplicate === 'boolean') decision.duplicate = transformed.duplicate;
+        if (Number.isFinite(transformed.delayMs) && transformed.delayMs >= 0) {
+          decision.delayMs = transformed.delayMs;
+        }
+        if (Object.prototype.hasOwnProperty.call(transformed, 'data')) {
+          decision.data = transformed.data;
+        }
+      }
+    }
+
+    return decision;
+  }
+
+  deliverToPeer(sender, receiver, data, target) {
+    this.messageCounter += 1;
+    const context = {
+      sender,
+      receiver,
+      data,
+      target,
+      messageIndex: this.messageCounter
+    };
+
+    const decision = this.resolveDeliveryDecision(context);
+    if (decision.drop) {
+      return;
+    }
+
+    const emitPayload = () => {
+      receiver.emit('dataReceived', {
+        data: clonePayload(decision.data),
+        uuid: sender.uuid,
+        streamID: sender.streamID,
+        fallback: false
+      });
+    };
+
+    const delayMs = intOrZero(decision.delayMs);
+    if (delayMs > 0) {
+      setTimeout(emitPayload, delayMs);
+    } else {
+      emitPayload();
+    }
+
+    if (decision.duplicate) {
+      setTimeout(emitPayload, Math.max(1, delayMs + 1));
+    }
+  }
+
+  disconnect(sdk) {
+    if (sdk.room) {
+      const room = this.getRoom(sdk.room);
+      room.members.delete(sdk);
+      if (sdk.streamID && room.publishers.get(sdk.streamID) === sdk) {
+        room.publishers.delete(sdk.streamID);
+      }
+    }
+
+    for (const peer of Array.from(sdk.peers)) {
+      peer.peers.delete(sdk);
+      peer.emit('peerDisconnected', { uuid: sdk.uuid, streamID: sdk.streamID || null });
+    }
+    sdk.peers.clear();
+  }
+}
+
+class FakeVDONinjaSDK {
+  constructor(config, bus) {
+    this.config = config || {};
+    this.bus = bus;
+    this.uuid = randomUUID();
+    this.room = null;
+    this.streamID = null;
+    this.listeners = new Map();
+    this.connected = false;
+    this.peers = new Set();
+  }
+
+  addEventListener(eventName, handler) {
+    if (!this.listeners.has(eventName)) {
+      this.listeners.set(eventName, new Set());
+    }
+    this.listeners.get(eventName).add(handler);
+  }
+
+  removeEventListener(eventName, handler) {
+    if (!this.listeners.has(eventName)) return;
+    this.listeners.get(eventName).delete(handler);
+  }
+
+  emit(eventName, detail) {
+    const handlers = this.listeners.get(eventName);
+    if (!handlers) return;
+    const event = { detail: detail || null };
+    for (const handler of handlers) {
+      try {
+        handler(event);
+      } catch (error) {
+        // Ignore handler errors in fake mode.
+      }
+    }
+  }
+
+  async connect() {
+    this.connected = true;
+    this.emit('connected', {});
+  }
+
+  async joinRoom(options) {
+    this.room = options && options.room ? options.room : this.config.room;
+    if (!this.room) {
+      throw new Error('room is required');
+    }
+    this.bus.join(this, this.room);
+  }
+
+  async announce(options) {
+    if (!this.room) {
+      throw new Error('joinRoom required before announce');
+    }
+    this.streamID = options && options.streamID ? options.streamID : null;
+    if (!this.streamID) {
+      throw new Error('streamID is required');
+    }
+    this.bus.announce(this);
+  }
+
+  async view(targetStreamID) {
+    if (!this.room) {
+      throw new Error('joinRoom required before view');
+    }
+    this.bus.connectViewer(this, targetStreamID);
+  }
+
+  sendData(data, target) {
+    const recipients = this.bus.resolveRecipients(this, target);
+    if (!recipients.length) return false;
+
+    for (const peer of recipients) {
+      this.bus.deliverToPeer(this, peer, data, target);
+    }
+    return true;
+  }
+
+  sendPing() {
+    return true;
+  }
+
+  disconnect() {
+    this.bus.disconnect(this);
+    if (this.connected) {
+      this.connected = false;
+      this.emit('disconnected', {});
+    }
+  }
+}
+
+function intOrZero(value) {
+  const parsed = Number.parseInt(String(value), 10);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
+}
+
+function createFakeSDKFactory(options = {}) {
+  const bus = new FakeNetworkBus(options);
+  const factory = function sdkFactory(config) {
+    return new FakeVDONinjaSDK(config, bus);
+  };
+  factory.bus = bus;
+  return factory;
+}
+
+module.exports = {
+  createFakeSDKFactory
+};

package/scripts/lib/load-vdo-sdk.js

@@ -0,0 +1,36 @@
+'use strict';
+
+function loadVDONinjaSDK() {
+  const candidates = [
+    '@vdoninja/sdk/node',
+    '@vdoninja/sdk',
+    '../../../vdoninja-sdk-node.js'
+  ];
+
+  let lastError = null;
+  for (const candidate of candidates) {
+    try {
+      // eslint-disable-next-line global-require, import/no-dynamic-require
+      const resolved = require(candidate);
+      if (resolved) return resolved;
+    } catch (error) {
+      const isMissingModule = error &&
+        error.code === 'MODULE_NOT_FOUND' &&
+        typeof error.message === 'string' &&
+        error.message.includes(`Cannot find module '${candidate}'`);
+      if (!isMissingModule) {
+        throw error;
+      }
+      lastError = error;
+    }
+  }
+
+  const hint = lastError && lastError.message ? ` Last error: ${lastError.message}` : '';
+  throw new Error(
+    `Unable to load VDO.Ninja SDK. Tried: ${candidates.join(', ')}.${hint}`
+  );
+}
+
+module.exports = {
+  loadVDONinjaSDK
+};

package/scripts/lib/mcp-stdio-parser.js

@@ -0,0 +1,137 @@
+'use strict';
+
+const EventEmitter = require('node:events');
+
+class McpStdioParser extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.maxMessageBytes = Number.isFinite(options.maxMessageBytes) && options.maxMessageBytes > 0
+      ? options.maxMessageBytes
+      : 1024 * 1024;
+    this.buffer = Buffer.alloc(0);
+    this.mode = null;
+  }
+
+  push(chunk) {
+    if (!chunk || chunk.length === 0) return;
+    const incoming = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    this.buffer = Buffer.concat([this.buffer, incoming]);
+
+    while (this.buffer.length > 0) {
+      this.trimLeadingEmptyLines();
+      if (this.buffer.length === 0) return;
+
+      if (this.looksLikeFramedHeader()) {
+        if (!this.processFramedMessage()) return;
+      } else {
+        if (!this.processLineMessage()) return;
+      }
+    }
+  }
+
+  trimLeadingEmptyLines() {
+    while (this.buffer.length > 0) {
+      const first = this.buffer[0];
+      if (first === 0x0a || first === 0x0d) {
+        this.buffer = this.buffer.slice(1);
+        continue;
+      }
+      break;
+    }
+  }
+
+  looksLikeFramedHeader() {
+    const preview = this.buffer.slice(0, Math.min(this.buffer.length, 64)).toString('utf8');
+    return /^content-length\s*:/i.test(preview);
+  }
+
+  processFramedMessage() {
+    const markerCRLF = this.buffer.indexOf('\r\n\r\n');
+    const markerLF = this.buffer.indexOf('\n\n');
+    let markerIndex = -1;
+    let markerLength = 0;
+
+    if (markerCRLF >= 0 && (markerLF < 0 || markerCRLF < markerLF)) {
+      markerIndex = markerCRLF;
+      markerLength = 4;
+    } else if (markerLF >= 0) {
+      markerIndex = markerLF;
+      markerLength = 2;
+    }
+
+    if (markerIndex < 0) return false;
+
+    const header = this.buffer.slice(0, markerIndex).toString('utf8');
+    const match = header.match(/content-length\s*:\s*(\d+)/i);
+    if (!match) {
+      this.emit('error', { code: 'invalid_header', message: 'missing Content-Length header' });
+      this.buffer = this.buffer.slice(markerIndex + markerLength);
+      return true;
+    }
+
+    const byteLength = Number.parseInt(match[1], 10);
+    if (!Number.isFinite(byteLength) || byteLength < 0) {
+      this.emit('error', { code: 'invalid_header', message: 'invalid Content-Length value' });
+      this.buffer = this.buffer.slice(markerIndex + markerLength);
+      return true;
+    }
+
+    if (byteLength > this.maxMessageBytes) {
+      this.emit('error', { code: 'message_too_large', message: `message exceeds max size ${this.maxMessageBytes}` });
+      this.buffer = this.buffer.slice(markerIndex + markerLength);
+      return true;
+    }
+
+    const totalLength = markerIndex + markerLength + byteLength;
+    if (this.buffer.length < totalLength) return false;
+
+    const payload = this.buffer.slice(markerIndex + markerLength, totalLength).toString('utf8');
+    this.buffer = this.buffer.slice(totalLength);
+    this.mode = this.mode || 'framed';
+    this.emitParsed(payload, 'framed');
+    return true;
+  }
+
+  processLineMessage() {
+    const newlineIndex = this.buffer.indexOf(0x0a);
+    if (newlineIndex < 0) return false;
+
+    const line = this.buffer.slice(0, newlineIndex).toString('utf8').trim();
+    this.buffer = this.buffer.slice(newlineIndex + 1);
+    if (!line) return true;
+
+    if (Buffer.byteLength(line, 'utf8') > this.maxMessageBytes) {
+      this.emit('error', { code: 'message_too_large', message: `line exceeds max size ${this.maxMessageBytes}` });
+      return true;
+    }
+
+    this.mode = this.mode || 'line';
+    this.emitParsed(line, 'line');
+    return true;
+  }
+
+  emitParsed(raw, mode) {
+    try {
+      const message = JSON.parse(raw);
+      this.emit('message', { message, mode });
+    } catch (error) {
+      this.emit('error', { code: 'parse_error', message: error.message, raw });
+    }
+  }
+}
+
+function writeMcpMessage(output, payload, mode) {
+  const text = JSON.stringify(payload);
+  if (mode === 'framed') {
+    const body = Buffer.from(text, 'utf8');
+    output.write(`Content-Length: ${body.length}\r\n\r\n`);
+    output.write(body);
+    return;
+  }
+  output.write(`${text}\n`);
+}
+
+module.exports = {
+  McpStdioParser,
+  writeMcpMessage
+};