@twinsearth/w2m-dsh-plugin 0.17.0 → 0.18.0

package/CHANGELOG.md

@@ -4,6 +4,34 @@ All notable changes to this project are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project
 adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.18.0] — 2026-10-15
+
+**The whole handshake primitive set is present on both machines — so the P2P failure is not a missing algorithm.**
+
+Two candidates for `P2P_PUNCH_FAILED: Digest method not supported` have now been **measured and excluded**:
+
+| Candidate | Measurement | Verdict |
+|---|---|---|
+| BLAKE2s-256 | 32-byte digest on MacMini **and** here, on the same run that failed | **innocent** |
+| every other primitive the handshake touches | `sha256`, `chacha20-poly1305` with a real AEAD round trip, `hkdfSync('sha256')`, `x25519`+`diffieHellman`, `ed25519` — all present on both | **innocent** |
+
+The second row was answered by **one bit-encoded dispatch** that put eight questions to MacMini at once
+(`exit_code: 255`, every bit set) rather than one question per round. That technique was already in this
+repository and should have been the first move.
+
+**What this changes:** the search moves off the runtime and onto the protocol, the session state, or the
+transport. And it points somewhere specific — **`P2P_PUNCH_FAILED` is raised by the relay's own push, on the
+machine that already has every primitive it needs.** The failing handshake is not on a peer missing an
+algorithm; it is on a peer that has all of them.
+
+`cryptoCapabilities()` now answers this question in one dispatch for any machine, and its suite asserts the
+**count** — six primitives, six checks — because a capability report that silently checks four things reads as
+complete.
+
+**Honest status: the cause of `P2P_PUNCH_FAILED` remains UNVERIFIED**, and the 0 % direct share measured last
+round is unchanged. What this release buys is that two hypotheses are dead and the next one costs one
+dispatch to test.
+
 ## [0.17.0] — 2026-10-15
 
 **BLAKE2s-256 is not the cause of `P2P_PUNCH_FAILED`, and a failure that names nothing costs a probe per guess.**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@twinsearth/w2m-dsh-plugin",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "DSH: Windows2MacOS — drive the same project on online Windows and macOS machines from one DeepSeek account, across networks and regions. P2P hole punching is the default path (relay + shared server as rendezvous, ledger and fallback), with a bundled STUN responder, Tailscale/public-VPS/tunnel shapes, Rabbit relay + per-machine Localside + eight DSH tools (replicate / split), nine aggregate verdicts and signed requests.",
   "type": "module",
   "main": "lib/index.js",

package/src/agent/crypto.mjs

@@ -704,6 +704,67 @@ export function derive(ikm, label, length = KEY_BYTES) {
   return Buffer.from(hkdfSync('sha256', ikm, Buffer.alloc(0), Buffer.from(label, 'utf8'), length));
 }
 
+/**
+ * The cryptographic primitives the handshake requires, and whether this runtime has each.
+ *
+ * ## Why a capability report rather than a one-off diagnostic
+ *
+ * `P2P_PUNCH_FAILED: Digest method not supported` has been reproduced several times in production and never
+ * under instrumentation. Two candidates have now been **measured and excluded**:
+ *
+ *   * **BLAKE2s-256** — present on both MacMini and this Windows host, on the same run that reported the
+ *     failure. Ruled out by a direct 32-byte digest on each machine.
+ *   * **every other primitive the handshake touches** — `sha256`, `chacha20-poly1305` with a real AEAD
+ *     round trip, `hkdfSync('sha256')`, `x25519` with `diffieHellman`, and `ed25519` — all present on both.
+ *
+ * So the fault is **not a missing algorithm**, and knowing that is worth more than another hypothesis: it
+ * moves the search from the runtime to the protocol, the state, or the transport.
+ *
+ * The exclusion cost several dispatches because each candidate had to be probed over a channel carrying one
+ * exit code. This function means the next question of that kind is answered in **one** dispatch, by the
+ * machine itself, with no interpretation in between.
+ *
+ * @returns {{ ok: boolean, missing: string[], present: string[], node: string, detail: string }}
+ */
+export function cryptoCapabilities() {
+  const present = [];
+  const missing = [];
+  const check = (name, fn) => {
+    try {
+      if (fn()) present.push(name);
+      else missing.push(`${name} (reported as unsupported)`);
+    } catch (e) {
+      missing.push(`${name} (${e?.message ?? String(e)})`);
+    }
+  };
+
+  check('blake2s256', () => createHash('blake2s256').update('').digest().length === 32);
+  check('sha256', () => createHash('sha256').update('').digest().length === 32);
+  check('chacha20-poly1305', () => {
+    const key = randomBytes(32);
+    const cipher = createCipheriv('chacha20-poly1305', key, Buffer.alloc(12), { authTagLength: 16 });
+    cipher.update(Buffer.from('probe'));
+    cipher.final();
+    return cipher.getAuthTag().length === 16;
+  });
+  check('hkdf-sha256', () => hkdfSync('sha256', randomBytes(32), Buffer.alloc(0), Buffer.from('probe'), 32).byteLength === 32);
+  check('x25519+diffieHellman', () => {
+    const { privateKey, publicKey } = generateKeyPairSync('x25519');
+    return diffieHellman({ privateKey, publicKey }).length === 32;
+  });
+  check('ed25519', () => generateKeyPairSync('ed25519') !== null);
+
+  return {
+    ok: missing.length === 0,
+    present,
+    missing,
+    node: process.version,
+    detail: missing.length === 0
+      ? `all ${present.length} handshake primitive(s) available on ${process.version}`
+      : `${missing.length} of ${present.length + missing.length} handshake primitive(s) unavailable on ${process.version}: ${missing.join('; ')}`,
+  };
+}
+
 /**
  * How BLAKE2s-256 is reached on this runtime, discovered once and remembered.
  *

package/src/plugin/tools.mjs

@@ -185,7 +185,7 @@ const MAX_STAGES = 16;
  * `package.json` during `scripts/pack.mjs` rather than hand-maintained, and `W2M_PLUGIN_VERSION`
  * overrides it at runtime for tests and packagers.
  */
-const PLUGIN_VERSION = '0.17.0';
+const PLUGIN_VERSION = '0.18.0';
 
 /** How long any single HTTP call may take before it is aborted, in milliseconds. */
 const DEFAULT_REQUEST_TIMEOUT_MS = 15_000;