bring in sendosc and convert to npm workspaces

2026-08-19 14:04:01 +00:00 · 2024-10-09 17:28:49 -05:00
parent efce70806f
commit 7b681be033
26 changed files with 3572 additions and 162 deletions
@@ -0,0 +1 @@
+dist
@@ -0,0 +1,44 @@
+![npm](https://img.shields.io/npm/v/sendosc)
+
+# sendosc
+
+Simple NodeJS script for sending OSC via TCP or UDP originally inspired by this [c++ utility](https://github.com/yoggy/sendosc) of the same name.
+
+## Usage
+
+```
+Usage: sendosc [options]
+
+simple util to sendosc
+
+Options:
+  -V, --version          output the version number
+  --protocol <protocol>  Network protocol (choices: "tcp", "udp", default: "udp")
+  --host <host>          the host to send osc to
+  --port <port>          the port to send osc to
+  --address <address>    OSC address
+  --args <args...>       osc args (default: [])
+  --slip                 slip encode message (default: false)
+  --types <types...>     osc arg types (choices: "s", "i", "f", "b", default: [])
+  -h, --help             display help for command
+```
+
+- using npx `npx sendosc@latest --host 127.0.0.1 --port 9999 --address /hello`
+- install using `npm install -g sendosc@latest` and run `sendosc --host 127.0.0.1 --port 9999 --address /hello`
+
+## Notes
+
+- `--types` option is a space seperate list of type characters that will determine what the corresponding argument type will be set to
+  - optional
+  - uses type codes from the OSC spec
+- `--args` option is a space-separated list of arguments. If a corresponding type is not found in the `--types` option it will default to string (`s`).
+  - blobs (`b`) are to be entered as hex string representing the buffer to be sent so the ASCII string `hello` would be `68656c6c6f`
+- the default protocol is UDP but can be changed to TCP using the `--protocol` flag
+
+## Examples
+
+- `sendosc --host 127.0.0.1 --port 8000 --address /test --args 1.0`
+- `sendosc --protocol tcp --host 127.0.0.1 --port 8000 --address /this/is/sent/via/tcp`
+- `sendosc --host 127.0.0.1 --port 8000 --address /test/with/types --args 1 2.0 three --types i f`
+  - note that `types` is not the same length as `args` so the remaining argument (`three`) will default to string
+- `sendosc --host 127.0.0.1 --port 8000 --address /blob --args 68656c6c6f --types b`
@@ -0,0 +1,27 @@
+{
+  "name": "sendosc",
+  "version": "1.0.1",
+  "description": "Simple NodeJS utility for sending osc",
+  "main": "dist/main.js",
+  "bin": "dist/main.js",
+  "scripts": {
+    "prebuild": "rimraf dist",
+    "build": "esbuild src/main.js --bundle --platform=node --outfile=dist/main.js",
+    "prepack": "npm run build"
+  },
+  "author": {
+    "name": "Joel Wetzell",
+    "email": "me@jwetzell.com",
+    "url": "https://jwetzell.com"
+  },
+  "repository": "https://github.com/jwetzell/osc-js",
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^11.0.0",
+    "slip": "^1.0.2"
+  },
+  "devDependencies": {
+    "esbuild": "0.24.0",
+    "rimraf": "6.0.1"
+  }
+}
@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+const { Option, program } = require('commander');
+const dgram = require('dgram');
+const net = require('net');
+const slip = require('slip');
+const osc = require('./osc');
+const packageInfo = require('../package.json');
+
+program.name(packageInfo.name);
+program.version(packageInfo.version);
+program.description('simple util to sendosc');
+program.addOption(new Option('--protocol <protocol>', 'Network protocol').choices(['tcp', 'udp']).default('udp'));
+program.addOption(new Option('--host <host>', 'the host to send osc to').makeOptionMandatory());
+program.addOption(new Option('--port <port>', 'the port to send osc to').makeOptionMandatory());
+program.addOption(new Option('--address <address>', 'OSC address').makeOptionMandatory());
+program.addOption(new Option('--args <args...>', 'osc args').default([]));
+program.addOption(new Option('--slip', 'slip encode message').default(false));
+program.addOption(new Option('--types <types...>', 'osc arg types').choices(['s', 'i', 'f', 'b']).default([]));
+program.action((options) => {
+  const { host, port, address, args, types } = options;
+
+  const typedArgs = args?.map((rawArg, index) => {
+    const argType = types[index] || 's';
+
+    return {
+      type: argType,
+      value: osc.argToTypedArg(rawArg, argType),
+    };
+  });
+
+  let oscMsgBuffer = osc.toBuffer({
+    address,
+    args: typedArgs,
+  });
+
+  if (options.slip) {
+    oscMsgBuffer = slip.encode(oscMsgBuffer);
+  }
+
+  if (options.protocol === 'tcp') {
+    const client = net.Socket();
+    client.on('error', (error) => {
+      console.error(error);
+    });
+    client.connect(port, host, () => {
+      client.write(oscMsgBuffer, () => {
+        client.destroy();
+      });
+    });
+  } else if (options.protocol === 'udp') {
+    const client = dgram.createSocket('udp4');
+    client.send(oscMsgBuffer, port, host, (error) => {
+      if (error) {
+        console.error(error);
+      }
+      client.close();
+    });
+  }
+});
+program.parse();
@@ -0,0 +1,83 @@
+const oscTypeConverterMap = {
+  s: {
+    toBuffer: (string) => {
+      let oscString = `${string}\u0000`;
+      const padSize = 4 - (oscString.length % 4);
+      if (padSize < 4) {
+        oscString = oscString.padEnd(oscString.length + padSize, '\u0000');
+      }
+      return Buffer.from(oscString, 'ascii');
+    },
+    fromString: (string) => string,
+  },
+  f: {
+    toBuffer: (number) => {
+      const buffer = Buffer.alloc(4);
+      buffer.writeFloatBE(number);
+      return buffer;
+    },
+    fromString: (string) => Number.parseFloat(string),
+  },
+  i: {
+    toBuffer: (number) => {
+      const buffer = Buffer.alloc(4);
+      buffer.writeInt32BE(number);
+      return buffer;
+    },
+    fromString: (string) => Number.parseInt(string, 10),
+  },
+  b: {
+    toBuffer: (data) => {
+      const sizeBuffer = oscTypeConverterMap.i.toBuffer(data.length);
+      const padSize = 4 - (data.length % 4);
+      const padBuffer = Buffer.from(Array(padSize).fill(0));
+      return Buffer.concat([sizeBuffer, data, padBuffer]);
+    },
+    fromString: (string) => Buffer.from(string, 'hex'),
+  },
+};
+
+function argsToBuffer(args) {
+  const argBuffers = [];
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    const typeConverter = oscTypeConverterMap[arg.type];
+    if (typeConverter === undefined) {
+      throw new Error('osc type error: unknown type '.concat(arg.type));
+    }
+
+    if (typeConverter.fromString === undefined) {
+      throw new Error('osc type error: no string converter for type '.concat(arg.type));
+    }
+
+    argBuffers.push(typeConverter.toBuffer(arg.value));
+  }
+  return Buffer.concat(argBuffers);
+}
+
+function toBuffer({ address, args }) {
+  const addressBuffer = oscTypeConverterMap.s.toBuffer(address);
+  const typeString = args.map((arg) => arg.type).join('');
+  const typesBuffer = oscTypeConverterMap.s.toBuffer(`,${typeString}`);
+  const argsBuffer = argsToBuffer(args);
+  return Buffer.concat([addressBuffer, typesBuffer, argsBuffer]);
+}
+
+function argToTypedArg(rawArg, type = 's') {
+  const typeConverter = oscTypeConverterMap[type];
+  if (typeConverter === undefined) {
+    throw new Error('osc type error: unknown type '.concat(type));
+  }
+
+  if (typeConverter.fromString === undefined) {
+    throw new Error('osc type error: no string converter for type '.concat(type));
+  }
+
+  return typeConverter.fromString(rawArg);
+}
+
+module.exports = {
+  toBuffer,
+  argToTypedArg,
+};