dsh-grok-provider 0.1.0

package/dist/internal/grok-transport.mjs

@@ -0,0 +1,279 @@
+const BASE_URL = "https://cli-chat-proxy.grok.com"
+const MAX_JSON_RESPONSE_BYTES = 256 * 1024
+const MAX_REQUEST_BYTES = 16 * 1024 * 1024
+const DEFAULT_MODEL_TIMEOUT_MS = 30 * 1000
+const DEFAULT_BILLING_TIMEOUT_MS = 15 * 1000
+const DEFAULT_RESPONSE_TIMEOUT_MS = 10 * 60 * 1000
+const MAX_TIMER_DELAY_MS = 2_147_483_647
+
+export class GrokTransportError extends Error {
+  constructor(status) {
+    super("The Grok Build transport request failed")
+    this.name = "GrokTransportError"
+    if (status !== undefined) this.status = status
+  }
+}
+
+export function createGrokTransport({
+  credentialSource,
+  fetch,
+  attributionHeaders,
+  clientIdentifier,
+  clientVersion,
+  modelTimeoutMs = DEFAULT_MODEL_TIMEOUT_MS,
+  billingTimeoutMs = DEFAULT_BILLING_TIMEOUT_MS,
+  responseTimeoutMs = DEFAULT_RESPONSE_TIMEOUT_MS,
+}) {
+  if (
+    !credentialSource ||
+    typeof credentialSource.withAccessToken !== "function" ||
+    typeof fetch !== "function" ||
+    typeof attributionHeaders !== "function" ||
+    !isHeaderValue(clientIdentifier) ||
+    !isHeaderValue(clientVersion) ||
+    !isTimeout(modelTimeoutMs) ||
+    !isTimeout(billingTimeoutMs) ||
+    !isTimeout(responseTimeoutMs)
+  ) {
+    throw new TypeError("Invalid Grok transport dependencies")
+  }
+
+  return Object.freeze({
+    async getBilling({ signal } = {}) {
+      const deadline = createDeadline(signal, billingTimeoutMs)
+      try {
+        return await credentialSource.withAccessToken(async (accessToken, metadata) => {
+          if (!isPlainObject(metadata) || !isHeaderValue(metadata.userId)) throw new GrokTransportError()
+          let response
+          try {
+            const headers = buildHeaders({ accessToken, attributionHeaders, clientIdentifier, clientVersion })
+            headers.set("x-userid", metadata.userId)
+            response = await fetch(`${BASE_URL}/v1/billing?format=credits`, {
+              method: "GET",
+              redirect: "error",
+              headers,
+              signal: deadline.signal,
+            })
+            validateJsonResponse(response)
+            if (response.status !== 200) throw new GrokTransportError(response.status)
+            return await readBoundedText(response, MAX_JSON_RESPONSE_BYTES)
+          } catch (error) {
+            if (error instanceof GrokTransportError) throw error
+            if (signal?.aborted && error?.name === "AbortError") throw error
+            throw new GrokTransportError()
+          } finally {
+            response = undefined
+            metadata = undefined
+            accessToken = undefined
+          }
+        })
+      } finally {
+        deadline.dispose()
+      }
+    },
+
+    async listModels({ signal } = {}) {
+      const deadline = createDeadline(signal, modelTimeoutMs)
+      try {
+        return await credentialSource.withAccessToken(async (accessToken) => {
+          let response
+          try {
+            response = await fetch(`${BASE_URL}/v1/models`, {
+              method: "GET",
+              redirect: "error",
+              headers: buildHeaders({
+                accessToken,
+                attributionHeaders,
+                clientIdentifier,
+                clientVersion,
+              }),
+              signal: deadline.signal,
+            })
+            validateJsonResponse(response)
+            if (response.status !== 200) throw new GrokTransportError(response.status)
+            return await readBoundedText(response, MAX_JSON_RESPONSE_BYTES)
+          } catch (error) {
+            if (error instanceof GrokTransportError) throw error
+            if (signal?.aborted && error?.name === "AbortError") throw error
+            throw new GrokTransportError()
+          } finally {
+            response = undefined
+            accessToken = undefined
+          }
+        })
+      } finally {
+        deadline.dispose()
+      }
+    },
+
+    async *streamResponses(request, { signal } = {}) {
+      if (!isPlainObject(request) || request.stream !== true || request.store !== false) {
+        throw new TypeError("Invalid Grok Responses request")
+      }
+      let body
+      try {
+        body = JSON.stringify(request)
+      } catch {
+        throw new TypeError("Invalid Grok Responses request")
+      }
+      if (Buffer.byteLength(body, "utf8") > MAX_REQUEST_BYTES) {
+        throw new TypeError("Invalid Grok Responses request")
+      }
+
+      let response
+      let source
+      const deadline = createDeadline(signal, responseTimeoutMs)
+      try {
+        response = await credentialSource.withAccessToken(async (accessToken) => {
+          const headers = buildHeaders({
+            accessToken,
+            attributionHeaders,
+            clientIdentifier,
+            clientVersion,
+          })
+          headers.set("Content-Type", "application/json")
+          return fetch(`${BASE_URL}/v1/responses`, {
+            method: "POST",
+            redirect: "error",
+            headers,
+            body,
+            signal: deadline.signal,
+          })
+        })
+        validateEventStreamResponse(response)
+        if (response.status !== 200) throw new GrokTransportError(response.status)
+        source = response.body
+        for await (const chunk of source) {
+          if (!(chunk instanceof Uint8Array)) throw new GrokTransportError(response.status)
+          yield chunk
+        }
+      } catch (error) {
+        if (error instanceof GrokTransportError) throw error
+        if (signal?.aborted && error?.name === "AbortError") throw error
+        throw new GrokTransportError()
+      } finally {
+        deadline.dispose()
+        source = undefined
+        response = undefined
+        body = undefined
+      }
+    },
+  })
+}
+
+function createDeadline(callerSignal, timeoutMs) {
+  if (callerSignal !== undefined && (
+    callerSignal === null ||
+    typeof callerSignal !== "object" ||
+    typeof callerSignal.addEventListener !== "function" ||
+    typeof callerSignal.removeEventListener !== "function" ||
+    typeof callerSignal.aborted !== "boolean"
+  )) throw new TypeError("Invalid Grok transport abort signal")
+  const controller = new AbortController()
+  const abortFromCaller = () => controller.abort(callerSignal.reason)
+  if (callerSignal?.aborted) abortFromCaller()
+  else callerSignal?.addEventListener("abort", abortFromCaller, { once: true })
+  const timer = setTimeout(() => controller.abort(new DOMException("Timed out", "TimeoutError")), timeoutMs)
+  return {
+    signal: controller.signal,
+    dispose() {
+      clearTimeout(timer)
+      callerSignal?.removeEventListener("abort", abortFromCaller)
+    },
+  }
+}
+
+function isTimeout(value) {
+  return Number.isSafeInteger(value) && value > 0 && value <= MAX_TIMER_DELAY_MS
+}
+
+function buildHeaders({ accessToken, attributionHeaders, clientIdentifier, clientVersion }) {
+  if (!isHeaderValue(accessToken)) throw new GrokTransportError()
+  const attribution = attributionHeaders()
+  if (!isPlainObject(attribution)) throw new GrokTransportError()
+
+  const headers = new Headers()
+  for (const [name, value] of Object.entries(attribution)) {
+    if (!isHeaderValue(name) || !isHeaderValue(value)) throw new GrokTransportError()
+    headers.set(name, value)
+  }
+  headers.set("Accept", "application/json")
+  headers.set("Authorization", `Bearer ${accessToken}`)
+  headers.set("X-XAI-Token-Auth", "xai-grok-cli")
+  headers.set("x-grok-client-version", clientVersion)
+  headers.set("x-grok-client-identifier", clientIdentifier)
+  return headers
+}
+
+function validateJsonResponse(response) {
+  validateResponseShape(response)
+  const contentType = response.headers.get("content-type")
+  if (typeof contentType !== "string" || !contentType.toLowerCase().startsWith("application/json")) {
+    throw new GrokTransportError(response.status)
+  }
+}
+
+function validateEventStreamResponse(response) {
+  validateResponseShape(response)
+  const contentType = response.headers.get("content-type")
+  if (typeof contentType !== "string" || !contentType.toLowerCase().startsWith("text/event-stream")) {
+    throw new GrokTransportError(response.status)
+  }
+  if (!response.body || typeof response.body[Symbol.asyncIterator] !== "function") {
+    throw new GrokTransportError(response.status)
+  }
+}
+
+function validateResponseShape(response) {
+  if (
+    response === null ||
+    typeof response !== "object" ||
+    !Number.isSafeInteger(response.status) ||
+    response.status < 100 ||
+    response.status > 599 ||
+    !response.headers ||
+    typeof response.headers.get !== "function"
+  ) {
+    throw new GrokTransportError()
+  }
+}
+
+async function readBoundedText(response, maxBytes) {
+  if (!response.body || typeof response.body.getReader !== "function") {
+    if (typeof response.text !== "function") throw new GrokTransportError(response.status)
+    const text = await response.text()
+    if (typeof text !== "string" || Buffer.byteLength(text, "utf8") > maxBytes) {
+      throw new GrokTransportError(response.status)
+    }
+    return text
+  }
+
+  const reader = response.body.getReader()
+  const decoder = new TextDecoder("utf-8", { fatal: true })
+  let byteLength = 0
+  let text = ""
+  try {
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      if (!(value instanceof Uint8Array)) throw new GrokTransportError(response.status)
+      byteLength += value.byteLength
+      if (byteLength > maxBytes) throw new GrokTransportError(response.status)
+      text += decoder.decode(value, { stream: true })
+    }
+    text += decoder.decode()
+    return text
+  } finally {
+    reader.releaseLock()
+  }
+}
+
+function isHeaderValue(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 16 * 1024 && !/[\r\n\0]/u.test(value)
+}
+
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false
+  const prototype = Object.getPrototypeOf(value)
+  return prototype === Object.prototype || prototype === null
+}

package/dist/internal/model-catalog.mjs

@@ -0,0 +1,142 @@
+const MODEL_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/
+const MAX_CATALOG_BYTES = 256 * 1024
+const MAX_MODELS = 256
+const MAX_REASONING_EFFORTS = 16
+
+export class InvalidModelCatalogError extends Error {
+  constructor() {
+    super("The Grok model catalog response is invalid or unsupported")
+    this.name = "InvalidModelCatalogError"
+  }
+}
+
+export function parseModelCatalogResponse(raw, { provider }) {
+  if (typeof raw !== "string" || Buffer.byteLength(raw, "utf8") > MAX_CATALOG_BYTES) {
+    throw new InvalidModelCatalogError()
+  }
+  if (typeof provider !== "string" || provider.length === 0) {
+    throw new TypeError("A provider id is required")
+  }
+
+  let value
+  try {
+    value = JSON.parse(raw)
+  } catch {
+    throw new InvalidModelCatalogError()
+  }
+
+  if (!isPlainObject(value) || value.object !== "list" || !Array.isArray(value.data)) {
+    throw new InvalidModelCatalogError()
+  }
+  if (value.data.length > MAX_MODELS) throw new InvalidModelCatalogError()
+
+  const seen = new Set()
+  return value.data.map((model) => {
+    const entry = parseModel(model, provider)
+    if (seen.has(entry.resolvedModelInfo.id)) throw new InvalidModelCatalogError()
+    seen.add(entry.resolvedModelInfo.id)
+    return entry
+  })
+}
+
+function parseModel(model, provider) {
+  if (
+    !isPlainObject(model) ||
+    typeof model.id !== "string" ||
+    !MODEL_ID_PATTERN.test(model.id) ||
+    typeof model.name !== "string" ||
+    model.name.length === 0 ||
+    model.name.length > 128 ||
+    (model.description !== undefined && (
+      typeof model.description !== "string" ||
+      model.description.length > 1024
+    )) ||
+    !Number.isSafeInteger(model.context_window) ||
+    model.context_window <= 0 ||
+    model.context_window > 10_000_000 ||
+    model.api_backend !== "responses"
+  ) {
+    throw new InvalidModelCatalogError()
+  }
+
+  const resolvedModelInfo = {
+    provider,
+    id: model.id,
+    name: model.name,
+    ...(model.description === undefined ? {} : { description: model.description }),
+    inputModalities: ["text"],
+    context: { contextWindow: model.context_window },
+    ...parseReasoning(model),
+  }
+
+  return {
+    backend: model.api_backend,
+    resolvedModelInfo,
+  }
+}
+
+function parseReasoning(model) {
+  if (model.supports_reasoning_effort !== true) return {}
+  if (!Array.isArray(model.reasoning_efforts)) throw new InvalidModelCatalogError()
+  if (
+    model.reasoning_efforts.length === 0 ||
+    model.reasoning_efforts.length > MAX_REASONING_EFFORTS
+  ) {
+    throw new InvalidModelCatalogError()
+  }
+
+  const seen = new Set()
+  let defaultEffort
+  const efforts = model.reasoning_efforts.map((effort) => {
+    if (
+      !isPlainObject(effort) ||
+      typeof effort.id !== "string" ||
+      !MODEL_ID_PATTERN.test(effort.id) ||
+      effort.value !== effort.id ||
+      typeof effort.label !== "string" ||
+      effort.label.length === 0 ||
+      effort.label.length > 128 ||
+      (effort.description !== undefined && (
+        typeof effort.description !== "string" ||
+        effort.description.length > 512
+      )) ||
+      typeof effort.default !== "boolean" ||
+      seen.has(effort.id)
+    ) {
+      throw new InvalidModelCatalogError()
+    }
+    seen.add(effort.id)
+    if (effort.default) {
+      if (defaultEffort !== undefined) throw new InvalidModelCatalogError()
+      defaultEffort = effort.id
+    }
+    return {
+      id: effort.id,
+      name: effort.label,
+      ...(effort.description === undefined ? {} : { description: effort.description }),
+    }
+  })
+
+  if (model.reasoning_effort !== undefined) {
+    if (typeof model.reasoning_effort !== "string" || !seen.has(model.reasoning_effort)) {
+      throw new InvalidModelCatalogError()
+    }
+    if (defaultEffort !== undefined && defaultEffort !== model.reasoning_effort) {
+      throw new InvalidModelCatalogError()
+    }
+    defaultEffort = model.reasoning_effort
+  }
+
+  return {
+    reasoning: {
+      efforts,
+      ...(defaultEffort === undefined ? {} : { defaultEffort }),
+    },
+  }
+}
+
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false
+  const prototype = Object.getPrototypeOf(value)
+  return prototype === Object.prototype || prototype === null
+}

package/dist/internal/official-auth-driver.mjs

@@ -0,0 +1,40 @@
+const OUTCOMES = new Set(["succeeded", "cancelled"])
+
+export function createOfficialAuthDriver({ officialAuth, credentialSource }) {
+  if (
+    !officialAuth ||
+    typeof officialAuth.login !== "function" ||
+    typeof officialAuth.logout !== "function" ||
+    !credentialSource ||
+    typeof credentialSource.withAccessToken !== "function"
+  ) throw new TypeError("Invalid official Grok authentication driver dependencies")
+
+  return Object.freeze({
+    async begin({ signal } = {}) {
+      return Object.freeze({
+        completion: (async () => {
+          const outcome = await officialAuth.login({ signal })
+          validateOutcome(outcome)
+          if (outcome.kind !== "succeeded") return outcome
+          await credentialSource.withAccessToken(async () => undefined)
+          return outcome
+        })(),
+      })
+    },
+
+    async logout({ signal } = {}) {
+      const outcome = await officialAuth.logout({ signal })
+      validateOutcome(outcome)
+      return outcome
+    },
+  })
+}
+
+function validateOutcome(value) {
+  if (
+    value === null ||
+    typeof value !== "object" ||
+    !OUTCOMES.has(value.kind) ||
+    Object.keys(value).length !== 1
+  ) throw new TypeError("Invalid official Grok authentication outcome")
+}

package/dist/internal/official-cli-auth.mjs

@@ -0,0 +1,231 @@
+import path from "node:path"
+
+const EXPECTED_VERSION = "grok 1.0.5 (5115b46bc909)"
+const GRACE_MS = 5_000
+const DEFAULT_VERSION_TIMEOUT_MS = 10 * 1000
+const DEFAULT_LOGIN_TIMEOUT_MS = 5 * 60 * 1000
+const DEFAULT_LOGOUT_TIMEOUT_MS = 2 * 60 * 1000
+const DEFAULT_REFRESH_TIMEOUT_MS = 30 * 1000
+const MAX_TIMER_DELAY_MS = 2_147_483_647
+
+export class OfficialCliAuthError extends Error {
+  constructor() {
+    super("The official Grok CLI login could not be completed")
+    this.name = "OfficialCliAuthError"
+  }
+}
+
+export function createOfficialCliAuth({
+  subprocess,
+  platform,
+  homeDir,
+  verifyExecutable,
+  versionTimeoutMs = DEFAULT_VERSION_TIMEOUT_MS,
+  loginTimeoutMs = DEFAULT_LOGIN_TIMEOUT_MS,
+  logoutTimeoutMs = DEFAULT_LOGOUT_TIMEOUT_MS,
+  refreshTimeoutMs = DEFAULT_REFRESH_TIMEOUT_MS,
+}) {
+  if (
+    !subprocess ||
+    typeof subprocess.resolveExecutable !== "function" ||
+    typeof subprocess.spawn !== "function" ||
+    (platform !== "darwin" && platform !== "win32") ||
+    typeof homeDir !== "string" ||
+    homeDir.length === 0 ||
+    typeof verifyExecutable !== "function" ||
+    !isTimeout(versionTimeoutMs) ||
+    !isTimeout(loginTimeoutMs) ||
+    !isTimeout(logoutTimeoutMs) ||
+    !isTimeout(refreshTimeoutMs)
+  ) {
+    throw new TypeError("Invalid official Grok CLI auth dependencies")
+  }
+
+  const pathApi = platform === "win32" ? path.win32 : path.posix
+  const grokHome = pathApi.join(homeDir, ".grok")
+  const candidate = pathApi.join(grokHome, "bin", platform === "win32" ? "grok.exe" : "grok")
+  const cliEnvironment = buildCliEnvironment(platform, homeDir)
+
+  const runAction = async (argvTail, callerSignal, timeoutMs) => {
+    let preparationDeadline = createDeadline(callerSignal, versionTimeoutMs)
+    let actionDeadline
+    let resolved
+    try {
+      resolved = await subprocess.resolveExecutable(candidate, {}, preparationDeadline.signal)
+      if (typeof resolved !== "string" || !pathApi.isAbsolute(resolved)) throw new OfficialCliAuthError()
+      await verifyExecutable({ candidate, resolved, grokHome, platform })
+
+      const version = await runCollected(subprocess, {
+        argv: [resolved, "--version"],
+        cwd: grokHome,
+        maxBytes: 4 * 1024,
+        signal: preparationDeadline.signal,
+        env: cliEnvironment,
+      })
+      if (version.stdout.trim() !== EXPECTED_VERSION || version.stderr.length !== 0) {
+        throw new OfficialCliAuthError()
+      }
+
+      preparationDeadline.dispose()
+      preparationDeadline = undefined
+      actionDeadline = createDeadline(callerSignal, timeoutMs)
+      await runCollected(subprocess, {
+        argv: [resolved, ...argvTail],
+        cwd: grokHome,
+        maxBytes: 64 * 1024,
+        signal: actionDeadline.signal,
+        env: cliEnvironment,
+      })
+      return Object.freeze({ kind: "succeeded" })
+    } catch (error) {
+      if (callerSignal?.aborted) {
+        return Object.freeze({ kind: "cancelled" })
+      }
+      if (error instanceof OfficialCliAuthError || error instanceof TypeError) throw error
+      throw new OfficialCliAuthError()
+    } finally {
+      actionDeadline?.dispose()
+      preparationDeadline?.dispose()
+      resolved = undefined
+    }
+  }
+
+  return Object.freeze({
+    login({ signal } = {}) {
+      return runAction(["login", "--oauth"], signal, loginTimeoutMs)
+    },
+    logout({ signal } = {}) {
+      return runAction(["logout"], signal, logoutTimeoutMs)
+    },
+    refresh({ signal } = {}) {
+      return runAction(["models"], signal, refreshTimeoutMs)
+    },
+  })
+}
+
+function createDeadline(callerSignal, timeoutMs) {
+  const controller = new AbortController()
+  const abortFromCaller = () => controller.abort(callerSignal.reason)
+  if (callerSignal?.aborted) abortFromCaller()
+  else callerSignal?.addEventListener("abort", abortFromCaller, { once: true })
+  const timer = setTimeout(() => controller.abort(new DOMException("Timed out", "TimeoutError")), timeoutMs)
+  return {
+    signal: controller.signal,
+    dispose() {
+      clearTimeout(timer)
+      callerSignal?.removeEventListener("abort", abortFromCaller)
+    },
+  }
+}
+
+function isTimeout(value) {
+  return Number.isSafeInteger(value) && value > 0 && value <= MAX_TIMER_DELAY_MS
+}
+
+async function runCollected(subprocess, { argv, cwd, maxBytes, signal, env }) {
+  let handle
+  let stdout
+  let stderr
+  try {
+    handle = subprocess.spawn({
+      argv,
+      cwd,
+      stdio: {
+        stdin: "ignore",
+        stdout: { maxBytes },
+        stderr: { maxBytes },
+      },
+      graceMs: GRACE_MS,
+      signal,
+      env,
+    })
+    if (!isProcessHandle(handle)) throw new OfficialCliAuthError()
+    const outcome = await handle.done
+    if (!isOutcome(outcome) || outcome.exitCode !== 0 || outcome.signal !== null) {
+      throw new OfficialCliAuthError()
+    }
+    stdout = readCollected(handle.collected.stdout)
+    stderr = readCollected(handle.collected.stderr)
+    return { stdout, stderr }
+  } finally {
+    if (handle && typeof handle.waitForExit === "function") {
+      const exited = await handle.waitForExit()
+      if (exited !== true && !signal?.aborted) throw new OfficialCliAuthError()
+    }
+    stderr = undefined
+    stdout = undefined
+    handle = undefined
+  }
+}
+
+function buildCliEnvironment(platform, homeDir) {
+  const environment = {}
+  const fixedTombstones = [
+    "BROWSER",
+    "GROK_AUTH_PROVIDER_COMMAND",
+    "GROK_CONFIG",
+    "GROK_CONFIG_PATH",
+    "GROK_HOME",
+    "NODE_EXTRA_CA_CERTS",
+    "NODE_OPTIONS",
+    "NODE_PATH",
+    "SSLKEYLOGFILE",
+    "XAI_API_KEY",
+  ]
+  for (const name of fixedTombstones) environment[name] = undefined
+  for (const name of Object.keys(process.env)) {
+    if (/^(?:GROK_|XAI_|DYLD_|LD_)/iu.test(name)) environment[name] = undefined
+  }
+
+  if (platform === "darwin") {
+    environment.HOME = homeDir
+    environment.PATH = "/usr/bin:/bin:/usr/sbin:/sbin"
+  } else {
+    const inheritedRoot = process.env.SystemRoot ?? process.env.SYSTEMROOT
+    const systemRoot = typeof inheritedRoot === "string" && path.win32.isAbsolute(inheritedRoot) &&
+      inheritedRoot.length <= 260 && !/[\r\n\0]/u.test(inheritedRoot)
+      ? path.win32.normalize(inheritedRoot)
+      : "C:\\Windows"
+    environment.USERPROFILE = homeDir
+    environment.PATH = [
+      path.win32.join(systemRoot, "System32"),
+      systemRoot,
+      path.win32.join(systemRoot, "System32", "Wbem"),
+    ].join(";")
+    environment.PATHEXT = ".COM;.EXE;.BAT;.CMD"
+    environment.COMSPEC = path.win32.join(systemRoot, "System32", "cmd.exe")
+  }
+  return Object.freeze(environment)
+}
+
+function readCollected(reader) {
+  if (!reader || typeof reader.readFrom !== "function") throw new OfficialCliAuthError()
+  const output = reader.readFrom(0)
+  if (
+    !output ||
+    typeof output.text !== "string" ||
+    output.lossy !== false ||
+    output.spillPath !== undefined
+  ) throw new OfficialCliAuthError()
+  return output.text
+}
+
+function isProcessHandle(handle) {
+  return (
+    handle !== null &&
+    typeof handle === "object" &&
+    handle.done &&
+    typeof handle.done.then === "function" &&
+    handle.collected &&
+    typeof handle.waitForExit === "function"
+  )
+}
+
+function isOutcome(outcome) {
+  return (
+    outcome !== null &&
+    typeof outcome === "object" &&
+    (Number.isSafeInteger(outcome.exitCode) || outcome.exitCode === null) &&
+    (typeof outcome.signal === "string" || outcome.signal === null)
+  )
+}