socketduct 0.1.15 → 0.1.16

package/changelog.d/20260916165820-fix-deferred-socket-callback-guard.md

@@ -0,0 +1 @@
+Fixed a crash in `DeferredVirtualSocket` where a non-function callback value (e.g. `null`) passed to `write()` or `end()` threw `selectedCallback is not a function` instead of failing gracefully.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "socketduct",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "description": "Resilient authenticated tunnel/proxy for keeping socket streams alive across flaky links.",
   "type": "module",
   "main": "./src/index.js",

package/src/client/deferred-virtual-socket.js

@@ -259,7 +259,7 @@ export class DeferredVirtualSocket extends VirtualSocket {
    */
   write(chunk, encoding, callback) {
     const selectedEncoding = typeof encoding === "string" ? encoding : undefined
-    const selectedCallback = typeof encoding === "function" ? encoding : callback
+    const selectedCallback = typeof encoding === "function" ? encoding : typeof callback === "function" ? callback : undefined
     if (typeof chunk !== "string" && !ArrayBuffer.isView(chunk)) {
       return selectedEncoding === undefined
         ? super.write(chunk, selectedCallback)
@@ -302,7 +302,7 @@ export class DeferredVirtualSocket extends VirtualSocket {
    */
   end(chunk, encoding, callback) {
     if (typeof chunk === "function") return super.end(chunk)
-    const selectedCallback = typeof encoding === "function" ? encoding : callback
+    const selectedCallback = typeof encoding === "function" ? encoding : typeof callback === "function" ? callback : undefined
     if (chunk !== undefined) {
       if (typeof encoding === "string") this.write(chunk, encoding)
       else this.write(chunk)

package/test/unit/client/deferred-virtual-socket.test.js

@@ -0,0 +1,170 @@
+/* eslint-disable jsdoc/escape-inline-tags, jsdoc/require-param-type, jsdoc/require-returns */
+import assert from "node:assert/strict"
+import test from "node:test"
+
+import {DeferredVirtualSocket} from "../../../src/client/deferred-virtual-socket.js"
+import {VirtualSocket} from "../../../src/client/virtual-socket.js"
+
+/**
+ * @param {{reserveMemoryError?: Error}} [options] - Optional rejection to inject into the byte budget.
+ * @returns {{reservedBytes: () => number, socket: import('../../../src/client/deferred-virtual-socket.js').DeferredVirtualSocket}} Deferred socket fixture with reserved-byte accounting.
+ */
+function deferredSocket(options = {}) {
+  let reservedBytes = 0
+  const socket = new DeferredVirtualSocket({host: "127.0.0.1", port: 4793}, {
+    budget: {
+      reserveMemory(bytes) {
+        if (options.reserveMemoryError) throw options.reserveMemoryError
+        reservedBytes += bytes
+      },
+      releaseMemory(bytes) {
+        reservedBytes -= bytes
+      }
+    },
+    onCancel: () => {},
+    ref: () => {},
+    unref: () => {}
+  })
+  return {reservedBytes: () => reservedBytes, socket}
+}
+
+/** Fake member connection that settles write and final callbacks on the next macrotask. */
+function memberConnection() {
+  /** @type {Buffer[]} */
+  const writes = []
+  let ended = 0
+  return {
+    connection: /** @type {import('../../../src/client/virtual-socket.js').VirtualSocketOwner} */ (/** @type {unknown} */ ({
+      /**
+       * @param {number} _id @param {Buffer} data @param {(error?: Error | null) => void} callback
+       * @param data
+       * @param callback
+       */
+      _writeStream: (_id, data, callback) => {
+        writes.push(data)
+        setImmediate(callback)
+      },
+      /**
+       * @param {number} _id @param {(error?: Error | null) => void} callback
+       * @param callback
+       */
+      _endStream: (_id, callback) => {
+        ended += 1
+        callback()
+      },
+      _destroyStream: () => {},
+      _resumeReadable: () => {},
+      physicalAddress: () => ({address: "127.0.0.1", port: 43210}),
+      ref: () => {},
+      unref: () => {}
+    })),
+    ended: () => ended,
+    writes
+  }
+}
+
+test("DeferredVirtualSocket write ignores non-function callback values in both parameter slots", async () => {
+  const first = deferredSocket()
+  // @ts-expect-error Deliberate non-function callback value; the socket must ignore it.
+  assert.equal(first.socket.write("hello", null), true)
+  const closed = new Promise((resolve) => first.socket.once("close", resolve))
+  first.socket.destroy()
+  await closed
+  assert.equal(first.socket.destroyed, true)
+
+  const second = deferredSocket()
+  // @ts-expect-error Deliberate non-function callback value; the socket must ignore it.
+  assert.equal(second.socket.write("hello", "utf8", null), true)
+  const closedAgain = new Promise((resolve) => second.socket.once("close", resolve))
+  assert.doesNotThrow(() => second.socket.destroy())
+  await closedAgain
+  assert.equal(second.socket.destroyed, true)
+})
+
+test("DeferredVirtualSocket write budget failure destroys the socket without crashing on non-function callback values", async () => {
+  const failure = new Error("budget exhausted")
+  const {socket} = deferredSocket({reserveMemoryError: failure})
+  const error = new Promise((resolve) => socket.once("error", resolve))
+  // @ts-expect-error Deliberate non-function callback value; the socket must ignore it.
+  assert.equal(socket.write("hello", "utf8", null), false)
+  assert.equal(await error, failure)
+  assert.equal(socket.destroyed, true)
+})
+
+test("DeferredVirtualSocket write budget failure invokes the completion callback with the failure", async () => {
+  const failure = new Error("budget exhausted")
+  const {reservedBytes, socket} = deferredSocket({reserveMemoryError: failure})
+  /** @type {Error | null | undefined} */
+  let callbackError
+  const error = new Promise((resolve) => socket.once("error", resolve))
+  assert.equal(socket.write("hello", "utf8", (received) => {
+    callbackError = received
+  }), false)
+  await error
+  assert.equal(callbackError, failure)
+  assert.equal(reservedBytes(), 0)
+  assert.equal(socket.destroyed, true)
+})
+
+test("DeferredVirtualSocket write completion after member assignment ignores non-function callback values", async () => {
+  const {socket} = deferredSocket()
+  const member = memberConnection()
+  socket.assign(new VirtualSocket(member.connection, 1, {host: "127.0.0.1", port: 4793}), "gateway-1")
+  // @ts-expect-error Deliberate non-function callback value; the socket must ignore it.
+  assert.equal(socket.write("hello", "utf8", null), true)
+  await new Promise((resolve) => setImmediate(resolve))
+  const written = member.writes[0]
+  assert(written !== undefined)
+  assert.equal(written.toString(), "hello")
+})
+
+test("DeferredVirtualSocket end ignores non-function callback values in both parameter slots", async () => {
+  const first = deferredSocket()
+  assert.doesNotThrow(() => {
+    // @ts-expect-error Deliberate non-function callback value; the socket must ignore it.
+    first.socket.end("hello", null)
+  })
+  assert.equal(first.socket.writableEnded, true)
+  const closed = new Promise((resolve) => first.socket.once("close", resolve))
+  first.socket.destroy()
+  await closed
+  assert.equal(first.socket.destroyed, true)
+
+  const second = deferredSocket()
+  assert.doesNotThrow(() => {
+    // @ts-expect-error Deliberate non-function callback value; the socket must ignore it.
+    second.socket.end("hello", "utf8", null)
+  })
+  assert.equal(second.socket.writableEnded, true)
+  const closedAgain = new Promise((resolve) => second.socket.once("close", resolve))
+  second.socket.destroy()
+  await closedAgain
+  assert.equal(second.socket.destroyed, true)
+})
+
+test("DeferredVirtualSocket end does not forward non-function callback values to the stream", async () => {
+  const {socket} = deferredSocket()
+  assert.doesNotThrow(() => {
+    // @ts-expect-error Deliberate non-function callback value; the socket must ignore it.
+    socket.end("hello", "utf8", 42)
+  })
+  assert.equal(socket.writableEnded, true)
+  const closed = new Promise((resolve) => socket.once("close", resolve))
+  socket.destroy()
+  await closed
+})
+
+test("DeferredVirtualSocket end completion after member assignment invokes the callback on finish", async () => {
+  const {socket} = deferredSocket()
+  const member = memberConnection()
+  socket.assign(new VirtualSocket(member.connection, 1, {host: "127.0.0.1", port: 4793}), "gateway-1")
+  let finishedCallback = false
+  const finished = new Promise((resolve) => socket.once("finish", resolve))
+  socket.end("hello", "utf8", () => {
+    finishedCallback = true
+  })
+  await finished
+  assert.equal(finishedCallback, true)
+  assert.equal(socket.writableFinished, true)
+  assert.equal(member.ended(), 1)
+})

package/test/unit/config/docker-gateway-files.test.js

@@ -41,7 +41,9 @@ test("TensorBuzz exclusively owns verification and container build validation",
   assert.match(tensorbuzz, /privileged: true/)
   assert.match(tensorbuzz, /docker build --tag socketduct-ci \./)
   assert.doesNotMatch(tensorbuzz, /docker (?:login|push)/)
-  assert.equal(packageMetadata.private, true)
+  // release-patch refuses to publish a package marked "private": true, so the
+  // published UNLICENSED npm release requires the flag to be absent or false.
+  assert.notEqual(packageMetadata.private, true)
   assert.equal(packageMetadata.license, "UNLICENSED")
 })