threadwire 0.1.11 → 0.1.12

package/src/isolated-runtime-client.js

@@ -1,10 +1,9 @@
 // @ts-nocheck
 /* eslint-disable jsdoc/require-jsdoc */
 
-import {deadlineAfter, abortable, readResponseCapped} from "./absolute-deadline.js"
+import {AbsoluteDeadline, deadlineAfter, abortable, readResponseCapped} from "./absolute-deadline.js"
 
 const MAX_RESPONSE_BYTES = 2_097_152
-const DEFAULT_TIMEOUT_MS = 3_660_000
 const MAX_RAW_OUTPUT_BYTES = 1_048_576
 
 export class IsolatedRuntimeClient {
@@ -13,18 +12,27 @@ export class IsolatedRuntimeClient {
     this.url = normalizedUrl(options.url)
     this.controlToken = nonempty(options.controlToken, "isolated runtime control token")
     this.fetch = options.fetchImplementation ?? fetch
-    this.timeoutMs = positiveDuration(options.timeoutMs, DEFAULT_TIMEOUT_MS)
+    this.timeoutMs = optionalDuration(options.timeoutMs)
   }
 
   /**
-   * @param {{provider: string, profile: string, repositoryRoot: string, cwd: string, providerArguments: string[], resumeSession?: string, signal?: AbortSignal, deadline?: import("./absolute-deadline.js").AbsoluteDeadline}} request
+   * @param {{provider: string, profile: string, repositoryRoot?: string, cwd?: string, binding?: unknown, providerArguments: string[], resumeSession?: string, signal?: AbortSignal, deadline?: import("./absolute-deadline.js").AbsoluteDeadline}} request
    * @returns {Promise<{preflightId: string, deadline?: import("./absolute-deadline.js").AbsoluteDeadline}>}
    */
   async preflight(request) {
-    const deadline = request.deadline ?? deadlineAfter(this.timeoutMs, {signal: request.signal, timeoutMessage: "Isolated runtime launch timeout"})
-    const response = await this.request("/preflight", {...request, launchDeadlineAt: deadline.expiresAt}, deadline)
-    if (response.ok !== true || typeof response.preflightId !== "string") throw new Error("Isolated runtime preflight failed")
-    return {preflightId: response.preflightId, deadline}
+    const deadline = request.deadline ?? (this.timeoutMs === undefined ? undefined : deadlineAfter(this.timeoutMs, {signal: request.signal, timeoutMessage: "Isolated runtime launch timeout"}))
+    const operation = deadline ?? new AbsoluteDeadline(undefined, {signal: request.signal, timeoutMessage: "Isolated runtime launch timeout"})
+    const body = {...request}
+    delete body.signal
+    delete body.deadline
+    if (deadline !== undefined) body.launchDeadlineAt = deadline.expiresAt
+    try {
+      const response = await this.request("/preflight", body, operation)
+      if (response.ok !== true || typeof response.preflightId !== "string") throw new Error("Isolated runtime preflight failed")
+      return deadline === undefined ? {preflightId: response.preflightId} : {preflightId: response.preflightId, deadline}
+    } finally {
+      if (deadline === undefined) operation.close()
+    }
   }
 
   /**
@@ -33,44 +41,42 @@ export class IsolatedRuntimeClient {
    *   resumeSession?: string,
    *   signal?: AbortSignal,
    *   deadline?: import("./absolute-deadline.js").AbsoluteDeadline,
-   *   onEvent: (event: import("./types.js").WorkerEvent) => void | Promise<void>,
-   *   onRecord?: (record: unknown) => void | Promise<void>,
-   *   onStdoutChunk?: (chunk: Buffer) => void | Promise<void>,
-   *   onStderrChunk?: (chunk: Buffer) => void | Promise<void>
+   *   onEvent: (event: import("./types.js").WorkerEvent) => unknown | Promise<unknown>,
+   *   onRecord?: (record: unknown) => unknown | Promise<unknown>,
+   *   onStdoutChunk?: (chunk: Buffer) => unknown | Promise<unknown>,
+   *   onStderrChunk?: (chunk: Buffer) => unknown | Promise<unknown>
    * }} options
+   * @returns {Promise<number>}
    */
   async run(options) {
-    const deadline = options.deadline ?? deadlineAfter(this.timeoutMs, {signal: options.signal, timeoutMessage: "Isolated runtime launch timeout"})
-    const response = await this.request("/run", {
-      preflightId: options.preflightId,
-      prompt: options.prompt,
-      providerArguments: options.providerArguments,
-      ...(options.resumeSession === undefined ? {} : {resumeSession: options.resumeSession})
-    }, deadline)
-    if (!Array.isArray(response.records) || !Array.isArray(response.rawChunks) || !Number.isSafeInteger(response.exitCode)) throw new Error("Isolated runtime emitted an invalid response")
-    let rawBytes = 0
-    const decoded = response.rawChunks.map((item) => {
-      if (!isRecord(item) || Object.keys(item).sort().join(",") !== "channel,data"
-        || (item.channel !== "stdout" && item.channel !== "stderr") || typeof item.data !== "string"
-        || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u.test(item.data)) {
-        throw new Error("Isolated runtime emitted an invalid response")
+    const deadline = options.deadline ?? (this.timeoutMs === undefined ? undefined : deadlineAfter(this.timeoutMs, {signal: options.signal, timeoutMessage: "Isolated runtime launch timeout"}))
+    const operation = deadline ?? new AbsoluteDeadline(undefined, {signal: options.signal, timeoutMessage: "Isolated runtime launch timeout"})
+    try {
+      const response = await abortable(this.fetch(`${this.url}/run`, {
+        method: "POST",
+        redirect: "error",
+        headers: {
+          authorization: `Bearer ${this.controlToken}`,
+          "content-type": "application/json",
+          connection: "close",
+          ...(operation.expiresAt === undefined ? {} : {"x-threadwire-launch-deadline": String(operation.expiresAt)})
+        },
+        body: JSON.stringify({
+          preflightId: options.preflightId,
+          prompt: options.prompt,
+          providerArguments: options.providerArguments,
+          ...(options.resumeSession === undefined ? {} : {resumeSession: options.resumeSession})
+        }),
+        signal: operation.signal
+      }), operation.signal)
+      if (!response.ok) {
+        const bytes = await readResponseCapped(response, MAX_RESPONSE_BYTES, operation.signal)
+        throw new Error(safeRemoteError(bytes))
       }
-      const data = Buffer.from(item.data, "base64")
-      rawBytes += data.length
-      if (rawBytes > MAX_RAW_OUTPUT_BYTES) throw new Error("Isolated runtime emitted an invalid response")
-      return {channel: item.channel, data}
-    })
-    for (const chunk of decoded) {
-      deadline.throwIfAborted()
-      const callback = chunk.channel === "stdout" ? options.onStdoutChunk : options.onStderrChunk
-      await abortable(callback?.(chunk.data), deadline.signal)
+      return await consumeRunStream(response, options, operation)
+    } finally {
+      if (options.deadline === undefined) operation.close()
     }
-    for (const record of response.records) {
-      deadline.throwIfAborted()
-      await abortable(options.onRecord?.(record), deadline.signal)
-      if (isWorkerEventEnvelope(record)) await abortable(options.onEvent(record.event), deadline.signal)
-    }
-    return /** @type {number} */ (response.exitCode)
   }
 
   /** @param {string} path @param {unknown} body */
@@ -83,7 +89,7 @@ export class IsolatedRuntimeClient {
         authorization: `Bearer ${this.controlToken}`,
         "content-type": "application/json",
         connection: "close",
-        "x-threadwire-launch-deadline": String(deadline.expiresAt)
+        ...(deadline.expiresAt === undefined ? {} : {"x-threadwire-launch-deadline": String(deadline.expiresAt)})
       },
       body: JSON.stringify(body),
       signal
@@ -106,8 +112,74 @@ export class IsolatedRuntimeClient {
   }
 }
 
-function positiveDuration(value, fallback) {
-  if (value === undefined) return fallback
+/** @returns {Promise<number>} */
+async function consumeRunStream(response, options, operation) {
+  const reader = response.body?.getReader()
+  if (reader === undefined) throw new Error("Isolated runtime emitted an invalid response")
+  let pending = Buffer.alloc(0)
+  let totalBytes = 0
+  let rawBytes = 0
+  /** @type {number | undefined} */
+  let terminal
+  const consume = async (line) => {
+    if (line.length === 0 || terminal !== undefined) throw new Error("Isolated runtime emitted an invalid response")
+    let frame
+    try { frame = JSON.parse(line.toString("utf8")) } catch { throw new Error("Isolated runtime emitted an invalid response") }
+    if (!isRecord(frame) || typeof frame.type !== "string") throw new Error("Isolated runtime emitted an invalid response")
+    if (frame.type === "chunk") {
+      if (Object.keys(frame).sort().join(",") !== "channel,data,type"
+        || (frame.channel !== "stdout" && frame.channel !== "stderr") || typeof frame.data !== "string"
+        || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u.test(frame.data)) {
+        throw new Error("Isolated runtime emitted an invalid response")
+      }
+      const data = Buffer.from(frame.data, "base64")
+      rawBytes += data.length
+      if (rawBytes > MAX_RAW_OUTPUT_BYTES) throw new Error("Isolated runtime emitted an invalid response")
+      const callback = frame.channel === "stdout" ? options.onStdoutChunk : options.onStderrChunk
+      await abortable(callback?.(data), operation.signal)
+      return
+    }
+    if (frame.type === "record") {
+      if (Object.keys(frame).sort().join(",") !== "record,type") throw new Error("Isolated runtime emitted an invalid response")
+      await abortable(options.onRecord?.(frame.record), operation.signal)
+      if (isWorkerEventEnvelope(frame.record)) await abortable(options.onEvent(frame.record.event), operation.signal)
+      return
+    }
+    if (frame.type === "terminal" && Object.keys(frame).sort().join(",") === "exitCode,type" && Number.isSafeInteger(frame.exitCode)) {
+      terminal = frame.exitCode
+      return
+    }
+    throw new Error("Isolated runtime emitted an invalid response")
+  }
+  try {
+    while (true) {
+      const {done, value} = await abortable(reader.read(), operation.signal)
+      if (done) break
+      const chunk = Buffer.from(value)
+      totalBytes += chunk.length
+      if (totalBytes > MAX_RESPONSE_BYTES) {
+        await reader.cancel(new Error("Response exceeded capacity")).catch(() => {})
+        throw new Error("Isolated runtime response exceeded the configured capacity")
+      }
+      pending = Buffer.concat([pending, chunk])
+      while (true) {
+        const newline = pending.indexOf(0x0a)
+        if (newline < 0) break
+        const line = pending.subarray(0, newline)
+        pending = pending.subarray(newline + 1)
+        await consume(line)
+      }
+    }
+    if (pending.length !== 0 || terminal === undefined) throw new Error("Isolated runtime emitted an invalid response")
+    return terminal
+  } finally {
+    if (operation.signal.aborted) await reader.cancel(operation.signal.reason).catch(() => {})
+    reader.releaseLock()
+  }
+}
+
+function optionalDuration(value) {
+  if (value === undefined || (typeof value === "string" && value.trim().length === 0)) return undefined
   const number = Number(value)
   if (!Number.isSafeInteger(number) || number < 1 || number > 604_800_000) throw new Error("Invalid isolated runtime client timeout")
   return number