rclnodejs 1.9.0-alpha.0 → 2.0.0-beta.0

package/rosocket/README.md

@@ -0,0 +1,152 @@
+# rosocket — ROS 2 in the browser, no library required
+
+> A tiny WebSocket gateway to ROS 2 — built into `rclnodejs`.
+
+> **Availability:** experimental; currently only on the `develop` branch of
+> `rclnodejs` and not yet part of any published release. Install from GitHub
+> to try it (see the project's [Install from GitHub](../README.md#install-from-github) section):
+>
+> ```bash
+> npm install RobotWebTools/rclnodejs#develop
+> ```
+
+**rosocket** is a **lightweight** WebSocket bridge that lets a **plain web
+browser** (or any WebSocket-capable client) talk to ROS 2 through `rclnodejs`,
+with **no extra JavaScript library** required on the client side. Browsers
+only need the built-in `WebSocket` and `JSON` APIs.
+
+How it compares with the classic
+[rosbridge_suite](https://github.com/RobotWebTools/rosbridge_suite) +
+[roslibjs](https://github.com/RobotWebTools/roslibjs) stack:
+
+| | **rosocket (rclnodejs)** | **rosbridge_suite + roslibjs** |
+| --- | --- | --- |
+| Server process | same Node.js process as your `rclnodejs` app | separate Python ROS 2 node |
+| Client-side library | none — built-in `WebSocket` + `JSON` | `roslibjs` (must be bundled/loaded) |
+| Wire protocol | resource-style URLs (`/topic/<name>`, `/service/<name>`); frame = bare ROS message as JSON | custom JSON envelope (`op: "publish" / "subscribe" / "call_service"`, …) |
+| Type discovery | URL `?type=` query, or server-side default map | advertised at runtime via envelope ops |
+| Features | publish / subscribe, service client | pub/sub, services, **actions, tf, parameters, compression, PNG/CBOR, auth, …** |
+| Deployment | one `npm` dep, runs anywhere Node runs | extra ROS package; version must match ROS distro |
+
+## URL scheme
+
+The bridge is **resource-style** — the URL *is* the topic or service name and
+the WebSocket frame *is* the ROS message as JSON.
+
+| URL | Direction | Payload |
+| --- | --- | --- |
+| `ws://host:port/topic/<topic_name>?type=<pkg>/msg/<Type>` | server → client (subscribe) | one frame per received ROS message, JSON-serialized |
+| `ws://host:port/topic/<topic_name>?type=<pkg>/msg/<Type>` | client → server (publish) | one frame per ROS message to publish, JSON-encoded |
+| `ws://host:port/service/<service_name>?type=<pkg>/srv/<Type>` | client → server (request) | one frame per request, JSON-encoded |
+| `ws://host:port/service/<service_name>?type=<pkg>/srv/<Type>` | server → client (response) | one frame per response, JSON-serialized |
+
+Notes:
+
+- Each connection is dedicated to one topic or service. A single socket is
+  full-duplex, so the same `/topic/<name>` socket can both publish and
+  subscribe at the same time.
+- The `type=` query parameter can be omitted if the server was started with
+  `topicTypes` / `serviceTypes` defaults for that name.
+- Service calls may be sent as a bare request (`{"a":1,"b":2}`) or wrapped
+  with a correlation id (`{"id":"c1","request":{"a":1,"b":2}}`); responses
+  echo the same shape (`{"id":"c1","response":{...}}`).
+- Errors are reported as `{"error":"<message>"}` frames; fatal protocol errors
+  cause the socket to close with a `1008`/`1011` code.
+- 64-bit integer fields may be sent as JSON numbers or BigInt-encoded
+  strings (`"12n"`); responses use the rclnodejs `toJSONSafe` encoding
+  (BigInts become `"<n>n"` strings).
+
+## Server side
+
+```js
+const rclnodejs = require('rclnodejs');
+const { startRosocket } = require('rclnodejs/rosocket');
+
+await rclnodejs.init();
+const node = new rclnodejs.Node('rosocket_node');
+rclnodejs.spin(node);
+
+await startRosocket({
+  node,
+  port: 9000,
+  // optional: pre-declare types so clients can omit ?type=
+  topicTypes:   { '/chatter':       'std_msgs/msg/String' },
+  serviceTypes: { '/add_two_ints':  'example_interfaces/srv/AddTwoInts' },
+});
+```
+
+### Without `topicTypes` / `serviceTypes`
+
+The `topicTypes` / `serviceTypes` maps are entirely optional. If you omit
+them, the server stays generic and clients must specify the message type
+themselves via the `?type=` query parameter on each connection:
+
+```js
+// server – open to any topic/service the node is allowed to access
+await startRosocket({ node, port: 9000 });
+```
+
+```js
+// browser – type comes from the URL
+const sub = new WebSocket(
+  'ws://localhost:9000/topic/chatter?type=std_msgs/msg/String'
+);
+const cli = new WebSocket(
+  'ws://localhost:9000/service/add_two_ints?type=example_interfaces/srv/AddTwoInts'
+);
+```
+
+The same applies to the CLI — drop `--topic` / `--service` to run a generic
+bridge: `npx rosocket --port 9000`.
+
+## CLI (`rosocket`)
+
+A ready-to-run command is shipped as a `bin` entry, so users do not need to
+write any server code:
+
+```bash
+# from inside this repo
+npm run rosocket -- --port 9000 \
+  --topic   /chatter:std_msgs/msg/String \
+  --service /add_two_ints:example_interfaces/srv/AddTwoInts
+
+# anywhere after `npm i rclnodejs` (or via npx)
+npx rosocket --port 9000 \
+  --topic   /chatter:std_msgs/msg/String \
+  --service /add_two_ints:example_interfaces/srv/AddTwoInts
+```
+
+Options: `--port/-p`, `--host/-H`, `--node-name/-n`, repeatable
+`--topic/-t <name>:<type>` and `--service/-s <name>:<type>`, `--help/-h`.
+Pre-declared types let browsers omit the `?type=` query.
+
+## Browser side (no library)
+
+```html
+<script type="module">
+  // Subscribe
+  const sub = new WebSocket('ws://localhost:9000/topic/chatter');
+  sub.onmessage = (e) => console.log('chatter:', JSON.parse(e.data).data);
+
+  // Publish on the same socket (or a different one)
+  sub.onopen = () => sub.send(JSON.stringify({ data: 'hello from browser' }));
+
+  // Service call
+  const cli = new WebSocket('ws://localhost:9000/service/add_two_ints');
+  cli.onopen    = () => cli.send(JSON.stringify({ a: 1, b: 2 }));
+  cli.onmessage = (e) => console.log('sum =', JSON.parse(e.data).sum);
+</script>
+```
+
+## Why not rosbridge?
+
+Use this bridge when you want:
+
+- **Zero browser dependency** — no JavaScript library to bundle or load.
+- **Zero extra process** — already in the same Node.js where your
+  `rclnodejs` app runs.
+- **Greppable URLs** for reverse-proxy ACLs (`location /topic/...`).
+
+Use a full-featured stack like rosbridge_suite when you need actions, tf,
+parameter helpers, compression, throttling, or compatibility with existing
+ROS web tooling.

package/rosocket/cli.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+// Copyright (c) 2026 RobotWebTools Contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+
+'use strict';
+
+const rclnodejs = require('../index.js');
+const { startRosocket } = require('./index.js');
+
+const USAGE = `Usage: rosocket [options]
+
+rosocket — expose ROS 2 topics and services as resource-style WebSocket URLs.
+
+Options:
+  -p, --port <port>             Port to listen on (default: 9000)
+  -H, --host <host>             Host/interface to bind (default: 0.0.0.0)
+  -n, --node-name <name>        ROS 2 node name (default: rosocket)
+  -t, --topic <name>:<type>     Pre-declare a topic type (repeatable)
+                                e.g. --topic /chatter:std_msgs/msg/String
+  -s, --service <name>:<type>   Pre-declare a service type (repeatable)
+                                e.g. --service /add:example_interfaces/srv/AddTwoInts
+  -h, --help                    Show this help
+
+URL scheme:
+  ws://host:port/topic/<name>?type=<pkg>/msg/<Type>
+  ws://host:port/service/<name>?type=<pkg>/srv/<Type>
+
+Pre-declared types via --topic/--service let clients omit the ?type= query.
+`;
+
+function parseArgs(argv) {
+  const opts = {
+    port: 9000,
+    host: '0.0.0.0',
+    nodeName: 'rosocket',
+    topicTypes: {},
+    serviceTypes: {},
+  };
+  const need = (i, flag) => {
+    if (i + 1 >= argv.length) {
+      console.error(`error: ${flag} requires a value`);
+      process.exit(2);
+    }
+    return argv[i + 1];
+  };
+  const addPair = (target, raw, flag) => {
+    const idx = raw.indexOf(':');
+    if (idx <= 0) {
+      console.error(`error: ${flag} expects <name>:<type>, got "${raw}"`);
+      process.exit(2);
+    }
+    let name = raw.slice(0, idx);
+    const type = raw.slice(idx + 1);
+    if (!name.startsWith('/')) name = '/' + name;
+    target[name] = type;
+  };
+
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    switch (a) {
+      case '-h':
+      case '--help':
+        console.log(USAGE);
+        process.exit(0);
+        break;
+      case '-p':
+      case '--port': {
+        const raw = need(i, a);
+        const p = Number(raw);
+        if (!Number.isInteger(p) || p < 0 || p > 65535) {
+          console.error(
+            `error: ${a} expects an integer in 0–65535, got "${raw}"`
+          );
+          process.exit(2);
+        }
+        opts.port = p;
+        i++;
+        break;
+      }
+      case '-H':
+      case '--host':
+        opts.host = need(i, a);
+        i++;
+        break;
+      case '-n':
+      case '--node-name':
+        opts.nodeName = need(i, a);
+        i++;
+        break;
+      case '-t':
+      case '--topic':
+        addPair(opts.topicTypes, need(i, a), a);
+        i++;
+        break;
+      case '-s':
+      case '--service':
+        addPair(opts.serviceTypes, need(i, a), a);
+        i++;
+        break;
+      default:
+        console.error(`error: unknown argument: ${a}`);
+        console.error(USAGE);
+        process.exit(2);
+    }
+  }
+  return opts;
+}
+
+async function main() {
+  const opts = parseArgs(process.argv.slice(2));
+
+  await rclnodejs.init();
+  const node = rclnodejs.createNode(opts.nodeName);
+  rclnodejs.spin(node);
+
+  const bridge = await startRosocket({
+    node,
+    port: opts.port,
+    host: opts.host,
+    topicTypes: opts.topicTypes,
+    serviceTypes: opts.serviceTypes,
+  });
+
+  // 0.0.0.0 / :: are bind wildcards, not reachable URLs. Show a usable
+  // hostname in the log so users can paste the URL directly into a browser.
+  const displayHost =
+    opts.host === '0.0.0.0' || opts.host === '::' || opts.host === ''
+      ? '127.0.0.1'
+      : opts.host;
+  console.log(
+    `[rosocket] node="${opts.nodeName}" listening on ws://${displayHost}:${bridge.port} (bind=${opts.host})`
+  );
+  for (const [name, type] of Object.entries(opts.topicTypes)) {
+    console.log(`  topic   ${name}\t-> ${type}`);
+  }
+  for (const [name, type] of Object.entries(opts.serviceTypes)) {
+    console.log(`  service ${name}\t-> ${type}`);
+  }
+
+  const shutdown = (sig) => {
+    console.log(`[rosocket] received ${sig}, shutting down`);
+    // Hard-exit fallback in case ws/rcl close callbacks don't fire
+    // (e.g. due to in-flight rclnodejs.spin loop keeping the event loop busy).
+    const hard = setTimeout(() => process.exit(0), 1500);
+    hard.unref();
+    Promise.resolve()
+      .then(() => bridge.close())
+      .catch(() => {})
+      .then(() => {
+        try {
+          rclnodejs.shutdown();
+        } catch (_) {}
+        process.exit(0);
+      });
+  };
+  process.on('SIGINT', () => shutdown('SIGINT'));
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
+}
+
+main().catch((e) => {
+  console.error(e.stack || e.message);
+  process.exit(1);
+});

package/rosocket/index.js

@@ -0,0 +1,245 @@
+// Copyright (c) 2026 RobotWebTools Contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+
+'use strict';
+
+const { WebSocketServer } = require('ws');
+const debug = require('debug')('rclnodejs:rosocket');
+const { toJSONSafe } = require('../lib/message_serialization.js');
+
+// Convert a JSON value coming from the browser into shapes rclnodejs understands.
+// Mainly: integer fields declared as 64-bit need to be BigInt. We don't have schema
+// information here, so we accept either Number or BigInt for fields and let the
+// underlying serializer coerce. For convenience we convert string-encoded ints
+// like "12n" produced by toJSONSafe back to BigInt.
+function reviveBigInts(value) {
+  if (value === null || typeof value !== 'object') {
+    if (typeof value === 'string' && /^-?\d+n$/.test(value)) {
+      return BigInt(value.slice(0, -1));
+    }
+    return value;
+  }
+  if (Array.isArray(value)) return value.map(reviveBigInts);
+  const out = {};
+  for (const k of Object.keys(value)) out[k] = reviveBigInts(value[k]);
+  return out;
+}
+
+function safeSend(ws, payload) {
+  if (ws.readyState !== ws.OPEN) return;
+  try {
+    ws.send(typeof payload === 'string' ? payload : JSON.stringify(payload));
+  } catch (e) {
+    debug('send failed: %s', e.message);
+  }
+}
+
+function sendError(ws, message, extra) {
+  safeSend(ws, { error: message, ...(extra || {}) });
+}
+
+// Decode a URL path into { kind, name } where kind is 'topic' or 'service'.
+// Examples:
+//   /topic/chatter            -> { kind:'topic',   name:'/chatter' }
+//   /topic/ns/sub/chatter     -> { kind:'topic',   name:'/ns/sub/chatter' }
+//   /service/add_two_ints     -> { kind:'service', name:'/add_two_ints' }
+function parseResourcePath(pathname) {
+  const m = /^\/(topic|service)\/(.+)$/.exec(pathname);
+  if (!m) return null;
+  const name = '/' + m[2].replace(/^\/+/, '');
+  if (name.length < 2) return null;
+  return { kind: m[1], name };
+}
+
+/**
+ * Start a resource-style WebSocket bridge that exposes ROS 2 topics and
+ * services as plain WebSocket URLs carrying ROS messages as JSON.
+ *
+ * URL scheme:
+ *   ws://host:port/topic/<topic_name>?type=<pkg>/msg/<Type>
+ *   ws://host:port/service/<service_name>?type=<pkg>/srv/<Type>
+ *
+ * The browser only needs the built-in `WebSocket` and `JSON` APIs.
+ *
+ * @param {Object} options
+ * @param {import('../lib/node.js')} options.node - rclnodejs Node to host pubs/subs/clients on.
+ * @param {number} [options.port=9000] - Port to listen on.
+ * @param {string} [options.host='0.0.0.0'] - Host to bind to.
+ * @param {Object<string,string>} [options.topicTypes] - Optional default type per topic name (e.g. {"/chatter":"std_msgs/msg/String"}).
+ * @param {Object<string,string>} [options.serviceTypes] - Optional default type per service name.
+ * @param {(req: import('http').IncomingMessage) => boolean} [options.verifyClient] - Optional auth hook called with the raw HTTP upgrade request; return `false` to reject the connection.
+ * @returns {Promise<{wss: WebSocketServer, close: () => Promise<void>, port: number}>}
+ */
+function startRosocket(options = {}) {
+  const {
+    node,
+    port = 9000,
+    host = '0.0.0.0',
+    topicTypes = {},
+    serviceTypes = {},
+    verifyClient,
+  } = options;
+
+  if (!node) throw new TypeError('startRosocket: options.node is required');
+
+  // ws's verifyClient is invoked with `info = { origin, secure, req }`,
+  // not the raw IncomingMessage. Wrap it so users can write a simple
+  // `(req) => boolean` hook as documented above.
+  const wsVerifyClient = verifyClient
+    ? (info) => verifyClient(info.req)
+    : undefined;
+
+  return new Promise((resolve, reject) => {
+    const wss = new WebSocketServer({
+      host,
+      port,
+      verifyClient: wsVerifyClient,
+    });
+
+    wss.on('error', reject);
+
+    wss.on('connection', (ws, req) => {
+      const url = new URL(req.url, 'http://localhost');
+      const resource = parseResourcePath(url.pathname);
+      if (!resource) {
+        sendError(ws, `Unknown path: ${url.pathname}`);
+        ws.close(1008, 'unknown path');
+        return;
+      }
+      const typeFromQuery = url.searchParams.get('type');
+      const typeFromMap =
+        resource.kind === 'topic'
+          ? topicTypes[resource.name]
+          : serviceTypes[resource.name];
+      const typeName = typeFromQuery || typeFromMap;
+      if (!typeName) {
+        sendError(
+          ws,
+          `Missing message type. Specify ?type=<pkg>/${resource.kind === 'topic' ? 'msg' : 'srv'}/<Type> or configure it server-side.`
+        );
+        ws.close(1008, 'missing type');
+        return;
+      }
+
+      try {
+        if (resource.kind === 'topic') {
+          handleTopic(ws, node, resource.name, typeName);
+        } else {
+          handleService(ws, node, resource.name, typeName);
+        }
+      } catch (e) {
+        debug('connection setup failed: %s', e.stack || e.message);
+        sendError(ws, e.message);
+        ws.close(1011, 'setup error');
+      }
+    });
+
+    wss.on('listening', () => {
+      const addr = wss.address();
+      debug('rosocket listening on %s:%d', addr.address, addr.port);
+      resolve({
+        wss,
+        port: addr.port,
+        close: () =>
+          new Promise((res) => {
+            for (const client of wss.clients) {
+              try {
+                client.close();
+              } catch (_) {}
+            }
+            wss.close(() => res());
+          }),
+      });
+    });
+  });
+}
+
+function handleTopic(ws, node, topicName, typeName) {
+  // Lazily create both a publisher and a subscription on first need.
+  // The publisher is only created if/when the client publishes; the
+  // subscription is created immediately so the client receives messages.
+  let publisher = null;
+  const subscription = node.createSubscription(typeName, topicName, (msg) => {
+    safeSend(ws, toJSONSafe(msg));
+  });
+  debug('subscribed %s [%s]', topicName, typeName);
+
+  ws.on('message', (data, isBinary) => {
+    if (isBinary) {
+      sendError(ws, 'binary frames not supported on /topic/*');
+      return;
+    }
+    let msg;
+    try {
+      msg = reviveBigInts(JSON.parse(data.toString('utf8')));
+    } catch (e) {
+      sendError(ws, `invalid JSON: ${e.message}`);
+      return;
+    }
+    try {
+      if (!publisher) {
+        publisher = node.createPublisher(typeName, topicName);
+      }
+      publisher.publish(msg);
+    } catch (e) {
+      sendError(ws, `publish failed: ${e.message}`);
+    }
+  });
+
+  ws.on('close', () => {
+    try {
+      node.destroySubscription(subscription);
+    } catch (_) {}
+    if (publisher) {
+      try {
+        node.destroyPublisher(publisher);
+      } catch (_) {}
+    }
+  });
+}
+
+function handleService(ws, node, serviceName, typeName) {
+  const client = node.createClient(typeName, serviceName);
+  debug('service client created %s [%s]', serviceName, typeName);
+
+  ws.on('message', (data, isBinary) => {
+    if (isBinary) {
+      sendError(ws, 'binary frames not supported on /service/*');
+      return;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(data.toString('utf8'));
+    } catch (e) {
+      sendError(ws, `invalid JSON: ${e.message}`);
+      return;
+    }
+    // Allow either bare request {a:1,b:2} or wrapped {id, request}.
+    const id = parsed && typeof parsed === 'object' ? parsed.id : undefined;
+    const request = reviveBigInts(
+      parsed && parsed.request !== undefined ? parsed.request : parsed
+    );
+
+    try {
+      client.sendRequest(request, (response) => {
+        const body = toJSONSafe(response);
+        safeSend(ws, id !== undefined ? { id, response: body } : body);
+      });
+    } catch (e) {
+      sendError(ws, `service call failed: ${e.message}`, { id });
+    }
+  });
+
+  ws.on('close', () => {
+    try {
+      node.destroyClient(client);
+    } catch (_) {}
+  });
+}
+
+module.exports = { startRosocket };

package/scripts/install.js

@@ -15,6 +15,10 @@
 const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
+const {
+  detectPrebuildRuntime,
+  getTaggedPrebuildFilename,
+} = require('../lib/prebuilds');
 const { detectUbuntuCodename } = require('../lib/utils');
 
 function getRosDistro() {
@@ -24,6 +28,7 @@ function getRosDistro() {
 function checkPrebuiltBinary() {
   const platform = process.platform;
   const arch = process.arch;
+  const runtime = detectPrebuildRuntime();
 
   // Only Linux has prebuilt binaries
   if (platform !== 'linux') {
@@ -50,18 +55,24 @@ function checkPrebuiltBinary() {
     'prebuilds',
     `${platform}-${arch}`
   );
-  const expectedBinary = `${rosDistro}-${ubuntuCodename}-${arch}-rclnodejs.node`;
+  const expectedBinary = getTaggedPrebuildFilename({
+    rosDistro,
+    ubuntuCodename,
+    arch,
+    runtime,
+  });
+
   const binaryPath = path.join(prebuildDir, expectedBinary);
 
   if (fs.existsSync(binaryPath)) {
     console.log(`✓ Found prebuilt binary: ${expectedBinary}`);
-    console.log(`  Platform: ${platform}, Arch: ${arch}`);
+    console.log(`  Platform: ${platform}, Arch: ${arch}, Runtime: ${runtime}`);
     console.log(`  Ubuntu: ${ubuntuCodename}, ROS: ${rosDistro}`);
     return true;
   }
 
   console.log(
-    `✗ No prebuilt binary found for ${rosDistro}-${ubuntuCodename}-${arch}`
+    `✗ No ${runtime} prebuilt binary found for ${rosDistro}-${ubuntuCodename}-${arch}`
   );
 
   // List available binaries for debugging

package/scripts/tag_prebuilds.js

@@ -14,6 +14,10 @@
 
 const fs = require('fs');
 const path = require('path');
+const {
+  getRuntimeFromGeneratedPrebuild,
+  getTaggedPrebuildFilename,
+} = require('../lib/prebuilds');
 const { detectUbuntuCodename } = require('../lib/utils');
 
 function tagPrebuilds() {
@@ -38,23 +42,36 @@ function tagPrebuilds() {
     return;
   }
 
-  const files = fs.readdirSync(prebuildDir).filter((f) => f.endsWith('.node'));
+  const files = fs
+    .readdirSync(prebuildDir)
+    .filter(
+      (file) => file.endsWith('.node') && getRuntimeFromGeneratedPrebuild(file)
+    );
 
   for (const file of files) {
     const filePath = path.join(prebuildDir, file);
+    const runtime = getRuntimeFromGeneratedPrebuild(file);
 
-    // Create tagged version with format: {ros_distro}-{linux-codename}-{cpu-arch}-rclnodejs.node
-    if (rosDistro && ubuntuCodename) {
-      const taggedName = `${rosDistro}-${ubuntuCodename}-${arch}-rclnodejs.node`;
+    // Create tagged version with format:
+    // {ros_distro}-{linux-codename}-{cpu-arch}-{runtime}-rclnodejs.node
+    if (rosDistro && ubuntuCodename && runtime) {
+      const taggedName = getTaggedPrebuildFilename({
+        rosDistro,
+        ubuntuCodename,
+        arch,
+        runtime,
+      });
       const taggedPath = path.join(prebuildDir, taggedName);
+
+      if (fs.existsSync(taggedPath)) {
+        fs.unlinkSync(taggedPath);
+      }
+
       fs.copyFileSync(filePath, taggedPath);
       console.log(`Created tagged binary: ${taggedName}`);
 
-      // Remove the original generic binary file if it's the basic rclnodejs.node
-      if (file === 'rclnodejs.node') {
-        fs.unlinkSync(filePath);
-        console.log(`Removed generic binary: ${file}`);
-      }
+      fs.unlinkSync(filePath);
+      console.log(`Removed generated binary: ${file}`);
     } else {
       console.log(
         `Skipping tagging for ${file} - missing ROS_DISTRO or Ubuntu codename`