threadwire 0.1.6 → 0.1.9

package/src/isolated-runtime-client.js

@@ -0,0 +1,158 @@
+// @ts-nocheck
+/* eslint-disable jsdoc/require-jsdoc */
+
+import {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 {
+  /** @param {{url: string, controlToken: string, timeoutMs?: number | string, fetchImplementation?: typeof fetch}} options */
+  constructor(options) {
+    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)
+  }
+
+  /**
+   * @param {{provider: string, profile: string, repositoryRoot: string, cwd: string, 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}
+  }
+
+  /**
+   * @param {{
+   *   preflightId: string, prompt: string, providerArguments: string[],
+   *   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>
+   * }} options
+   */
+  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 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)
+    }
+    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 */
+  async request(path, body, deadline) {
+    const signal = deadline.signal
+    const response = await abortable(this.fetch(`${this.url}${path}`, {
+      method: "POST",
+      redirect: "error",
+      headers: {
+        authorization: `Bearer ${this.controlToken}`,
+        "content-type": "application/json",
+        connection: "close",
+        "x-threadwire-launch-deadline": String(deadline.expiresAt)
+      },
+      body: JSON.stringify(body),
+      signal
+    }), signal)
+    let bytes
+    try {
+      bytes = await readResponseCapped(response, MAX_RESPONSE_BYTES, signal)
+    } catch (error) {
+      if (error instanceof Error && error.message === "Response exceeded capacity") throw new Error("Isolated runtime response exceeded the configured capacity", {cause: error})
+      throw error
+    }
+    if (!response.ok) throw new Error(safeRemoteError(bytes))
+    try {
+      const value = JSON.parse(bytes.toString("utf8"))
+      if (!isRecord(value)) throw new Error()
+      return value
+    } catch {
+      throw new Error("Isolated runtime emitted an invalid response")
+    }
+  }
+}
+
+function positiveDuration(value, fallback) {
+  if (value === undefined) return fallback
+  const number = Number(value)
+  if (!Number.isSafeInteger(number) || number < 1 || number > 604_800_000) throw new Error("Invalid isolated runtime client timeout")
+  return number
+}
+/** @param {NodeJS.ProcessEnv} environment */
+export function isolatedRuntimeClientFromEnvironment(environment) {
+  return new IsolatedRuntimeClient({
+    url: nonempty(environment.THREADWIRE_ISOLATED_RUNTIME_URL, "THREADWIRE_ISOLATED_RUNTIME_URL"),
+    controlToken: nonempty(environment.THREADWIRE_ISOLATED_RUNTIME_CONTROL_TOKEN, "THREADWIRE_ISOLATED_RUNTIME_CONTROL_TOKEN"),
+    timeoutMs: environment.THREADWIRE_ISOLATED_RUNTIME_CLIENT_TIMEOUT_MS
+  })
+}
+
+/** @param {NodeJS.ProcessEnv} environment */
+export function kimiIsolatedRuntimeClientFromEnvironment(environment) {
+  return new IsolatedRuntimeClient({
+    url: nonempty(environment.THREADWIRE_KIMI_ISOLATED_RUNTIME_URL, "THREADWIRE_KIMI_ISOLATED_RUNTIME_URL"),
+    controlToken: nonempty(environment.THREADWIRE_KIMI_ISOLATED_RUNTIME_CONTROL_TOKEN, "THREADWIRE_KIMI_ISOLATED_RUNTIME_CONTROL_TOKEN"),
+    timeoutMs: environment.THREADWIRE_ISOLATED_RUNTIME_CLIENT_TIMEOUT_MS
+  })
+}
+
+function normalizedUrl(value) {
+  const url = new URL(value)
+  if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error("THREADWIRE_ISOLATED_RUNTIME_URL must use HTTP or HTTPS")
+  url.pathname = url.pathname.replace(/\/+$/u, "")
+  url.search = ""
+  url.hash = ""
+  return url.toString().replace(/\/$/u, "")
+}
+
+function nonempty(value, name) {
+  if (typeof value !== "string" || value.trim().length === 0 || /[\r\n]/u.test(value)) throw new Error(`${name} is required`)
+  return value
+}
+
+function safeRemoteError(bytes) {
+  const text = bytes.toString("utf8").trim()
+  return /^[\x20-\x7e]{1,200}$/u.test(text) ? text : "Isolated runtime request failed"
+}
+
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+function isWorkerEventEnvelope(value) {
+  return isRecord(value) && value.type === "worker-event" && isRecord(value.event)
+}