@yz-social/kdht 0.1.0

package/spec/dhtInternalsSpec.js

@@ -0,0 +1,253 @@
+import { Node, KBucket, Contact, SimulatedContact, Helper } from '../index.js';
+const { describe, it, expect, beforeAll, afterAll, BigInt} = globalThis; // For linters.
+
+describe("DHT internals", function () {
+  beforeAll(function () {
+    //Node.distinguisher = 0;
+  });
+  afterAll(function () {
+    Node.stopRefresh();
+  });
+
+  describe("structure", function () {
+    let example;
+    beforeAll(async function () {
+      const contact = await SimulatedContact.create(0);
+      example = contact.node;
+    });
+    it("has key.", function () {
+      expect(typeof example.key).toBe('bigint');
+    });
+    describe("local storage", function () {
+      it("stores by Identifier key.", async function () {
+	let key = await Node.key("foo");
+	let value = 17;
+	example.storeLocally(key, value);
+	let retrieved = example.retrieveLocally(key);
+	expect(retrieved).toBe(value);
+      });
+      it("retrieves undefined if not set.", async function () {
+	let key = await Node.key("not seen");
+	let retrieved = example.retrieveLocally(key);
+	expect(retrieved).toBeUndefined();
+      });
+    });
+      
+    describe("report", function () {
+      beforeAll(async function () { // Add some data for which we know the expected internal structure.
+	example.storeLocally(await Node.key("foo"), 17); // May or may not have already been set to same value, depending on test order.
+	example.storeLocally(await Node.key("bar"), "baz");
+	const contact = await SimulatedContact.create();
+	const node = contact.node;
+	let bucket = new KBucket(node, 90); // 90 isn't correct, but we're just looking at the structure.
+	bucket.contacts.push(await SimulatedContact.fromKey(1, node));
+	bucket.contacts.push(await SimulatedContact.fromKey(2, node));
+	example.routingTable.set(90, bucket);
+      });
+      afterAll(function () {
+	example.routingTable.delete(90);
+      });
+      it("includes name, routing names and stored items by bigInt key.", function () {
+	let report = example.report(string => string); // No op for what to do with the report. Just return it.
+	expect(report).toBe(`Node: 0, 0 transports
+  storing 2: 58686998438798322974467776505749455156n: 17, 336119020696479164089214630533760195420n: "baz"
+  90: 1n, 2n`);
+      });
+    });
+
+    describe("constants", function () {
+      it("alpha >= 3.", function () {
+	expect(Node.alpha).toBeGreaterThanOrEqual(3);
+      });
+      it("k >= 10.", function () {
+	expect(Node.k).toBeGreaterThanOrEqual(10);
+      });
+    });
+  });
+  
+  describe("operations", function () {
+    const one = 1n;
+    const two = 2n;
+    const three = 3n;
+    const max = Node.one << BigInt(Node.keySize);
+    describe("commonPrefixLength", function () {
+      it("is keySize for 0n.", function () {
+	expect(Node.commonPrefixLength(Node.zero)).toBe(Node.keySize);
+      });
+      it("is keySize - 1 for 1n.", function () {
+	expect(Node.commonPrefixLength(Node.one)).toBe(Node.keySize - 1);
+      });
+      it("is 1 for (keySize - 1) ones.", function () {
+	expect(Node.commonPrefixLength(BigInt("0b" + "1".repeat(Node.keySize-1)))).toBe(1);
+      });
+      it("is 0 for keySize ones.", function () {
+	expect(Node.commonPrefixLength(BigInt("0b" + "1".repeat(Node.keySize)))).toBe(0);
+      });
+    });
+    describe("getBucketIndex", function () {
+      let node;
+      beforeAll(function () {
+	node = Node.fromKey(Node.zero); 
+      });
+      it("bucket keySize -1 is farthest.", function () {
+	const distance = max - Node.one; // max distance within nTagBits. All bits on.
+	expect(node.getBucketIndex(distance)).toBe(Node.keySize - 1);
+      });
+      it("bucket keySize - 2 is for middle distance.", function () {
+	const distance = (max / two) - Node.one;
+	expect(node.getBucketIndex(distance)).toBe(Node.keySize - 2);
+      });
+      it("bucket 1 is for a distance 2.", function () {
+	const distance = two;
+	expect(node.getBucketIndex(distance)).toBe(1);
+      });
+      it("bucket 0 is for a closest distance.", function () {
+	const distance = Node.one;
+	expect(node.getBucketIndex(distance)).toBe(0);
+      });
+    });
+    describe("randomTarget", function () {
+      let node;
+      beforeAll(async function () {
+	node = await Node.create();
+      });
+      function test(bucketIndex) {
+	it(`computes random of ${bucketIndex}.`, function () {
+	  const random = node.ensureBucket(bucketIndex).randomTarget;
+	  const computedBucket = node.getBucketIndex(random);
+	  expect(computedBucket).toBe(bucketIndex);
+	});
+      }
+      for (let i = 0; i < Node.keySize; i++) test(i);
+    });
+
+    describe("examination", function () {
+      const keys = [];
+      let node;
+      beforeAll(async function () {
+	// Applications won't be hand-creating the routingTable, but this test does.
+	const contact = await SimulatedContact.create();
+	node = contact.node;
+	const bucket0 = new KBucket(node, 0);
+	const bucket10 = new KBucket(node, 10);
+	const bucket60 = new KBucket(node, 60);
+	const bucket90 = new KBucket(node, 90);	
+	const addTo = async bucket => {
+	  const key = bucket.randomTarget;
+	  keys.push(key);
+	  await bucket.addContact(SimulatedContact.fromKey(key, node));
+	};
+	await addTo(bucket0,);
+	await addTo(bucket10);
+	await addTo(bucket60);
+	await addTo(bucket90);
+	node.routingTable.set(0, bucket0);
+	node.routingTable.set(10, bucket10);	
+	node.routingTable.set(60, bucket60);
+	node.routingTable.set(90, bucket90);	
+      });
+      it("is initially empty.", async function () {
+	const node = await Node.create();
+	expect(node.contacts).toEqual([]);
+      });
+      it("collects from all buckets.", function () {
+	const contacts = node.contacts;
+	const asKeys = contacts.map(c => c.key);
+	expect(asKeys).toEqual(keys);
+      });
+      it("finds all ordered keys there are.", function () {
+	let target = node.key;
+	let all = [node.key, ...keys]; // Our findClosestHelpers includes ourself.
+	let keysAndDistances = all.map(key => ({key, distance: Node.distance(target, key)}));
+	keysAndDistances.sort(Helper.compare);
+	const closest = node.findClosestHelpers(target);
+	const mapped = closest.map(helper => ({key: helper.key, distance: helper.distance}));
+	expect(mapped).toEqual(keysAndDistances);
+      });
+      it("reports name and bucket contents.", function () {
+	let report = node.report(string => string);
+	let expected = `Node: ${node.name}, 0 transports
+  0: ${node.routingTable.get(0).contacts.map(c => c.key.toString() + 'n').join(', ')}
+  10: ${node.routingTable.get(10).contacts.map(c => c.key.toString() + 'n').join(', ')}
+  60: ${node.routingTable.get(60).contacts.map(c => c.key.toString() + 'n').join(', ')}
+  90: ${node.routingTable.get(90).contacts.map(c => c.key.toString() + 'n').join(', ')}`;	
+	expect(report).toBe(expected);
+      });
+    });
+    describe("discovery", function () {
+      it("does not place self.", async function () {
+	let node = Node.fromKey(Node.one);
+	expect(await node.addToRoutingTable(SimulatedContact.fromKey(Node.one))).toBeFalsy();
+	expect(node.routingTable.size).toBe(0);
+      });
+      it("places in bucket if room.", async function () {
+	let contact = SimulatedContact.fromKey(Node.zero);
+	let node = contact.node;
+	let other = SimulatedContact.fromKey(Node.one, node); // Closest bucket
+	expect(await node.addToRoutingTable(other)).toBeTruthy();
+	expect(node.getBucketIndex(Node.one)).toBe(0);
+	const bucket = node.routingTable.get(0);
+	expect(bucket.contacts[0].key).toBe(Node.one);
+      });
+      describe("examples", function () {
+	const nOthers = Node.k + 40; // k+31 will not overflow. k+40 would overflow.
+	let node;
+	beforeAll(async function () {
+	  let start = Date.now();
+	  const host = SimulatedContact.fromKey(Node.zero);
+	  node = host.node;
+	  // These others are all constructed to have distances that increase by one from node.
+	  for (let i = 1; i <= nOthers; i++) {
+	    let other = SimulatedContact.fromKey(BigInt(i), host.host);
+	    await node.addToRoutingTable(other);
+	  }
+	  //node.report();
+	}, 20e3);
+	it("places k in bucket.", function () {
+	  // Checks the results of the discover() placement, each other should have filled in starting from the closest end.
+	  // Working backwards from the last kBucket, these will all fill in 1, 2, 4, 8, 16 nodes in each bucket.
+	  // The next bucket will then fill in k=20
+
+	  // Iterate through the buckets, keeping track of the expectCount in each (1, 2, 4, ...)
+	  for (let bucketIndex = 0, expectCount = 1, otherBigInt = Node.one, othersLast = BigInt(nOthers );
+	       otherBigInt <= othersLast;
+	       bucketIndex++, expectCount *= 2) {
+	    const bucket = node.routingTable.get(bucketIndex);
+	    // Now iterate through the entries in the bucket, up to expectCount or k.
+	    let i = 0;
+
+	    // Full bucket.contacts can be in a different order because each attempt to add to a full bucket
+	    // causes the head of the bucket to be pinged and (if alive) rotated to the back.
+	    // So, let's just collect the keys and the expected values, andnd sort the keys for comparison.
+	    let keys = bucket.contacts.map(c => c.key);
+	    let expecting = [];
+	    for (; i < Math.min(expectCount, Node.k); i++) expecting.push(otherBigInt++);
+	    const compare = (a, b) => {
+	      if (a < b) return -1;
+	      if (a > b) return 1;
+	      return 0;
+	    };
+	    keys.sort(compare);
+	    expect(keys).toEqual(expecting);
+
+	    if (i >= Node.k) { // Now soak up those dropped, if any. (If we add a bucket replacement cache, it would be checked here.)
+	      for (i = 0; otherBigInt <= othersLast; i++) {
+		otherBigInt++;
+	      }
+	    }
+	  }
+	});
+	it('finds closest keys', function () {
+	  const closest = node.findClosestHelpers(BigInt(40));
+	  const keys = closest.map(helper => helper.key);
+	  expect(keys).toEqual([
+  40n, 41n, 42n, 43n, 44n,
+  45n, 46n, 47n, 32n, 33n,
+  34n, 35n, 36n, 37n, 38n,
+  39n, 48n, 49n, 50n, 51n
+]);
+	});
+      });
+    });
+  });
+});

package/spec/dhtKeySpec.js

@@ -0,0 +1,92 @@
+import { Node } from '../index.js';
+const { describe, it, expect, BigInt, afterAll } = globalThis; // For linters.
+
+describe("DHT Keys", function () {
+  afterAll(function () {
+    Node.stopRefresh();
+  });
+
+  describe("Node creation", function () {
+
+    describe("from string", function () {
+      it("keeps given name.", async function () {
+	let name = "something";
+	let node= await Node.create(name);
+	expect(node.name).toBe(name);
+	expect(typeof node.key).toBe('bigint');
+      });
+
+      it("can ommit name.", async function () {
+	let node = await Node.create();
+	expect(typeof node.name).toBe('string');
+	expect(typeof node.key).toBe('bigint');
+      });
+      
+      it("has non-negative bigInt.", async function () {
+	const key = Math.random();
+	const node = await Node.create(key);
+	const bigInt = node.key;
+	expect(bigInt).toBeGreaterThanOrEqual(0n);
+      });
+    });
+  });
+
+  describe("keySize", function () {
+    it("is >= 128.", function () {
+      expect(Node.keySize).toBeGreaterThanOrEqual(128);
+    });
+
+    it("is a multiple of 8.", function () {
+      expect(Node.keySize % 8).toBe(0);
+    });
+
+    it("is the max number of bits in the Identifier bigInt.", async function () {
+      const example = await Node.create("something else");
+      // Not every example will have a leading 1 in the most significant bit, but this one does.
+      const binaryString = example.key.toString(2);
+      expect(binaryString.length).toBe(Node.keySize);
+
+      const random = await Node.create(Math.random());
+      expect(random.key.toString(2).length).toBeLessThanOrEqual(Node.keySize);
+    });
+  });
+
+  describe("distance", function () {
+
+    it("is xor as a BigInt.", function () {
+      // Here we are just spot checking some of the bits.
+      let a = BigInt(0b1010);
+      let b = BigInt(0b1001);
+      let distance = Node.distance(a, b);
+      expect(distance).toBe(BigInt(0b11));
+    });
+
+    it("is zero from itself.", async function () {
+      let random = await Node.create(Math.random());
+      let distance = Node.distance(random.key, random.key);
+      expect(distance).toBe(0n);
+    });
+
+    it("is commutative.", async function () {
+      let a = await Node.create(Math.random());
+      let b = await Node.create(Math.random());
+      let distance1 = Node.distance(a.key, b.key);
+      let distance2 = Node.distance(b.key, a.key);
+      expect(distance1).toBe(distance2);
+    });
+
+    it("is maximum (all nTagBits on) for a complement.", async function () {
+      let random = await Node.create(Math.random());
+      let key = random.key;
+      let flipped = ~key;
+      let truncatedFlipped = BigInt.asUintN(Node.keySize, flipped);
+      let complementIdentifier = truncatedFlipped;
+      let distance = Node.distance(key, complementIdentifier);
+      let one = 1n;
+      let next = distance + one;
+      let max = one << BigInt(Node.keySize);
+      expect(next).toBe(max);
+    });
+  });
+});
+

package/spec/dhtWriteRead.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env npx jasmine
+const { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach } = globalThis; // For linters.
+import process from 'node:process';
+import { exec } from 'node:child_process';
+import { v4 as uuidv4 } from 'uuid';
+import { WebContact, Node } from '../index.js';
+
+// I cannot get yargs to work properly within jasmine. Get args by hand.
+// Note: jasmine will treat --options as arguments to itself. To pass them to the script, you need to separate with '--'.
+const nWritesIndex = process.argv.indexOf('--nWrites');
+const baseURLIndex = process.argv.indexOf('--baseURL');
+const waitBeforeReadIndex = process.argv.indexOf('--waitBeforeRead');
+const verboseIndex = process.argv.indexOf('--verbose');
+const shutdownIndex = process.argv.indexOf('--shutdown');
+
+const nWrites = nWritesIndex >= 0 ? JSON.parse(process.argv[nWritesIndex + 1]) : 10;
+const baseURL = baseURLIndex >= 0 ? process.argv[baseURLIndex + 1] : 'http://localhost:3000/kdht';
+const waitBeforeRead = waitBeforeReadIndex >= 0 ? JSON.parse(process.argv[waitBeforeReadIndex + 1]) : 10;
+const verbose = verboseIndex >= 0 ? JSON.parse( process.argv[verboseIndex + 1] || 'true' ) : false;
+const shutdown = shutdownIndex >= 0 ? JSON.parse( process.argv[shutdownIndex + 1] || 'true' ) : true;
+
+describe("DHT write/read", function () {
+  let contact;
+  beforeAll(async function () {
+    contact = await WebContact.create({name: uuidv4(), debug: verbose});
+    const bootstrapName = await contact.fetchBootstrap(baseURL);
+    const bootstrapContact = await contact.ensureRemoteContact(bootstrapName, baseURL);
+    console.log(new Date(), contact.sname, 'joining', bootstrapContact.sname);
+    await contact.join(bootstrapContact);
+    console.log(new Date(), contact.sname, 'joined');    
+    for (let index = 0; index < nWrites; index++) {
+      const wrote = await contact.storeValue(index, index);
+      console.log('Wrote', index);
+    }
+    if (waitBeforeRead) {
+      console.log(new Date(), `Written. Waiting ${waitBeforeRead.toLocaleString()} ms before reading.`);
+      await Node.delay(waitBeforeRead);
+    }
+    console.log(new Date(), 'Reading');
+  }, 5e3 * nWrites + 2 * Node.refreshTimeIntervalMS);
+  afterAll(async function () {
+    if (shutdown) {
+      contact.disconnect();
+      exec('pkill kdht-portal-server');
+    } else {
+      contact.disconnect();
+    }
+  });
+  for (let index = 0; index < nWrites; index++) {
+    it(`reads ${index}.`, async function () {
+      const read = await contact.node.locateValue(index);
+      console.log('read', read);
+      expect(read).toBe(index);
+    }, 10e3); // Can take longer to re-establish multiple connections.
+  }
+});

package/spec/node.html

@@ -0,0 +1,47 @@
+<html>
+  <head>
+    <script type="importmap">
+      {
+	"imports": {
+	  "uuid": "./uuid/index.js",
+	  "@yz-social/kdht": "./kdht/index.js",
+	  "@yz-social/webrtc": "./webrtc/index.js"
+	}
+      }
+    </script>
+  </head>
+  <body>
+    <button id="update">update node display</button><pre id="display"></pre><br/>
+    <input type="text" id="key" placeholder="key to read or write under"></input><br/>
+    <input type="text" id="writeValue" placeholder="value to write"></input> <button id="write">write</button><br/>
+    <input type="text" id="readValue" placeholder="read value" readonly></input> <button id="read">read</button><br/>    
+    <script type="module">
+      import { v4 as uuidv4 } from 'uuid';
+      import { WebContact } from '@yz-social/kdht';
+      Object.assign(globalThis, {uuidv4, WebContact });
+
+      let name = localStorage.getItem('name');
+      if (!name) {
+	name = uuidv4();
+	localStorage.setItem('name', name);
+      }
+      const contact = globalThis.contact = await WebContact.create({name});
+      const bootstrapBase = new URL('/kdht', origin).href; // Must be a string
+      const bootstrapName = await contact.fetchBootstrap(bootstrapBase);
+      console.log('connecting to', bootstrapName);
+      const bootstrapContact = globalThis.bootstrapContact = await contact.ensureRemoteContact(bootstrapName, bootstrapBase);
+      await contact.join(bootstrapContact);
+      console.log('connected');
+
+      update.onclick = () => {
+        const report = contact.node.report(null);
+        console.log({report, display});
+        display.textContent = report;
+      };
+      update.onclick();
+
+      write.onclick = () => contact.storeValue(key.value, writeValue.value);
+      read.onclick = () => contact.node.locateValue(key.value).then(value => readValue.value = value);
+    </script>
+  </body>    
+</html>  

package/spec/portal.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+import process from 'node:process';
+import cluster from 'node:cluster';
+import { spawn } from 'node:child_process'; // For optionally spawning bots.js
+import { launchWriteRead } from './writes.js';
+import express from 'express';
+import logger from 'morgan';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { Node } from '../index.js';
+
+// TODO: Allow a remote portal to be specified that this portal will hook with, forming one big network.
+const argv = yargs(hideBin(process.argv))
+      .usage("Start an http post server through which nodes can connect to set of nPortals stable nodes.")
+      .option('nPortals', {
+	alias: 'nportals',	
+	alias: 'p',
+	type: 'number',
+	default: 20,
+	description: "The number of steady nodes that handle initial connections."
+      })
+      .option('nBots', {
+	alias: 'nbots',
+	alias: 'n',
+	type: 'number',
+	default: 0,
+	description: "If non-zero, spawns bots.js with the given nBots."
+      })
+      .option('thrash', {
+	type: 'boolean',
+	default: false,
+	description: "Do the nBots randomly disconnect and reconnect with no memory of previous data?"
+      })
+      .option('nWrites', {
+	alias: 'w',
+	type: 'number',
+	default: 0,
+	description: "The number of test writes to pass to bots.js."
+      })
+      .option('baseURL', {
+	type: 'string',
+	default: 'http://localhost:3000/kdht',
+	description: "The base URL of the portal server through which to bootstrap."
+      })
+      .option('externalBaseURL', {
+	type: 'string',
+	default: '',
+	description: "The base URL of the some other portal server to which we should connect ours, if any."
+      })
+      .option('verbose', {
+	alias: 'v',
+	type: 'boolean',
+	description: "Run with verbose logging."
+      })
+      .option('fixedSpacing', {
+	type: 'number',
+	default: 2,
+	description: "Minimum seconds to add between each portal."
+      })
+      .options('variableSpacing', {
+	type: 'number',
+	default: 5,
+	description: "Additional variable seconds (+/- variableSpacing/2) to add to fixedSpacing between each portal."
+      })
+      .parse();
+
+// NodeJS cluster forks a group of process that each communicate with the primary via send/message.
+// Each fork is a stateful kdht node that can each handle multiple WebRTC connections. The parent runs
+// a Web server that handles Post request by sending the data to the specific fork.
+// 
+// (Some other applications using NodeJS cluster handle stateless requests, so each fork listens directly
+// on a shared socket and picks up requests randomly. We do not make use of that shared socket feature.)
+
+if (cluster.isPrimary) { // Parent process with portal webserver through which clienta can bootstrap
+  // Our job is to launch some kdht nodes to which clients can connect by signaling through
+  // a little web server operated here.
+  process.title = 'kdht-portal-server';
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path.dirname(__filename);
+  const app = express();
+  //fixme if (argv.verbose)
+    app.use(logger(':date[iso] :status :method :url :res[content-length] - :response-time ms'));
+
+  for (let i = 0; i < argv.nPortals; i++) cluster.fork();
+  const portalServer = await import('../portals/router.js');
+  
+  // Portal server
+  app.set('port', parseInt((new URL(argv.baseURL)).port || '80'));
+  console.log(new Date(), process.title, 'startup on port', app.get('port'), 'in', __dirname);
+  app.use(express.json());
+
+  app.use('/kdht', portalServer.router);
+  app.use(express.static(path.resolve(__dirname, '..')));
+  app.listen(app.get('port'));
+  const startupSeconds = argv.fixedSpacing * argv.nPortals + 1.5 * argv.variableSpacing;
+  console.log(`Starting ${argv.nPortals} portals over ${startupSeconds} seconds.`);
+  if (argv.nBots || argv.nWrites) await Node.delay(startupSeconds * 1e3);
+  if (argv.nBots) {
+    const args = ['spec/bots.js', '--nBots', argv.nBots, '--baseURL', argv.baseURL, '--thrash', argv.thrash || false, '--verbose', argv.verbose || false];
+    if (argv.verbose) console.log('spawning node', args.join(' '));
+    const bots = spawn('node', args, {shell: process.platform === 'win32'});
+    // Slice off the trailing newline of data so that we don't have blank lines after our console adds one more.
+    function echo(data) { data = data.slice(0, -1); console.log(data.toString()); }
+    bots.stdout.on('data', echo);
+    bots.stderr.on('data', echo);
+    if (argv.nWrites) {
+      console.log(new Date(), 'Waiting a refresh interval while', argv.nBots, 'bots get randomly created before write/read test.');
+      await Node.delay(2 * Node.refreshTimeIntervalMS);
+    }
+  }
+  if (argv.nWrites) launchWriteRead(argv.nWrites, argv.baseURL, argv.nBots ? 2 * Node.refreshTimeIntervalMS : 0, argv.verbose);
+
+} else { // A portal node through which client's can connect.
+  const portalNode = await import('../portals/node.js');
+  const {baseURL, externalBaseURL, fixedSpacing, variableSpacing, verbose} = argv;
+  portalNode.setup({baseURL, externalBaseURL, fixedSpacing, variableSpacing, verbose});
+}

package/spec/support/jasmine.mjs

@@ -0,0 +1,14 @@
+export default {
+  spec_dir: "spec",
+  spec_files: [
+    "**/*[sS]pec.?(m)js"
+  ],
+  helpers: [
+    "helpers/**/*.?(m)js"
+  ],
+  env: {
+    stopSpecOnExpectationFailure: false,
+    random: true,
+    forbidDuplicateNames: true
+  }
+}

package/spec/writes.js

@@ -0,0 +1,11 @@
+import process from 'node:process';
+import { spawn } from 'node:child_process'; // For optionally spawning bots.js
+
+export function launchWriteRead(nWrites, baseURL, waitBeforeRead, verbose = false) {
+  const args = ['jasmine', 'spec/dhtWriteRead.js', '--', '--nWrites', nWrites, '--baseURL', baseURL, '--waitBeforeRead', waitBeforeRead, '--verbose', verbose];
+  const bots = spawn('npx', args, {shell: process.platform === 'win32'});
+  console.log(new Date(), 'spawning npx', args.join(' '));
+  function echo(data) { data = data.slice(0, -1); console.log(data.toString()); }
+  bots.stdout.on('data', echo);
+  bots.stderr.on('data', echo);
+}