threadwire 0.1.6 → 0.1.9

package/src/kimi-oauth-store.js

@@ -0,0 +1,267 @@
+// @ts-check
+
+import {randomBytes} from "node:crypto"
+import {constants} from "node:fs"
+import {chmod, lstat, open, rename, unlink} from "node:fs/promises"
+import {dirname, isAbsolute, join} from "node:path"
+
+const MAX_CREDENTIAL_BYTES = 65_536
+const MAX_TOKEN_BYTES = 8_192
+const CLIENT_ID = "17e5f671-d194-4dfb-9706-5516cb48c098"
+const TOKEN_URL = "https://auth.kimi.com/api/oauth/token"
+const EXACT_KEYS = ["access_token", "expires_at", "expires_in", "refresh_token", "scope", "token_type"]
+
+/** @typedef {{access_token: string, expires_at: number, expires_in: number, refresh_token: string, scope: string, token_type: "Bearer"}} KimiCredential */
+
+/**
+ * @param {{
+ *   file: string,
+ *   expectedUid?: number,
+ *   now?: () => number,
+ *   fetchImplementation?: typeof fetch,
+ *   maxRefreshAttempts?: number,
+ *   sleep?: (milliseconds: number) => Promise<void>,
+ *   durabilityObserver?: (phase: string) => void | Promise<void>
+ * }} options
+ */
+export async function openKimiOAuthStore(options) {
+  if (!isAbsolute(options.file) || options.file.includes("\0")) throw unavailable()
+  const expectedUid = options.expectedUid ?? process.getuid?.() ?? -1
+  if (!Number.isSafeInteger(expectedUid) || expectedUid < 0) throw unavailable()
+  const now = options.now ?? (() => Math.floor(Date.now() / 1000))
+  const fetchImplementation = options.fetchImplementation ?? fetch
+  const maxRefreshAttempts = options.maxRefreshAttempts ?? 3
+  if (!Number.isSafeInteger(maxRefreshAttempts) || maxRefreshAttempts < 1 || maxRefreshAttempts > 3) throw unavailable()
+  const sleep = options.sleep ?? ((milliseconds) => new Promise((resolve) => {
+    const timer = setTimeout(resolve, milliseconds)
+    timer.unref()
+  }))
+  let credential = await readCredential(options.file, expectedUid)
+  /** @type {Promise<string> | undefined} */
+  let refreshInFlight
+
+  /** @param {AbortSignal | undefined} signal */
+  const refresh = async (signal) => {
+    if (credential.access_token.length === 0 || credential.refresh_token.length === 0) throw needsLogin()
+    /** @type {unknown} */
+    let lastFailure
+    for (let attempt = 0; attempt < maxRefreshAttempts; attempt++) {
+      if (signal?.aborted) throw signal.reason
+      let response
+      try {
+        const signals = [AbortSignal.timeout(30_000)]
+        if (signal !== undefined) signals.push(signal)
+        response = await fetchImplementation(TOKEN_URL, {
+          method: "POST",
+          redirect: "error",
+          headers: {accept: "application/json", "content-type": "application/x-www-form-urlencoded"},
+          body: new URLSearchParams({
+            client_id: CLIENT_ID,
+            grant_type: "refresh_token",
+            refresh_token: credential.refresh_token
+          }).toString(),
+          signal: AbortSignal.any(signals)
+        })
+      } catch (error) {
+        if (signal?.aborted) throw signal.reason
+        lastFailure = error
+        if (attempt + 1 < maxRefreshAttempts) { await sleep(2 ** attempt * 100); continue }
+        throw refreshUnavailable(lastFailure)
+      }
+      const bytes = await readCappedResponse(response, signal).catch((error) => {
+        lastFailure = error
+        return undefined
+      })
+      if (bytes === undefined) {
+        if (attempt + 1 < maxRefreshAttempts) { await sleep(2 ** attempt * 100); continue }
+        throw refreshUnavailable(lastFailure)
+      }
+      /** @type {Record<string, unknown>} */
+      let body = {}
+      try {
+        const parsed = JSON.parse(bytes.toString("utf8"))
+        if (record(parsed)) body = parsed
+      } catch { /* Invalid response bodies remain untrusted. */ }
+      if (response.status === 401 || response.status === 403 || body.error === "invalid_grant") {
+        credential = {
+          access_token: "", refresh_token: "", expires_at: 0,
+          scope: credential.scope, token_type: credential.token_type, expires_in: 0
+        }
+        await persistCredential(options.file, expectedUid, credential, options.durabilityObserver)
+        throw needsLogin()
+      }
+      if (response.ok) {
+        const replacement = tokenResponse(body, credential, now())
+        await persistCredential(options.file, expectedUid, replacement, options.durabilityObserver)
+        credential = replacement
+        return credential.access_token
+      }
+      if (![429, 500, 502, 503, 504].includes(response.status) || attempt + 1 >= maxRefreshAttempts) {
+        throw refreshUnavailable()
+      }
+      await sleep(2 ** attempt * 100)
+    }
+    throw refreshUnavailable(lastFailure)
+  }
+
+  return {
+    /** @param {{signal?: AbortSignal, force?: boolean}} [request] */
+    async getAccessToken(request = {}) {
+      if (credential.access_token.length === 0) throw needsLogin()
+      const threshold = Math.max(300, credential.expires_in * 0.5)
+      if (request.force !== true && credential.expires_at - now() > threshold) return credential.access_token
+      if (refreshInFlight !== undefined) return refreshInFlight
+      const operation = refresh(request.signal).finally(() => {
+        if (refreshInFlight === operation) refreshInFlight = undefined
+      })
+      refreshInFlight = operation
+      return operation
+    },
+    async health() {
+      return credential.access_token.length === 0
+        ? {ready: false, needsLogin: true}
+        : {ready: true, needsLogin: false}
+    }
+  }
+}
+
+/** @param {string} file @param {number} expectedUid @returns {Promise<KimiCredential>} */
+async function readCredential(file, expectedUid) {
+  const directory = dirname(file)
+  try {
+    const parent = await lstat(directory, {bigint: true})
+    if (!parent.isDirectory() || parent.isSymbolicLink() || parent.uid !== BigInt(expectedUid)
+      || (parent.mode & 0o077n) !== 0n) throw unavailable()
+    let handle
+    try {
+      handle = await open(file, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK)
+      const metadata = await handle.stat({bigint: true})
+      if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.nlink !== 1n
+        || metadata.uid !== BigInt(expectedUid) || (metadata.mode & 0o777n) !== 0o600n
+        || metadata.size < 1n || metadata.size > BigInt(MAX_CREDENTIAL_BYTES)) throw unavailable()
+      const bytes = await handle.readFile()
+      return parseCredential(bytes)
+    } finally { await handle?.close().catch(() => {}) }
+  } catch (error) {
+    if (error instanceof Error && error.message === unavailable().message) throw error
+    throw unavailable()
+  }
+}
+
+/** @param {Buffer} bytes @returns {KimiCredential} */
+function parseCredential(bytes) {
+  /** @type {unknown} */
+  let value
+  try { value = JSON.parse(bytes.toString("utf8")) } catch { throw unavailable() }
+  if (!record(value) || !exactKeys(value, EXACT_KEYS)
+    || !safeToken(value.access_token, true) || !safeToken(value.refresh_token, true)
+    || typeof value.expires_at !== "number" || !Number.isSafeInteger(value.expires_at) || value.expires_at < 0
+    || typeof value.expires_in !== "number" || !Number.isSafeInteger(value.expires_in) || value.expires_in < 0
+    || typeof value.scope !== "string" || value.scope.length > 2048 || /[\0\r\n]/u.test(value.scope)
+    || value.token_type !== "Bearer") throw unavailable()
+  const tombstone = value.access_token === "" && value.refresh_token === ""
+    && value.expires_at === 0 && value.expires_in === 0
+  if (!tombstone && (value.access_token === "" || value.refresh_token === ""
+    || value.expires_at < 1 || value.expires_in < 1)) throw unavailable()
+  return /** @type {KimiCredential} */ (value)
+}
+
+/** @param {unknown} value @param {KimiCredential} previous @param {number} currentTime @returns {KimiCredential} */
+function tokenResponse(value, previous, currentTime) {
+  if (!record(value) || !safeToken(value.access_token, false) || !safeToken(value.refresh_token, false)
+    || !Number.isFinite(Number(value.expires_in)) || Number(value.expires_in) <= 0) throw refreshUnavailable()
+  const expiresIn = Number(value.expires_in)
+  if (!Number.isSafeInteger(expiresIn) || expiresIn > 604_800) throw refreshUnavailable()
+  const scope = value.scope === undefined ? previous.scope : value.scope
+  const tokenType = value.token_type === undefined ? "Bearer" : value.token_type
+  if (typeof scope !== "string" || scope.length > 2048 || /[\0\r\n]/u.test(scope) || tokenType !== "Bearer") {
+    throw refreshUnavailable()
+  }
+  return {
+    access_token: value.access_token,
+    refresh_token: value.refresh_token,
+    expires_at: currentTime + expiresIn,
+    scope,
+    token_type: "Bearer",
+    expires_in: expiresIn
+  }
+}
+
+/** @param {string} file @param {number} expectedUid @param {KimiCredential} credential @param {((phase: string) => void | Promise<void>) | undefined} observer */
+async function persistCredential(file, expectedUid, credential, observer) {
+  const directory = dirname(file)
+  const temporary = join(directory, `.kimi-code.json.tmp.${randomBytes(12).toString("hex")}`)
+  let handle
+  try {
+    handle = await open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600)
+    await handle.writeFile(`${JSON.stringify(credential)}\n`)
+    await observer?.("before-file-sync")
+    await handle.sync()
+    await observer?.("after-file-sync")
+    await handle.close()
+    handle = undefined
+    await chmod(temporary, 0o600)
+    const metadata = await lstat(temporary, {bigint: true})
+    if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.nlink !== 1n
+      || metadata.uid !== BigInt(expectedUid) || (metadata.mode & 0o777n) !== 0o600n) throw unavailable()
+    await observer?.("before-rename")
+    await rename(temporary, file)
+    await observer?.("after-rename")
+    const parent = await open(directory, constants.O_RDONLY | constants.O_DIRECTORY)
+    try {
+      await observer?.("before-directory-sync")
+      await parent.sync()
+      await observer?.("after-directory-sync")
+    } finally { await parent.close() }
+  } catch (error) {
+    await handle?.close().catch(() => {})
+    await unlink(temporary).catch(() => {})
+    if (error instanceof Error && [needsLogin().message, refreshUnavailable().message].includes(error.message)) throw error
+    // Persistence errors may contain credential material or private paths; do not retain them as a cause.
+    // eslint-disable-next-line preserve-caught-error
+    throw new Error("Kimi OAuth credential persistence failed")
+  }
+}
+
+/** @param {Response} response @param {AbortSignal | undefined} signal @returns {Promise<Buffer>} */
+async function readCappedResponse(response, signal) {
+  if (response.body === null) return Buffer.alloc(0)
+  const reader = response.body.getReader()
+  /** @type {Buffer[]} */
+  const chunks = []
+  let size = 0
+  try {
+    while (true) {
+      if (signal?.aborted) throw signal.reason
+      const {done, value} = await reader.read()
+      if (done) break
+      size += value.byteLength
+      if (size > MAX_CREDENTIAL_BYTES) throw refreshUnavailable()
+      chunks.push(Buffer.from(value))
+    }
+  } catch (error) {
+    await reader.cancel().catch(() => {})
+    throw error
+  } finally { reader.releaseLock() }
+  return Buffer.concat(chunks)
+}
+
+/** @param {unknown} value @param {boolean} allowEmpty @returns {value is string} */
+function safeToken(value, allowEmpty) {
+  return typeof value === "string" && (allowEmpty || value.length > 0)
+    && value.length <= MAX_TOKEN_BYTES && !/[\0\r\n]/u.test(value)
+}
+/** @param {Record<string, unknown>} value @param {readonly string[]} expected @returns {boolean} */
+function exactKeys(value, expected) {
+  const actual = Object.keys(value).sort()
+  const wanted = [...expected].sort()
+  return actual.length === wanted.length && actual.every((key, index) => key === wanted[index])
+}
+/** @param {unknown} value @returns {value is Record<string, unknown>} */
+function record(value) { return typeof value === "object" && value !== null && !Array.isArray(value) }
+/** @returns {Error} */
+function unavailable() { return new Error("Kimi OAuth credential file is unavailable") }
+/** @returns {Error} */
+function needsLogin() { return new Error("Kimi OAuth credential was rejected; re-login required") }
+/** @param {unknown} [cause] @returns {Error} */
+function refreshUnavailable(cause) { return new Error("Kimi OAuth refresh is unavailable", cause === undefined ? undefined : {cause}) }

package/src/model-broker-policy.js

@@ -0,0 +1,139 @@
+// @ts-check
+
+import {randomBytes} from "node:crypto"
+
+const TOKEN_PATTERN = /^[A-Za-z0-9_-]{32,128}$/u
+const NETWORK_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/u
+const RUN_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/u
+const ALLOWED_HEADERS = new Set([
+  "authorization", "content-length", "content-type", "user-agent", "accept",
+  "accept-encoding", "accept-language", "sec-fetch-mode",
+  "x-stainless-arch", "x-stainless-lang", "x-stainless-os",
+  "x-stainless-package-version", "x-stainless-runtime",
+  "x-stainless-runtime-version", "x-stainless-retry-count", "x-stainless-timeout",
+  "x-stainless-async", "originator", "conversation_id", "session_id",
+  "version", "x-codex-turn-metadata"
+])
+
+/** @param {{now?: () => number, random?: (bytes: number) => Buffer}} [options] */
+export function createGrantStore(options = {}) {
+  const now = options.now ?? Date.now
+  const random = options.random ?? randomBytes
+  /** @type {Map<string, {runId: string, provider: "codex", networkId: string, model: string, expiresAt: number, active: boolean}>} */
+  const grants = new Map()
+  return {
+    /** @param {{runId: string, provider: "codex", networkId: string, model: string, ttlMs: number}} grant */
+    issue(grant) {
+      if (!RUN_PATTERN.test(grant.runId) || !NETWORK_PATTERN.test(grant.networkId)) throw new Error("Invalid broker grant")
+      if (grant.provider !== "codex") throw new Error("Invalid broker grant")
+      if (typeof grant.model !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u.test(grant.model)) throw new Error("Invalid broker grant")
+      if (!Number.isSafeInteger(grant.ttlMs) || grant.ttlMs < 1 || grant.ttlMs > 3_600_000) throw new Error("Invalid broker grant")
+      const token = random(32).toString("base64url")
+      grants.set(token, {...grant, expiresAt: now() + grant.ttlMs, active: false})
+      return token
+    },
+    /** @param {string} token */
+    activate(token) {
+      const grant = grants.get(token)
+      if (!grant) throw new Error("Broker grant unknown token")
+      if (grant.expiresAt < now()) {
+        grants.delete(token)
+        throw new Error("Broker grant expired")
+      }
+      if (grant.active) throw new Error("Broker grant already active")
+      grant.active = true
+      return {...grant}
+    },
+    /** @param {string} token @param {{provider: string, networkId: string, runId?: string}} context */
+    authorize(token, context) {
+      const grant = grants.get(token)
+      if (!grant) throw new Error("Broker grant unknown token")
+      if (grant.provider !== context.provider || grant.networkId !== context.networkId || (context.runId !== undefined && grant.runId !== context.runId)) throw new Error("Broker grant lineage denied")
+      if (!grant.active) throw new Error("Broker grant pending")
+      if (grant.expiresAt < now()) {
+        grants.delete(token)
+        throw new Error("Broker grant expired")
+      }
+      return {...grant}
+    },
+    /** @param {string} token */
+    revoke(token) {
+      grants.delete(token)
+    },
+    clear() {
+      grants.clear()
+    }
+  }
+}
+
+/**
+ * @param {{method?: string, path?: string, headers?: Record<string, string | string[] | undefined>}} request
+ */
+export function validateBrokerRequest(request) {
+  if (request.method !== "POST" || request.path !== "/v1/responses") throw new Error("Broker request denied")
+  for (const header of Object.keys(request.headers ?? {})) {
+    if (!ALLOWED_HEADERS.has(header.toLowerCase())) throw new Error(`Broker request denied header: ${header.toLowerCase()}`)
+  }
+  return {method: "POST", path: "/v1/responses"}
+}
+
+const RESPONSE_KEYS = new Set([
+  "model", "input", "instructions", "stream", "tools", "tool_choice",
+  "parallel_tool_calls", "previous_response_id", "reasoning", "store",
+  "include", "metadata", "max_output_tokens", "temperature", "top_p", "truncation",
+  "prompt_cache_key"
+])
+
+/** @param {Buffer} body @param {string} allowedModel */
+export function validateResponsesBody(body, allowedModel) {
+  const text = body.toString("utf8")
+  if (topLevelKeyCount(text, "model") !== 1) throw new Error("Broker request denied")
+  let value
+  try {
+    value = JSON.parse(text)
+  } catch {
+    throw new Error("Broker request denied")
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("Broker request denied")
+  const unexpected = Object.keys(value).find((key) => !RESPONSE_KEYS.has(key))
+  if (unexpected !== undefined) throw new Error(`Broker request denied field: ${unexpected}`)
+  if (value.model !== allowedModel || !("input" in value)) throw new Error("Broker request denied")
+  return value
+}
+
+/** @param {string} text @param {string} wanted */
+function topLevelKeyCount(text, wanted) {
+  let depth = 0
+  let count = 0
+  let index = 0
+  while (index < text.length) {
+    const character = text[index]
+    if (character === "\"") {
+      let string = ""
+      index += 1
+      while (index < text.length && text[index] !== "\"") {
+        if (text[index] === "\\") {
+          index += 2
+          continue
+        }
+        string += text[index]
+        index += 1
+      }
+      if (depth === 1) {
+        let next = index + 1
+        while (/\s/u.test(text[next] ?? "")) next += 1
+        if (text[next] === ":" && string === wanted) count += 1
+      }
+    } else if (character === "{") depth += 1
+    else if (character === "}") depth -= 1
+    index += 1
+  }
+  return count
+}
+
+/** @param {string | undefined} authorization */
+export function bearerToken(authorization) {
+  const match = /^Bearer ([A-Za-z0-9_-]{32,128})$/u.exec(authorization ?? "")
+  if (!match || !TOKEN_PATTERN.test(match[1] ?? "")) throw new Error("Broker grant format denied")
+  return /** @type {string} */ (match[1])
+}