threadwire 0.1.22 → 0.1.24

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## Unreleased
 
+- Fix a race in isolated-runtime worker cleanup: Docker's ContainerStop returns
+  HTTP 304 when the owned container exits before the stop call, and
+  ContainerKill returns HTTP 409 when the container exits between the post-stop
+  reinspection and the kill call. `stopAndRemoveWorkerContainer` now recognizes
+  only the endpoint-specific structured status for each call (304 at stop, 409
+  at kill), reinspects the exact container ID, and continues with removal only
+  when the reinspection confirms a terminal state. Genuine stop/kill errors
+  still fail closed, no broad cleanup is performed, and lineage retention
+  behavior is unchanged. Add focused lifecycle tests for 304 stop, 409 kill,
+  304 kill, and genuine error paths.
+
+- Complete every short filesystem write while spooling oversized worker JSONL
+  records, preventing truncated or corrupted worker output. Reject stalled,
+  invalid, or impossible write counts and clean up the private spool artifact
+  instead of silently accepting partial data.
+
 - Fix Node 24 release-prepublish timeouts in `run-worker` process-tree cleanup.
   The dedicated `npm-release` service now runs with Docker's `init: true` so
   terminated descendants are reaped instead of becoming zombies that keep the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "threadwire",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "description": "Stream Codex, Claude, Kimi Code, and OpenCode worker progress to an explicit Telegram destination",
   "keywords": [
     "ai-agent",

package/src/docker-api.js

@@ -3,6 +3,15 @@
 
 import {request as httpRequest} from "node:http"
 
+export class DockerApiError extends Error {
+  /** @param {string} method @param {string} path @param {number} status */
+  constructor(method, path, status) {
+    super(`Docker API ${method} ${path} failed (${status})`)
+    this.name = "DockerApiError"
+    this.status = status
+  }
+}
+
 export class DockerApi {
   /** @param {{host?: string, requestImplementation?: typeof httpRequest}} [options] */
   constructor(options = {}) {
@@ -38,7 +47,7 @@ export class DockerApi {
           const content = combined.toString("utf8")
           const status = response.statusCode ?? 500
           if (status < 200 || status >= 300) {
-            reject(new Error(`Docker API ${method} ${path} failed (${status})`))
+            reject(new DockerApiError(method, path, status))
             return
           }
           if (combined.length === 0) {
@@ -135,7 +144,7 @@ export class DockerApi {
         const status = response.statusCode ?? 500
         if (status < 200 || status >= 300) {
           response.resume()
-          fail(new Error(`Docker API GET /containers/${id}/logs failed (${status})`))
+          fail(new DockerApiError("GET", `/containers/${id}/logs`, status))
           return
         }
         response.on("data", (chunk) => {

package/src/isolated-runtime.js

@@ -6,7 +6,7 @@ import {once} from "node:events"
 import {lstat, realpath} from "node:fs/promises"
 import {createServer} from "node:http"
 import {isAbsolute, join, normalize, relative} from "node:path"
-import {DockerApi} from "./docker-api.js"
+import {DockerApi, DockerApiError} from "./docker-api.js"
 import {buildKimiBindingValidatorSpec, buildKimiRelayContainerSpec, buildWorkerContainerSpec, isDigestImage} from "./isolated-worker.js"
 import {validateRelayWriteProviderArguments} from "./relay-write.js"
 import {codexSessionId, parseCodexEvent} from "./providers/codex.js"
@@ -723,11 +723,19 @@ async function stopAndRemoveWorkerContainer(docker, containerId, requestOptions)
   let inspection = await docker.inspectContainer(containerId, requestOptions)
   if (typeof inspection?.State?.Running !== "boolean") throw new Error("Worker container state unavailable")
   if (inspection.State.Running) {
-    await docker.stopContainer(containerId, WORKER_STOP_GRACE_SECONDS, requestOptions)
+    try {
+      await docker.stopContainer(containerId, WORKER_STOP_GRACE_SECONDS, requestOptions)
+    } catch (error) {
+      if (!isContainerStopAlreadyStoppedError(error)) throw error
+    }
     inspection = await docker.inspectContainer(containerId, requestOptions)
     if (typeof inspection?.State?.Running !== "boolean") throw new Error("Worker container state unavailable")
     if (inspection.State.Running) {
-      await docker.killContainer(containerId, "KILL", requestOptions)
+      try {
+        await docker.killContainer(containerId, "KILL", requestOptions)
+      } catch (error) {
+        if (!isContainerKillConflictError(error)) throw error
+      }
       inspection = await docker.inspectContainer(containerId, requestOptions)
       if (inspection?.State?.Running !== false) throw new ContainerCleanupConfirmationError()
     }
@@ -735,6 +743,14 @@ async function stopAndRemoveWorkerContainer(docker, containerId, requestOptions)
   await docker.removeContainer(containerId, requestOptions)
 }
 
+function isContainerStopAlreadyStoppedError(error) {
+  return error instanceof DockerApiError && error.status === 304
+}
+
+function isContainerKillConflictError(error) {
+  return error instanceof DockerApiError && error.status === 409
+}
+
 class ContainerCleanupConfirmationError extends Error {
   /** @param {{cause?: unknown}} [options] */
   constructor(options = {}) {

package/src/jsonl-record-spool.js

@@ -4,6 +4,14 @@ import {closeSync, mkdtempSync, openSync, readFileSync, rmSync, unlinkSync, writ
 import {tmpdir} from "node:os"
 import {isAbsolute, join, normalize} from "node:path"
 
+const filesystemOperations = {writeSync}
+
+/**
+ * @typedef {object} FilesystemOperations
+ * @property {(fileDescriptor: number, buffer: Buffer, offset: number, length: number) => number} writeSync
+ *   Write bytes to a file descriptor and return the count written.
+ */
+
 /**
  * Single-owner byte-oriented spool for one worker's pending JSONL record.
  *
@@ -21,13 +29,14 @@ import {isAbsolute, join, normalize} from "node:path"
  * owner calls it on every settlement path.
  */
 export class JsonlRecordSpool {
-  /** @param {{memoryBytes: number, maxBytes: number, directory?: string}} options */
+  /** @param {{memoryBytes: number, maxBytes: number, directory?: string, filesystem?: FilesystemOperations}} options */
   constructor(options) {
     this.memoryBytes = positiveSafeInteger(options.memoryBytes, "memoryBytes")
     this.maxBytes = positiveSafeInteger(options.maxBytes, "maxBytes")
     const directory = options.directory ?? tmpdir()
     if (!isAbsolute(directory) || normalize(directory) !== directory) throw new Error("directory must be a normalized absolute path")
     this.directory = directory
+    this.filesystem = options.filesystem ?? filesystemOperations
     /** @type {Buffer[]} */
     this.segments = []
     this.pendingBytes = 0
@@ -120,7 +129,7 @@ export class JsonlRecordSpool {
     if (this.file === null) this.append(finalSegment)
     else {
       this.pendingBytes = recordBytes
-      writeSync(this.file.fd, finalSegment)
+      this.writeAll(this.file.fd, finalSegment)
     }
     const file = this.file
     if (file === null) throw new Error("JSONL record spool file is unavailable")
@@ -137,7 +146,7 @@ export class JsonlRecordSpool {
     this.pendingBytes += segment.length
     if (this.pendingBytes > this.maxBytes) throw new StdoutRecordTooLargeError()
     if (this.file !== null) {
-      writeSync(this.file.fd, segment)
+      this.writeAll(this.file.fd, segment)
       return
     }
     if (this.pendingBytes <= this.memoryBytes) {
@@ -150,9 +159,26 @@ export class JsonlRecordSpool {
     const path = join(this.ownedDirectory, "pending-record")
     const fd = openSync(path, "wx", 0o600)
     this.file = {fd, path}
-    for (const buffered of this.segments) writeSync(fd, buffered)
+    for (const buffered of this.segments) this.writeAll(fd, buffered)
     this.segments = []
-    writeSync(fd, segment)
+    this.writeAll(fd, segment)
+  }
+
+  /**
+   * Write a complete Buffer to one file descriptor, looping over short writes.
+   * @param {number} fd
+   * @param {Buffer} buffer
+   */
+  writeAll(fd, buffer) {
+    let offset = 0
+    while (offset < buffer.length) {
+      const written = this.filesystem.writeSync(fd, buffer, offset, buffer.length - offset)
+      if (written === 0) throw new Error("Spool write made zero bytes of progress")
+      if (!Number.isSafeInteger(written) || written < 0 || written > buffer.length - offset) {
+        throw new Error(`Spool write returned invalid byte count: ${written}`)
+      }
+      offset += written
+    }
   }
 
   /** Remove the current record's private spill directory, if one exists. */