threadwire 0.1.8 → 0.1.9

package/src/kimi-model-broker.js

@@ -0,0 +1,325 @@
+// @ts-check
+
+import {createServer} from "node:http"
+import {once} from "node:events"
+import {abortable} from "./absolute-deadline.js"
+import {
+  createKimiGrantStore,
+  kimiBearerToken,
+  parseApprovedKimiModels,
+  validateKimiBrokerRequest,
+  validateKimiChatBody
+} from "./kimi-model-broker-policy.js"
+import {openKimiOAuthStore} from "./kimi-oauth-store.js"
+
+const MAX_REQUEST_BYTES = 2_097_152
+const MAX_RESPONSE_BYTES = 8_388_608
+const UPSTREAM_URL = "https://api.kimi.com/coding/v1/chat/completions"
+
+/** @typedef {{provider: "kimi", runId: string, networkId: string, taskId: string, sessionId: string, modelAlias: string, model: string, ttlMs: number}} KimiGrant */
+/** @typedef {{alias: string, model: string, protocol: "kimi"}} ApprovedKimiModel */
+/** @typedef {ReturnType<typeof createKimiGrantStore>} KimiGrantStore */
+/** @typedef {Awaited<ReturnType<typeof openKimiOAuthStore>>} KimiOAuthStore */
+
+/** @param {{environment?: NodeJS.ProcessEnv, fetchImplementation?: typeof fetch, oauthFetchImplementation?: typeof fetch}} [options] */
+export async function startKimiModelBroker(options = {}) {
+  const environment = options.environment ?? process.env
+  const host = safeHost(environment.THREADWIRE_KIMI_MODEL_BROKER_HOST ?? "0.0.0.0")
+  const port = portValue(environment.THREADWIRE_KIMI_MODEL_BROKER_PORT, 8791)
+  const adminToken = authoritySetting(environment.THREADWIRE_KIMI_MODEL_BROKER_ADMIN_TOKEN, "THREADWIRE_KIMI_MODEL_BROKER_ADMIN_TOKEN")
+  const approvedModels = parseApprovedKimiModels(environment.THREADWIRE_ALLOWED_KIMI_MODELS)
+  const oauth = await openKimiOAuthStore({
+    file: safeSetting(environment.THREADWIRE_KIMI_OAUTH_FILE, "THREADWIRE_KIMI_OAUTH_FILE"),
+    fetchImplementation: options.oauthFetchImplementation ?? fetch
+  })
+  const fetchImplementation = options.fetchImplementation ?? fetch
+  const grants = createKimiGrantStore()
+  /** @type {Map<string, import("node:http").Server>} */
+  const listeners = new Map()
+  /** @type {Map<string, {controller: AbortController, timer: NodeJS.Timeout, sockets: Set<import("node:net").Socket>}>} */
+  const runtimes = new Map()
+  /** @type {Set<import("node:net").Socket>} */
+  const controlSockets = new Set()
+  let stopping = false
+
+  /** @param {string} token */
+  const revokeGrant = async (token) => {
+    grants.revoke(token)
+    const runtime = runtimes.get(token)
+    runtimes.delete(token)
+    if (runtime !== undefined) {
+      clearTimeout(runtime.timer)
+      runtime.controller.abort(new Error("Kimi broker grant revoked"))
+      for (const socket of runtime.sockets) socket.destroy()
+      runtime.sockets.clear()
+    }
+    await closeListener(listeners, token)
+  }
+
+  const server = createServer(async (request, response) => {
+    try {
+      if (stopping) throw new Error("Kimi model broker is shutting down")
+      if (request.method === "GET" && request.url === "/healthz") {
+        const health = await oauth.health()
+        sendJson(response, health.ready ? 200 : 503, health.ready
+          ? {ok: true, models: approvedModels.size}
+          : {ok: false, needsLogin: true})
+        return
+      }
+      requireAdmin(request.headers.authorization, adminToken)
+      if (request.method === "POST" && request.url === "/admin/grants") {
+        const health = await oauth.health()
+        if (!health.ready) throw new Error("Kimi OAuth login required")
+        const body = await readJson(request)
+        const selection = parseGrant(body, approvedModels)
+        const token = grants.issue(selection.grant)
+        const controller = new AbortController()
+        /** @type {Set<import("node:net").Socket>} */
+        const sockets = new Set()
+        const listener = createServer((workerRequest, workerResponse) => {
+          proxyWorkerRequest(workerRequest, workerResponse, {
+            token, grant: selection.grant, grants, oauth, fetchImplementation, signal: controller.signal
+          }).catch((error) => {
+            if (workerResponse.destroyed) return
+            const status = clientError(error) ? 403 : 502
+            sendJson(workerResponse, status, {error: status === 403 ? "request denied" : "Kimi model broker unavailable"})
+          })
+        })
+        listener.on("connection", (socket) => {
+          if (controller.signal.aborted) return socket.destroy()
+          sockets.add(socket)
+          socket.once("close", () => sockets.delete(socket))
+        })
+        try { await listen(listener, 0, selection.brokerAddress) } catch (error) {
+          grants.revoke(token)
+          throw error
+        }
+        listeners.set(token, listener)
+        const timer = setTimeout(() => { void revokeGrant(token) }, selection.grant.ttlMs)
+        timer.unref()
+        runtimes.set(token, {controller, timer, sockets})
+        const address = listener.address()
+        if (address === null || typeof address === "string") throw new Error("Kimi broker listener unavailable")
+        sendJson(response, 201, {token, port: address.port})
+        return
+      }
+      if (request.method === "POST" && request.url?.startsWith("/admin/grants/") && request.url.endsWith("/activate")) {
+        const token = decodeURIComponent(request.url.slice("/admin/grants/".length, -"/activate".length))
+        grants.activate(token)
+        sendJson(response, 200, {ok: true})
+        return
+      }
+      if (request.method === "DELETE" && request.url?.startsWith("/admin/grants/")) {
+        const token = decodeURIComponent(request.url.slice("/admin/grants/".length))
+        await revokeGrant(token)
+        response.writeHead(204)
+        response.end()
+        return
+      }
+      sendJson(response, 403, {error: "request denied"})
+    } catch (error) {
+      const status = clientError(error) ? 403 : 503
+      sendJson(response, status, {error: status === 403 ? "request denied" : "Kimi model broker unavailable"})
+    }
+  })
+  server.on("connection", (socket) => {
+    controlSockets.add(socket)
+    socket.once("close", () => controlSockets.delete(socket))
+  })
+  await listen(server, port, host)
+  return {
+    server,
+    activeListeners: () => listeners.size,
+    close: async () => {
+      if (stopping) return
+      stopping = true
+      for (const socket of controlSockets) socket.destroy()
+      await Promise.all([...listeners.keys()].map(revokeGrant))
+      await boundedClose(server)
+    },
+    config: {host, port, models: [...approvedModels.keys()]}
+  }
+}
+
+/**
+ * @param {import("node:http").IncomingMessage} request
+ * @param {import("node:http").ServerResponse} response
+ * @param {{token: string, grant: KimiGrant, grants: KimiGrantStore, oauth: KimiOAuthStore, fetchImplementation: typeof fetch, signal: AbortSignal}} options
+ */
+async function proxyWorkerRequest(request, response, options) {
+  throwIfAborted(options.signal)
+  const policyHeaders = {...request.headers}
+  delete policyHeaders.host
+  delete policyHeaders.connection
+  delete policyHeaders["transfer-encoding"]
+  validateKimiBrokerRequest({method: request.method ?? "", path: request.url ?? "", headers: policyHeaders})
+  const token = kimiBearerToken(request.headers.authorization)
+  if (token !== options.token) throw new Error("Kimi broker request denied")
+  const context = {
+    provider: "kimi", runId: options.grant.runId,
+    networkId: options.grant.networkId, taskId: options.grant.taskId,
+    sessionId: options.grant.sessionId, modelAlias: options.grant.modelAlias
+  }
+  const grant = options.grants.authorize(token, context)
+  const body = await readBody(request, options.signal)
+  options.grants.authorize(token, context)
+  validateKimiChatBody(body, grant.model)
+  const accessToken = await options.oauth.getAccessToken({signal: options.signal})
+  throwIfAborted(options.signal)
+  const upstream = await abortable(options.fetchImplementation(UPSTREAM_URL, {
+    method: "POST",
+    redirect: "error",
+    headers: {
+      authorization: `Bearer ${accessToken}`,
+      "content-type": "application/json",
+      accept: "text/event-stream",
+      "user-agent": "threadwire-kimi-model-broker/1"
+    },
+    body,
+    signal: options.signal
+  }), options.signal)
+  throwIfAborted(options.signal)
+  const contentType = safeContentType(upstream.headers.get("content-type"))
+  response.writeHead(upstream.status, {"content-type": contentType, "cache-control": "no-store"})
+  await streamResponse(upstream, response, options.signal)
+}
+
+/** @param {Response} upstream @param {import("node:http").ServerResponse} response @param {AbortSignal} signal */
+async function streamResponse(upstream, response, signal) {
+  if (upstream.body === null) { response.end(); return }
+  const reader = upstream.body.getReader()
+  let bytes = 0
+  try {
+    while (true) {
+      throwIfAborted(signal)
+      const {done, value} = await reader.read()
+      if (done) break
+      bytes += value.byteLength
+      if (bytes > MAX_RESPONSE_BYTES) throw new Error("Kimi broker response exceeded capacity")
+      if (!response.write(Buffer.from(value))) await abortable(once(response, "drain"), signal)
+    }
+    response.end()
+  } catch (error) {
+    await reader.cancel().catch(() => {})
+    response.destroy(error instanceof Error ? error : undefined)
+    throw error
+  } finally { reader.releaseLock() }
+}
+
+/** @param {unknown} value @param {Map<string, ApprovedKimiModel>} approvedModels @returns {{brokerAddress: string, grant: KimiGrant}} */
+function parseGrant(value, approvedModels) {
+  if (!record(value) || !exactKeys(value, ["brokerAddress", "modelAlias", "networkId", "provider", "runId", "sessionId", "taskId", "ttlMs"])
+    || value.provider !== "kimi" || typeof value.runId !== "string" || typeof value.networkId !== "string"
+    || typeof value.taskId !== "string" || typeof value.sessionId !== "string"
+    || typeof value.modelAlias !== "string" || typeof value.brokerAddress !== "string" || typeof value.ttlMs !== "number") {
+    throw new Error("Invalid Kimi broker grant")
+  }
+  if (!/^(?:\d{1,3}\.){3}\d{1,3}$/u.test(value.brokerAddress)) throw new Error("Invalid Kimi broker grant")
+  const model = approvedModels.get(value.modelAlias)
+  if (model === undefined) throw new Error("Kimi model is not allowed")
+  return {
+    brokerAddress: value.brokerAddress,
+    grant: {
+      provider: "kimi", runId: value.runId, networkId: value.networkId,
+      taskId: value.taskId, sessionId: value.sessionId,
+      modelAlias: model.alias, model: model.model, ttlMs: value.ttlMs
+    }
+  }
+}
+
+/** @param {import("node:http").IncomingMessage} request @returns {Promise<unknown>} */
+async function readJson(request) {
+  const body = await readBody(request)
+  try { return JSON.parse(body.toString("utf8")) } catch { throw new Error("Invalid Kimi broker request") }
+}
+
+/** @param {import("node:http").IncomingMessage} request @param {AbortSignal | undefined} [signal] @returns {Promise<Buffer>} */
+async function readBody(request, signal) {
+  /** @type {Buffer[]} */
+  const chunks = []
+  let size = 0
+  for await (const chunk of request) {
+    throwIfAborted(signal)
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)
+    size += buffer.length
+    if (size > MAX_REQUEST_BYTES) throw new Error("Kimi broker request exceeded capacity")
+    chunks.push(buffer)
+  }
+  throwIfAborted(signal)
+  return Buffer.concat(chunks)
+}
+
+/** @param {AbortSignal | undefined} signal */
+function throwIfAborted(signal) {
+  if (signal?.aborted) throw signal.reason instanceof Error ? signal.reason : new Error("Kimi broker request aborted")
+}
+/** @param {string | undefined} value @param {string} expected */
+function requireAdmin(value, expected) {
+  if (value !== `Bearer ${expected}`) throw new Error("Kimi broker request denied")
+}
+/** @param {string | undefined} value @param {string} name @returns {string} */
+function safeSetting(value, name) {
+  if (typeof value !== "string" || value.length === 0 || /[\0\r\n]/u.test(value)) throw new Error(`${name} is required`)
+  return value
+}
+/** @param {string | undefined} value @param {string} name @returns {string} */
+function authoritySetting(value, name) {
+  const authority = safeSetting(value, name)
+  if (authority.length < 32 || authority.length > 512) throw new Error(`${name} must be at least 32 characters`)
+  return authority
+}
+/** @param {string} value @returns {string} */
+function safeHost(value) {
+  if (value !== "0.0.0.0" && value !== "127.0.0.1" && value !== "::") throw new Error("Invalid Kimi model broker host")
+  return value
+}
+/** @param {string | undefined} value @param {number} fallback @returns {number} */
+function portValue(value, fallback) {
+  if (value === undefined) return fallback
+  const number = Number(value)
+  if (!/^\d+$/u.test(value) || !Number.isSafeInteger(number) || number < 1 || number > 65535) throw new Error("Invalid Kimi model broker port")
+  return number
+}
+/** @param {string | null} value @returns {string} */
+function safeContentType(value) {
+  return value && /^[\w.+-]+\/[\w.+-]+(?:;\s*charset=[\w-]+)?$/u.test(value) ? value : "application/octet-stream"
+}
+/** @param {import("node:http").ServerResponse} response @param {number} status @param {unknown} value */
+function sendJson(response, status, value) {
+  if (response.headersSent || response.destroyed) return
+  response.writeHead(status, {"content-type": "application/json", "cache-control": "no-store"})
+  response.end(JSON.stringify(value))
+}
+/** @param {unknown} error @returns {boolean} */
+function clientError(error) {
+  return error instanceof Error && /(denied|invalid|unknown token|expired|pending|already active|not allowed)/iu.test(error.message)
+}
+/** @param {unknown} value @returns {value is Record<string, unknown>} */
+function record(value) { return typeof value === "object" && value !== null && !Array.isArray(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 {import("node:http").Server} server @param {number} port @param {string} host @returns {Promise<void>} */
+function listen(server, port, host) {
+  return new Promise((resolve, reject) => {
+    server.once("error", reject)
+    server.listen(port, host, () => { server.off("error", reject); resolve(undefined) })
+  })
+}
+/** @param {import("node:http").Server} server @returns {Promise<void>} */
+function boundedClose(server) {
+  return Promise.race([
+    new Promise((resolve) => server.close(() => resolve(undefined))),
+    new Promise((resolve) => { const timer = setTimeout(resolve, 1000); timer.unref() })
+  ])
+}
+/** @param {Map<string, import("node:http").Server>} listeners @param {string} token */
+async function closeListener(listeners, token) {
+  const listener = listeners.get(token)
+  listeners.delete(token)
+  if (listener === undefined) return
+  await boundedClose(listener)
+}

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/providers/index.js

@@ -2,14 +2,15 @@
 
 import {buildClaudeCommand, claudeSessionId, createClaudeParser} from "./claude.js"
 import {buildCodexCommand, codexSessionId, parseCodexEvent} from "./codex.js"
+import {buildKimiCommand, createKimiParser, createKimiSessionId} from "./kimi.js"
 import {buildOpenCodeCommand, createOpenCodeParser, createOpenCodeSessionId} from "./opencode.js"
 
 /**
- * @typedef {{name: "codex" | "claude" | "opencode", executable: string, arguments: string[], parse: (record: unknown) => import("../types.js").WorkerEvent[], sessionId: (record: unknown) => string | undefined}} Provider
+ * @typedef {{name: "codex" | "claude" | "kimi" | "opencode", executable: string, arguments: string[], parse: (record: unknown) => import("../types.js").WorkerEvent[], sessionId: (record: unknown) => string | undefined}} Provider
  */
 
-/** @type {readonly ["codex", "claude", "opencode"]} */
-export const PROVIDERS = ["codex", "claude", "opencode"]
+/** @type {readonly ["codex", "claude", "kimi", "opencode"]} */
+export const PROVIDERS = ["codex", "claude", "kimi", "opencode"]
 
 /** @param {string} name @param {string[]} providerArguments @param {string} prompt @param {string | undefined} resumeSession @param {NodeJS.ProcessEnv} [environment] @returns {Provider} */
 export function createProvider(name, providerArguments, prompt, resumeSession, environment = process.env) {
@@ -25,5 +26,9 @@ export function createProvider(name, providerArguments, prompt, resumeSession, e
     const command = buildOpenCodeCommand(providerArguments, prompt, resumeSession, environment)
     return {...command, name: "opencode", parse: createOpenCodeParser(), sessionId: createOpenCodeSessionId()}
   }
+  if (name === "kimi") {
+    const command = buildKimiCommand(providerArguments, prompt, resumeSession)
+    return {...command, name: "kimi", parse: createKimiParser(), sessionId: createKimiSessionId()}
+  }
   throw new Error(`--provider must be one of: ${PROVIDERS.join(", ")}`)
 }