socketduct 0.1.18 → 0.1.20

package/test/unit/reverse/disconnect-attribution.test.js

@@ -0,0 +1,82 @@
+import assert from "node:assert/strict"
+import {createHmac} from "node:crypto"
+import test from "node:test"
+
+import {
+  attachDisconnectAttribution,
+  connectionFingerprint,
+  createDisconnectAttribution,
+  parseDisconnectAttribution,
+  sanitizePeerControlDetail
+} from "../../../src/reverse/disconnect-attribution.js"
+
+test("disconnect attribution uses one bounded incident and named generations", () => {
+  const attribution = createDisconnectAttribution({
+    disconnectReason: "remote_socket_error",
+    incidentOrigin: "reverse_hub",
+    physicalRole: "gateway",
+    clientConnectionGeneration: 17,
+    gatewayConnectionGeneration: 23,
+    fanOutCount: 5,
+    resumeSuccessCount: 2,
+    terminalStreamCount: 1
+  })
+
+  assert.match(attribution.disconnectIncidentId, /^[A-Za-z0-9_-]{22}$/)
+  assert.deepEqual(parseDisconnectAttribution(attribution), attribution)
+  assert.equal("generation" in attribution, false)
+
+  const error = /** @type {Error & Record<string, unknown>} */ (attachDisconnectAttribution(Object.assign(new Error("classified terminal"), {code: "GATEWAY_DISCONNECTED"}), attribution))
+  assert.equal(error.code, "GATEWAY_DISCONNECTED")
+  assert.equal(error.disconnectReason, "remote_socket_error")
+  assert.equal(error.disconnectIncidentId, attribution.disconnectIncidentId)
+  assert.equal(error.gatewayConnectionGeneration, 23)
+})
+
+test("peer control detail cannot assert hub-owned disconnect fields", () => {
+  const result = sanitizePeerControlDetail({
+    code: "TARGET_CLOSED",
+    disconnectIncidentId: "AAAAAAAAAAAAAAAAAAAAAA",
+    disconnectReason: "hub_shutdown",
+    incidentOrigin: "reverse_hub",
+    physicalRole: "gateway",
+    gatewayConnectionGeneration: 9,
+    fanOutCount: 4,
+    target: "docker.internal:2375",
+    token: "secret"
+  })
+
+  assert.deepEqual(result.detail, {code: "TARGET_CLOSED"})
+  assert.equal(result.reservedFieldsStripped, 6)
+})
+
+test("hub connection fingerprints are keyed, role-separated, and truncated to 128 bits", () => {
+  const key = Buffer.alloc(32, 0x5a)
+  const connectionId = "low_entropy_connection_01"
+  const expected = createHmac("sha256", key)
+    .update("socketduct-connection-id:v1")
+    .update(Buffer.from([0]))
+    .update("gateway")
+    .update(Buffer.from([0]))
+    .update(connectionId)
+    .digest()
+    .subarray(0, 16)
+    .toString("hex")
+
+  const actual = connectionFingerprint(key, "gateway", connectionId)
+  assert.equal(actual, expected)
+  assert.match(actual, /^[a-f0-9]{32}$/)
+  assert.notEqual(actual, connectionId)
+  assert.notEqual(actual, connectionFingerprint(key, "client", connectionId))
+  assert.throws(() => connectionFingerprint(Buffer.alloc(31), "gateway", connectionId), /at least 32 bytes/)
+})
+
+test("malformed attribution is rejected instead of partially trusted", () => {
+  assert.equal(parseDisconnectAttribution({
+    disconnectIncidentId: "AAAAAAAAAAAAAAAAAAAAAA",
+    disconnectReason: "not-a-reason",
+    incidentOrigin: "reverse_hub",
+    physicalRole: "gateway",
+    gatewayConnectionGeneration: 1
+  }), undefined)
+})

package/test/unit/spool/spool-file.test.js

@@ -191,6 +191,139 @@ test("SessionSpool synchronously rejects expired durable recovery state", async
   })
 })
 
+test("SessionSpool loadChunksSync restores only unacknowledged owned chunks", async () => {
+  await withTempDir(async (root) => {
+    const sessionId = "session_recovery_chunks"
+    const spool = new SessionSpool({rootDir: root, maxBytes: 16})
+    await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
+    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("old")})
+    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 6, data: Buffer.from("new")})
+
+    const chunks = spool.loadChunksSync(sessionId, "reverse-client-v3", 3, 6)
+
+    assert.deepEqual(chunks.map((chunk) => chunk.sequence), [6])
+    assert.equal(chunks[0]?.data.toString(), "new")
+    assert.equal(spool.getUsedBytes(sessionId), 3)
+    assert.throws(
+      () => spool.loadChunksSync(sessionId, "other-owner", 3, 6),
+      /Invalid Socketduct recovery chunks/
+    )
+  })
+})
+
+test("SessionSpool recovery repairs interruption after chunk append before usage update", async () => {
+  await withTempDir(async (root) => {
+    const sessionId = "session_append_interruption"
+    const spool = new SessionSpool({rootDir: root, maxBytes: 16})
+    await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
+    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("one")})
+    const chunksPath = join(root, sessionId, "chunks.jsonl")
+    const committed = await readFile(chunksPath, "utf8")
+    await writeFile(chunksPath, `${committed}${JSON.stringify({sequence: 6, dataBase64: Buffer.from("two").toString("base64")})}\n`)
+
+    const chunks = spool.loadChunksSync(sessionId, "reverse-client-v3", 0, 3)
+
+    assert.deepEqual(chunks.map((chunk) => chunk.sequence), [3])
+    assert.equal(await readFile(chunksPath, "utf8"), committed)
+    assert.deepEqual(JSON.parse(await readFile(join(root, sessionId, "usage.json"), "utf8")), {totalBytes: 3})
+    assert.equal((await stat(chunksPath)).mode & 0o777, 0o600)
+    assert.equal((await stat(join(root, sessionId, "usage.json"))).mode & 0o777, 0o600)
+  })
+})
+
+test("SessionSpool recovery repairs interruption after usage update before recovery commit", async () => {
+  await withTempDir(async (root) => {
+    const sessionId = "session_usage_interruption"
+    const spool = new SessionSpool({rootDir: root, maxBytes: 16})
+    await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
+    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("one")})
+    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 6, data: Buffer.from("two")})
+
+    const chunks = spool.loadChunksSync(sessionId, "reverse-client-v3", 0, 3)
+
+    assert.deepEqual(chunks.map((chunk) => chunk.sequence), [3])
+    assert.deepEqual(JSON.parse(await readFile(join(root, sessionId, "usage.json"), "utf8")), {totalBytes: 3})
+  })
+})
+
+test("SessionSpool recovery repairs interruption after acknowledged chunk truncation", async () => {
+  await withTempDir(async (root) => {
+    const sessionId = "session_truncate_interruption"
+    const spool = new SessionSpool({rootDir: root, maxBytes: 16})
+    await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
+    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("one")})
+    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 6, data: Buffer.from("two")})
+    const chunksPath = join(root, sessionId, "chunks.jsonl")
+    await writeFile(chunksPath, `${JSON.stringify({sequence: 6, dataBase64: Buffer.from("two").toString("base64")})}\n`)
+
+    const chunks = spool.loadChunksSync(sessionId, "reverse-client-v3", 3, 6)
+
+    assert.deepEqual(chunks.map((chunk) => chunk.sequence), [6])
+    assert.deepEqual(JSON.parse(await readFile(join(root, sessionId, "usage.json"), "utf8")), {totalBytes: 3})
+  })
+})
+
+test("SessionSpool recovery repairs a partial trailing JSONL record after committed chunks", async () => {
+  await withTempDir(async (root) => {
+    const sessionId = "session_partial_interruption"
+    const spool = new SessionSpool({rootDir: root, maxBytes: 16})
+    await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
+    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("one")})
+    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 6, data: Buffer.from("two")})
+    const chunksPath = join(root, sessionId, "chunks.jsonl")
+    const committed = await readFile(chunksPath, "utf8")
+    await writeFile(chunksPath, `${committed}{"sequence":9,"dataBase64":"thr`)
+
+    const chunks = spool.loadChunksSync(sessionId, "reverse-client-v3", 0, 6)
+
+    assert.deepEqual(chunks.map((chunk) => chunk.sequence), [3, 6])
+    assert.equal(await readFile(chunksPath, "utf8"), committed)
+  })
+})
+
+test("SessionSpool recovery rejects corruption before or outside a partial uncommitted tail", async () => {
+  await withTempDir(async (root) => {
+    const sessionId = "session_committed_corruption"
+    const spool = new SessionSpool({rootDir: root, maxBytes: 16})
+    await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
+    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("one")})
+    const chunksPath = join(root, sessionId, "chunks.jsonl")
+    await writeFile(chunksPath, `${await readFile(chunksPath, "utf8")}{"sequence":6,"dataBase64":"tw`)
+
+    assert.throws(
+      () => spool.loadChunksSync(sessionId, "reverse-client-v3", 0, 6),
+      /Invalid Socketduct recovery chunks/
+    )
+  })
+
+  await withTempDir(async (root) => {
+    const sessionId = "session_tail_corruption"
+    const spool = new SessionSpool({rootDir: root, maxBytes: 16})
+    await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
+    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("one")})
+    const chunksPath = join(root, sessionId, "chunks.jsonl")
+    await writeFile(chunksPath, `${await readFile(chunksPath, "utf8")}{not-json}\n`)
+
+    assert.throws(
+      () => spool.loadChunksSync(sessionId, "reverse-client-v3", 0, 3),
+      /Invalid Socketduct recovery chunks/
+    )
+  })
+
+  await withTempDir(async (root) => {
+    const sessionId = "session_usage_corruption"
+    const spool = new SessionSpool({rootDir: root, maxBytes: 16})
+    await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
+    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("one")})
+    await writeFile(join(root, sessionId, "usage.json"), "{not-json\n")
+
+    assert.throws(
+      () => spool.loadChunksSync(sessionId, "reverse-client-v3", 0, 3),
+      /Invalid Socketduct recovery chunks/
+    )
+  })
+})
+
 test("SessionSpool cleans expired abandoned entries so their stable IDs can be reused", async () => {
   await withTempDir(async (root) => {
     let now = 1_000_000