Skip to content

Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy

Rust

add config.json as alternative to env vars

Raine Virta6aa1b8463d14
diff --git a/README.md b/README.md
index 5f21c55..2bd2e31 100644
--- a/README.md
+++ b/README.md
@@ -427,35 +427,74 @@ The proxy speaks enough of the Anthropic API for Claude Code:
## Configuration
-Settings are environment variables on the proxy process, not a config file.
-
-| Variable | Default | Purpose |
-| ---------------------- | -------------------------------- | ---------------------------------------------------------------------------------------------- |
-| `PORT` | `18765` | Proxy listen port |
-| `XDG_STATE_HOME` | `~/.local/state` | Base dir for `proxy.log` |
-| `CCP_LOG_STDERR` | unset | Also mirror log lines to stderr |
-| `CCP_LOG_VERBOSE` | unset | Log full request/response bodies + every SSE event |
-| `KIMI_OAUTH_HOST` | `https://auth.kimi.com` | Override Kimi's OAuth host (debugging only) |
-| `KIMI_BASE_URL` | `https://api.kimi.com/coding/v1` | Override Kimi's API base URL |
-| `CCP_CODEX_MODEL` | unset | Force all Codex requests to this model (`gpt-5.2`, `gpt-5.3-codex`, `gpt-5.4`, `gpt-5.4-mini`) |
-| `CCP_CODEX_EFFORT` | unset | Force all Codex requests to this reasoning effort (`none`, `low`, `medium`, `high`, `xhigh`) |
-| `CCP_CODEX_ORIGINATOR` | `claude-code-proxy` | Override the `originator` header sent to Codex |
-| `CCP_CODEX_USER_AGENT` | `claude-code-proxy/<version>` | Override the `User-Agent` header sent to Codex |
-| `CCP_KIMI_USER_AGENT` | `KimiCLI/1.37.0` | Override the `User-Agent` header sent to Kimi |
-| `CCP_ORIGINATOR` | `claude-code-proxy` | Fallback for `CCP_CODEX_ORIGINATOR` |
-| `CCP_USER_AGENT` | unset | Fallback for `CCP_CODEX_USER_AGENT` and `CCP_KIMI_USER_AGENT` |
+Settings can come from either environment variables or a `config.json` file.
+Precedence per setting: **env var > config file > built-in default**. The
+config file is optional — env-var-only setups continue to work unchanged.
+
+The file lives at `~/.config/claude-code-proxy/config.json` on macOS (the same
+directory the auth tokens use, deliberately not `~/Library`) and at
+`${XDG_CONFIG_HOME:-$HOME/.config}/claude-code-proxy/config.json` elsewhere.
+
+```json
+{
+ "port": 18765,
+ "codex": {
+ "originator": "claude-code-proxy",
+ "userAgent": "claude-code-proxy/dev",
+ "model": "gpt-5.4",
+ "effort": "medium"
+ },
+ "kimi": {
+ "userAgent": "KimiCLI/1.37.0",
+ "oauthHost": "https://auth.kimi.com",
+ "baseUrl": "https://api.kimi.com/coding/v1"
+ },
+ "log": {
+ "stderr": false,
+ "verbose": false
+ }
+}
+```
+
+| Variable | Config key | Default | Purpose |
+| ---------------------- | ------------------- | -------------------------------- | ---------------------------------------------------------------------------------------------- |
+| `PORT` | `port` | `18765` | Proxy listen port |
+| `XDG_STATE_HOME` | — | `~/.local/state` | Base dir for `proxy.log` |
+| `CCP_LOG_STDERR` | `log.stderr` | unset | Also mirror log lines to stderr |
+| `CCP_LOG_VERBOSE` | `log.verbose` | unset | Log full request/response bodies + every SSE event |
+| `KIMI_OAUTH_HOST` | `kimi.oauthHost` | `https://auth.kimi.com` | Override Kimi's OAuth host (debugging only) |
+| `KIMI_BASE_URL` | `kimi.baseUrl` | `https://api.kimi.com/coding/v1` | Override Kimi's API base URL |
+| `CCP_CODEX_MODEL` | `codex.model` | unset | Force all Codex requests to this model (`gpt-5.2`, `gpt-5.3-codex`, `gpt-5.4`, `gpt-5.4-mini`) |
+| `CCP_CODEX_EFFORT` | `codex.effort` | unset | Force all Codex requests to this reasoning effort (`none`, `low`, `medium`, `high`, `xhigh`) |
+| `CCP_CODEX_ORIGINATOR` | `codex.originator` | `claude-code-proxy` | Override the `originator` header sent to Codex |
+| `CCP_CODEX_USER_AGENT` | `codex.userAgent` | `claude-code-proxy/<version>` | Override the `User-Agent` header sent to Codex |
+| `CCP_KIMI_USER_AGENT` | `kimi.userAgent` | `KimiCLI/1.37.0` | Override the `User-Agent` header sent to Kimi |
+| `CCP_ORIGINATOR` | — | `claude-code-proxy` | Fallback for `CCP_CODEX_ORIGINATOR` |
+| `CCP_USER_AGENT` | — | unset | Fallback for `CCP_CODEX_USER_AGENT` and `CCP_KIMI_USER_AGENT` |
+
+A malformed `config.json` is reported on stderr and ignored; defaults are used
+in its place. Invalid types for individual keys are warned and skipped without
+affecting other keys.
### Files
- `$XDG_STATE_HOME/claude-code-proxy/proxy.log` — JSON-lines log, rotated at 20
MiB. Secrets (`authorization`, `access`, `refresh`, `id_token`,
`ChatGPT-Account-Id`, …) are redacted before write.
-- `~/.config/claude-code-proxy/codex/auth.json` — codex tokens (non-macOS; macOS
- uses Keychain under service `claude-code-proxy.codex`).
-- `~/.config/claude-code-proxy/kimi/auth.json` — kimi tokens (non-macOS; macOS
- uses Keychain under service `claude-code-proxy.kimi`).
-- `~/.config/claude-code-proxy/kimi/device_id` — persistent UUID bound into the
- Kimi JWT at login. Reused for the lifetime of the install.
+- `~/.config/claude-code-proxy/config.json` (macOS) or
+ `${XDG_CONFIG_HOME:-$HOME/.config}/claude-code-proxy/config.json` — optional
+ configuration file (see table above).
+- `${XDG_CONFIG_HOME:-$HOME/.config}/claude-code-proxy/codex/auth.json` — codex
+ tokens (non-macOS; macOS uses Keychain under service
+ `claude-code-proxy.codex`). Pre-existing files at the legacy path
+ `~/.config/claude-code-proxy/codex/auth.json` are read as a fallback so
+ existing logins survive setting `XDG_CONFIG_HOME`.
+- `${XDG_CONFIG_HOME:-$HOME/.config}/claude-code-proxy/kimi/auth.json` — kimi
+ tokens (non-macOS; macOS uses Keychain under service
+ `claude-code-proxy.kimi`). Same legacy-path fallback as above.
+- `${XDG_CONFIG_HOME:-$HOME/.config}/claude-code-proxy/kimi/device_id` —
+ persistent UUID bound into the Kimi JWT at login. Reused for the lifetime
+ of the install.
## Limitations
diff --git a/src/cli.ts b/src/cli.ts
index 3705186..db10f85 100755
--- a/src/cli.ts
+++ b/src/cli.ts
@@ -1,6 +1,7 @@
#!/usr/bin/env bun
import { startServer } from "./server.ts"
import { createLogger, logDir } from "./log.ts"
+import { port as configPort } from "./config.ts"
import {
allProviders,
allSupportedModels,
@@ -24,7 +25,7 @@ async function main() {
}
if (!first || first === "serve") {
- const port = Number(process.env.PORT ?? 18765)
+ const port = configPort()
startServer({ port })
console.log(`Proxy listening on http://localhost:${port}`)
console.log(`Logs: ${logDir()}/proxy.log`)
@@ -89,7 +90,7 @@ function usageAndExit(): never {
.map((m) => `${m.model} (${m.provider})`)
.join(", ")
console.log(`Usage:
- claude-code-proxy serve Run proxy (PORT env, default 18765)
+ claude-code-proxy serve Run proxy (PORT env or config.json port, default 18765)
Upstream is chosen per-request from ANTHROPIC_MODEL.
claude-code-proxy <provider> auth login Browser OAuth
claude-code-proxy <provider> auth device Device-code OAuth
diff --git a/src/config.test.ts b/src/config.test.ts
new file mode 100644
index 0000000..3ab96ba
--- /dev/null
+++ b/src/config.test.ts
@@ -0,0 +1,176 @@
+import { describe, expect, it, beforeEach, afterEach } from "bun:test"
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import {
+ loadConfig,
+ port,
+ codexOriginator,
+ codexUserAgent,
+ codexModel,
+ codexEffort,
+ kimiUserAgent,
+ kimiOauthHost,
+ kimiBaseUrl,
+ logVerbose,
+ logStderr,
+} from "./config.ts"
+
+let dir: string
+let configPath: string
+
+function setEnv(env: NodeJS.ProcessEnv) {
+ loadConfig({ configPath, env, forceReload: true })
+}
+
+beforeEach(() => {
+ dir = mkdtempSync(join(tmpdir(), "ccp-config-"))
+ configPath = join(dir, "config.json")
+})
+
+afterEach(() => {
+ rmSync(dir, { recursive: true, force: true })
+ // Reset module-level cache to a clean process-env baseline so unrelated
+ // tests that import config getters do not see leftover overrides.
+ loadConfig({ forceReload: true })
+})
+
+describe("config defaults", () => {
+ it("returns built-in defaults when no env and no file", () => {
+ setEnv({})
+ expect(port()).toBe(18765)
+ expect(codexOriginator("default-orig")).toBe("default-orig")
+ expect(codexUserAgent("default-ua")).toBe("default-ua")
+ expect(codexModel()).toBeUndefined()
+ expect(codexEffort()).toBeUndefined()
+ expect(kimiUserAgent("default-kimi-ua")).toBe("default-kimi-ua")
+ expect(kimiOauthHost()).toBe("https://auth.kimi.com")
+ expect(kimiBaseUrl()).toBe("https://api.kimi.com/coding/v1")
+ expect(logVerbose()).toBe(false)
+ expect(logStderr()).toBe(false)
+ })
+})
+
+describe("file overrides default", () => {
+ it("port from config.json", () => {
+ writeFileSync(configPath, JSON.stringify({ port: 11111 }))
+ setEnv({})
+ expect(port()).toBe(11111)
+ })
+
+ it("codex.userAgent from config.json", () => {
+ writeFileSync(
+ configPath,
+ JSON.stringify({ codex: { userAgent: "ccp/file" } }),
+ )
+ setEnv({})
+ expect(codexUserAgent("default")).toBe("ccp/file")
+ })
+
+ it("kimi.oauthHost from config.json", () => {
+ writeFileSync(
+ configPath,
+ JSON.stringify({ kimi: { oauthHost: "https://auth.example.com" } }),
+ )
+ setEnv({})
+ expect(kimiOauthHost()).toBe("https://auth.example.com")
+ })
+
+ it("log.verbose from config.json", () => {
+ writeFileSync(configPath, JSON.stringify({ log: { verbose: true } }))
+ setEnv({})
+ expect(logVerbose()).toBe(true)
+ })
+})
+
+describe("env overrides file", () => {
+ it("PORT env wins over config port", () => {
+ writeFileSync(configPath, JSON.stringify({ port: 11111 }))
+ setEnv({ PORT: "22222" })
+ expect(port()).toBe(22222)
+ })
+
+ it("CCP_CODEX_USER_AGENT env wins over config", () => {
+ writeFileSync(
+ configPath,
+ JSON.stringify({ codex: { userAgent: "from-file" } }),
+ )
+ setEnv({ CCP_CODEX_USER_AGENT: "from-env" })
+ expect(codexUserAgent("default")).toBe("from-env")
+ })
+
+ it("CCP_USER_AGENT env (generic fallback) is preferred over file", () => {
+ writeFileSync(
+ configPath,
+ JSON.stringify({ codex: { userAgent: "from-file" } }),
+ )
+ setEnv({ CCP_USER_AGENT: "generic-env" })
+ expect(codexUserAgent("default")).toBe("generic-env")
+ expect(kimiUserAgent("default")).toBe("generic-env")
+ })
+
+ it("logStderr env-set forces true even when config sets false", () => {
+ writeFileSync(configPath, JSON.stringify({ log: { stderr: false } }))
+ setEnv({ CCP_LOG_STDERR: "1" })
+ expect(logStderr()).toBe(true)
+ })
+})
+
+describe("empty-string semantics", () => {
+ it("empty CCP_CODEX_MODEL env falls through to file value", () => {
+ writeFileSync(configPath, JSON.stringify({ codex: { model: "gpt-5.2" } }))
+ setEnv({ CCP_CODEX_MODEL: "" })
+ expect(codexModel()).toBe("gpt-5.2")
+ })
+
+ it("empty CCP_CODEX_MODEL env with no file value returns undefined", () => {
+ setEnv({ CCP_CODEX_MODEL: "" })
+ expect(codexModel()).toBeUndefined()
+ })
+
+ it("empty PORT env falls through to file value", () => {
+ writeFileSync(configPath, JSON.stringify({ port: 33333 }))
+ setEnv({ PORT: "" })
+ expect(port()).toBe(33333)
+ })
+})
+
+describe("empty env-string compatibility", () => {
+ it("empty CCP_CODEX_USER_AGENT env is a valid value (legacy ?? semantics)", () => {
+ setEnv({ CCP_CODEX_USER_AGENT: "" })
+ expect(codexUserAgent("default-ua")).toBe("")
+ })
+
+ it("empty KIMI_OAUTH_HOST env is a valid value (legacy ?? semantics)", () => {
+ setEnv({ KIMI_OAUTH_HOST: "" })
+ expect(kimiOauthHost()).toBe("")
+ })
+
+ it("CCP_LOG_STDERR set to empty string still enables stderr (legacy !! semantics)", () => {
+ setEnv({ CCP_LOG_STDERR: "" })
+ expect(logStderr()).toBe(true)
+ })
+})
+
+describe("malformed config", () => {
+ it("returns defaults when JSON is invalid", () => {
+ writeFileSync(configPath, "{not valid json")
+ setEnv({})
+ expect(port()).toBe(18765)
+ })
+
+ it("ignores wrong-typed values with a warning, keeps other valid ones", () => {
+ writeFileSync(
+ configPath,
+ JSON.stringify({ port: "not-a-number", codex: { userAgent: "good" } }),
+ )
+ setEnv({})
+ expect(port()).toBe(18765)
+ expect(codexUserAgent("default")).toBe("good")
+ })
+
+ it("returns defaults when file is missing entirely", () => {
+ setEnv({})
+ expect(port()).toBe(18765)
+ })
+})
diff --git a/src/config.ts b/src/config.ts
new file mode 100644
index 0000000..03edea5
--- /dev/null
+++ b/src/config.ts
@@ -0,0 +1,230 @@
+import { readFileSync } from "node:fs"
+import { join } from "node:path"
+import { configDir } from "./paths.ts"
+
+// Config precedence per setting:
+// provider-specific env > generic-fallback env (where one exists) > config.json > default
+//
+// The config file is parsed once on first access and cached. Empty strings
+// from either env or the file are treated as "unset" so they fall through
+// to the next layer (matches existing CCP_CODEX_MODEL behavior).
+
+export interface FileConfig {
+ port?: number
+ codex?: {
+ originator?: string
+ userAgent?: string
+ model?: string
+ effort?: string
+ }
+ kimi?: {
+ userAgent?: string
+ oauthHost?: string
+ baseUrl?: string
+ }
+ log?: {
+ stderr?: boolean
+ verbose?: boolean
+ }
+}
+
+interface LoadedConfig {
+ file: FileConfig
+ env: NodeJS.ProcessEnv
+}
+
+interface LoadOptions {
+ configPath?: string
+ env?: NodeJS.ProcessEnv
+ forceReload?: boolean
+}
+
+let cached: LoadedConfig | undefined
+
+// Most env-var consumers historically used `??` semantics — empty string is
+// a real value that wins. Only CCP_CODEX_MODEL and CCP_CODEX_EFFORT had
+// explicit empty-string-as-unset handling in the legacy code, so only those
+// getters use emptyOrUnset.
+function emptyOrUnset(v: string | undefined): string | undefined {
+ return v === undefined || v === "" ? undefined : v
+}
+
+function warnInvalid(key: string, expected: string, got: unknown): void {
+ process.stderr.write(
+ `claude-code-proxy: ignoring config.json key "${key}": expected ${expected}, got ${typeof got}\n`,
+ )
+}
+
+function validate(raw: unknown): FileConfig {
+ if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {}
+ const r = raw as Record<string, unknown>
+ const out: FileConfig = {}
+
+ if (r.port !== undefined) {
+ if (typeof r.port === "number" && Number.isFinite(r.port)) out.port = r.port
+ else warnInvalid("port", "number", r.port)
+ }
+
+ const validateStringSection = <K extends "codex" | "kimi" | "log">(
+ key: K,
+ keys: ReadonlyArray<keyof NonNullable<FileConfig[K]>>,
+ types: Record<string, "string" | "boolean">,
+ ): NonNullable<FileConfig[K]> | undefined => {
+ if (r[key] === undefined) return undefined
+ const sec = r[key]
+ if (!sec || typeof sec !== "object" || Array.isArray(sec)) {
+ warnInvalid(key, "object", sec)
+ return undefined
+ }
+ const acc: Record<string, unknown> = {}
+ for (const k of keys) {
+ const v = (sec as Record<string, unknown>)[k as string]
+ if (v === undefined) continue
+ const expected = types[k as string]
+ if (expected && typeof v === expected) acc[k as string] = v
+ else warnInvalid(`${key}.${String(k)}`, expected ?? "unknown", v)
+ }
+ return acc as NonNullable<FileConfig[K]>
+ }
+
+ const codex = validateStringSection("codex", ["originator", "userAgent", "model", "effort"], {
+ originator: "string",
+ userAgent: "string",
+ model: "string",
+ effort: "string",
+ })
+ if (codex) out.codex = codex
+
+ const kimi = validateStringSection("kimi", ["userAgent", "oauthHost", "baseUrl"], {
+ userAgent: "string",
+ oauthHost: "string",
+ baseUrl: "string",
+ })
+ if (kimi) out.kimi = kimi
+
+ const log = validateStringSection("log", ["stderr", "verbose"], {
+ stderr: "boolean",
+ verbose: "boolean",
+ })
+ if (log) out.log = log
+
+ return out
+}
+
+export function loadConfig(opts: LoadOptions = {}): LoadedConfig {
+ if (cached && !opts.forceReload && !opts.configPath && !opts.env) {
+ return cached
+ }
+ const env = opts.env ?? process.env
+ const path = opts.configPath ?? join(configDir(), "config.json")
+ let file: FileConfig = {}
+ try {
+ const raw = readFileSync(path, "utf8")
+ try {
+ file = validate(JSON.parse(raw))
+ } catch (err) {
+ process.stderr.write(
+ `claude-code-proxy: failed to parse ${path} (${(err as Error).message}); using defaults\n`,
+ )
+ }
+ } catch (err: unknown) {
+ if ((err as NodeJS.ErrnoException).code !== "ENOENT") {
+ process.stderr.write(
+ `claude-code-proxy: failed to read ${path} (${(err as Error).message}); using defaults\n`,
+ )
+ }
+ }
+ const result: LoadedConfig = { file, env }
+ // Always update the cache when forceReload is requested (lets tests
+ // install a custom env+path under the same singleton other modules read).
+ if (opts.forceReload || (!opts.configPath && !opts.env)) cached = result
+ return result
+}
+
+export function getConfig(): LoadedConfig {
+ return cached ?? loadConfig()
+}
+
+// Per-setting getters. Each encodes its precedence chain explicitly.
+
+// Preserves legacy `Number(process.env.PORT ?? 18765)` semantics: an env-set
+// PORT of empty string parsed to NaN under the old code (effectively broken),
+// so we treat it as unset rather than returning NaN.
+export function port(): number {
+ const c = getConfig()
+ const envPort = c.env.PORT
+ if (envPort !== undefined && envPort !== "") {
+ const n = Number(envPort)
+ if (Number.isFinite(n)) return n
+ }
+ return c.file.port ?? 18765
+}
+
+export function codexOriginator(defaultValue: string): string {
+ const c = getConfig()
+ return (
+ c.env.CCP_CODEX_ORIGINATOR ??
+ c.env.CCP_ORIGINATOR ??
+ c.file.codex?.originator ??
+ defaultValue
+ )
+}
+
+export function codexUserAgent(defaultValue: string): string {
+ const c = getConfig()
+ return (
+ c.env.CCP_CODEX_USER_AGENT ??
+ c.env.CCP_USER_AGENT ??
+ c.file.codex?.userAgent ??
+ defaultValue
+ )
+}
+
+// Returns undefined when neither env nor file specifies a value. Empty
+// string in env is intentionally treated as "unset" (preserves the
+// long-standing CCP_CODEX_MODEL escape hatch).
+export function codexModel(): string | undefined {
+ const c = getConfig()
+ return emptyOrUnset(c.env.CCP_CODEX_MODEL) ?? emptyOrUnset(c.file.codex?.model)
+}
+
+export function codexEffort(): string | undefined {
+ const c = getConfig()
+ return emptyOrUnset(c.env.CCP_CODEX_EFFORT) ?? emptyOrUnset(c.file.codex?.effort)
+}
+
+export function kimiUserAgent(defaultValue: string): string {
+ const c = getConfig()
+ return (
+ c.env.CCP_KIMI_USER_AGENT ??
+ c.env.CCP_USER_AGENT ??
+ c.file.kimi?.userAgent ??
+ defaultValue
+ )
+}
+
+export function kimiOauthHost(): string {
+ const c = getConfig()
+ return c.env.KIMI_OAUTH_HOST ?? c.file.kimi?.oauthHost ?? "https://auth.kimi.com"
+}
+
+export function kimiBaseUrl(): string {
+ const c = getConfig()
+ return c.env.KIMI_BASE_URL ?? c.file.kimi?.baseUrl ?? "https://api.kimi.com/coding/v1"
+}
+
+// Additive: error/warn always go to stderr in log.ts; this getter only
+// controls whether *all* levels are also mirrored to stderr. Matches the
+// pre-existing `!!process.env.CCP_LOG_STDERR` semantics where any value
+// (including the empty string) enables it.
+export function logStderr(): boolean {
+ const c = getConfig()
+ if (c.env.CCP_LOG_STDERR !== undefined) return true
+ return c.file.log?.stderr ?? false
+}
+
+export function logVerbose(): boolean {
+ const c = getConfig()
+ if (c.env.CCP_LOG_VERBOSE !== undefined) return true
+ return c.file.log?.verbose ?? false
+}
diff --git a/src/log.ts b/src/log.ts
index 10f1d00..169ef20 100644
--- a/src/log.ts
+++ b/src/log.ts
@@ -1,7 +1,8 @@
import { mkdir, appendFile, stat, rename } from "node:fs/promises"
import { createWriteStream, type WriteStream } from "node:fs"
import { join } from "node:path"
-import { homedir } from "node:os"
+import { stateDir } from "./paths.ts"
+import { logStderr, logVerbose } from "./config.ts"
const MAX_LOG_BYTES = 20 * 1024 * 1024 // 20 MiB
export const REDACT_KEYS = new Set([
@@ -17,11 +18,6 @@ export const REDACT_KEYS = new Set([
"x-api-key",
])
-function stateDir(): string {
- const base = process.env.XDG_STATE_HOME || join(homedir(), ".local", "state")
- return join(base, "claude-code-proxy")
-}
-
export function logDir(): string {
return stateDir()
}
@@ -61,13 +57,11 @@ async function maybeRotate(): Promise<void> {
return rotating
}
-const VERBOSE = !!process.env.CCP_LOG_VERBOSE
-
function redact(value: unknown, depth = 0): unknown {
if (depth > 6) return "[depth-limit]"
if (value == null) return value
if (typeof value === "string") {
- if (!VERBOSE && value.length > 4000) return value.slice(0, 4000) + `…[${value.length - 4000} more]`
+ if (!logVerbose() && value.length > 4000) return value.slice(0, 4000) + `…[${value.length - 4000} more]`
return value
}
if (typeof value !== "object") return value
@@ -100,7 +94,7 @@ async function write(level: Level, service: string, msg: string, fields?: Record
} catch {
// swallow; also print to stderr for visibility
}
- if (level === "error" || level === "warn" || process.env.CCP_LOG_STDERR) {
+ if (level === "error" || level === "warn" || logStderr()) {
process.stderr.write(line + "\n")
}
}
diff --git a/src/paths.test.ts b/src/paths.test.ts
new file mode 100644
index 0000000..ca3c55a
--- /dev/null
+++ b/src/paths.test.ts
@@ -0,0 +1,42 @@
+import { describe, expect, it } from "bun:test"
+import { resolveConfigDir, resolveStateDir } from "./paths.ts"
+
+describe("resolveConfigDir", () => {
+ it("uses ~/.config on darwin even when XDG_CONFIG_HOME is set", () => {
+ expect(
+ resolveConfigDir({ platform: "darwin", env: { XDG_CONFIG_HOME: "/x" }, home: "/home/u" }),
+ ).toBe("/home/u/.config/claude-code-proxy")
+ })
+
+ it("honors XDG_CONFIG_HOME on linux", () => {
+ expect(
+ resolveConfigDir({ platform: "linux", env: { XDG_CONFIG_HOME: "/x" }, home: "/home/u" }),
+ ).toBe("/x/claude-code-proxy")
+ })
+
+ it("falls back to $HOME/.config on linux without XDG_CONFIG_HOME", () => {
+ expect(resolveConfigDir({ platform: "linux", env: {}, home: "/home/u" })).toBe(
+ "/home/u/.config/claude-code-proxy",
+ )
+ })
+})
+
+describe("resolveStateDir", () => {
+ it("honors XDG_STATE_HOME on darwin (preserves pre-existing log.ts behavior)", () => {
+ expect(
+ resolveStateDir({ platform: "darwin", env: { XDG_STATE_HOME: "/x" }, home: "/home/u" }),
+ ).toBe("/x/claude-code-proxy")
+ })
+
+ it("falls back to $HOME/.local/state on darwin without XDG_STATE_HOME", () => {
+ expect(resolveStateDir({ platform: "darwin", env: {}, home: "/home/u" })).toBe(
+ "/home/u/.local/state/claude-code-proxy",
+ )
+ })
+
+ it("honors XDG_STATE_HOME on linux", () => {
+ expect(
+ resolveStateDir({ platform: "linux", env: { XDG_STATE_HOME: "/x" }, home: "/home/u" }),
+ ).toBe("/x/claude-code-proxy")
+ })
+})
diff --git a/src/paths.ts b/src/paths.ts
new file mode 100644
index 0000000..3d40164
--- /dev/null
+++ b/src/paths.ts
@@ -0,0 +1,46 @@
+import { homedir } from "node:os"
+import { join } from "node:path"
+
+export interface DirResolverEnv {
+ platform: NodeJS.Platform
+ env: NodeJS.ProcessEnv
+ home: string
+}
+
+function defaults(): DirResolverEnv {
+ return { platform: process.platform, env: process.env, home: homedir() }
+}
+
+// macOS deliberately uses ~/.config/<app> rather than honoring XDG_CONFIG_HOME
+// (which would redirect to ~/Library/Application Support). This matches where
+// auth tokens have always been stored on macOS.
+export function resolveConfigDir(deps: DirResolverEnv): string {
+ if (deps.platform === "darwin") {
+ return join(deps.home, ".config", "claude-code-proxy")
+ }
+ const base = deps.env.XDG_CONFIG_HOME || join(deps.home, ".config")
+ return join(base, "claude-code-proxy")
+}
+
+// XDG_STATE_HOME is honored on every platform (including macOS) — that's the
+// pre-config.json behavior of log.ts and is documented in the README.
+export function resolveStateDir(deps: DirResolverEnv): string {
+ const base = deps.env.XDG_STATE_HOME || join(deps.home, ".local", "state")
+ return join(base, "claude-code-proxy")
+}
+
+// Legacy (pre-config.json) auth/device-id path. Always ~/.config regardless
+// of XDG_CONFIG_HOME — this is the directory token stores hardcoded before
+// configDir() existed. Used as a read-only fallback so existing logins keep
+// working after upgrade.
+export function legacyConfigDir(deps: DirResolverEnv = defaults()): string {
+ return join(deps.home, ".config", "claude-code-proxy")
+}
+
+export function configDir(): string {
+ return resolveConfigDir(defaults())
+}
+
+export function stateDir(): string {
+ return resolveStateDir(defaults())
+}
diff --git a/src/providers/codex/auth/token-store.ts b/src/providers/codex/auth/token-store.ts
index 889e15e..542c7b4 100644
--- a/src/providers/codex/auth/token-store.ts
+++ b/src/providers/codex/auth/token-store.ts
@@ -1,7 +1,7 @@
import { mkdir, readFile, writeFile, unlink, rename } from "node:fs/promises"
import { dirname, join } from "node:path"
-import { homedir } from "node:os"
import { keychainGet, keychainSet, keychainDelete } from "../../../keychain.ts"
+import { configDir, legacyConfigDir } from "../../../paths.ts"
export interface StoredAuth {
access: string
@@ -10,8 +10,12 @@ export interface StoredAuth {
accountId?: string
}
-const DIR = join(homedir(), ".config", "claude-code-proxy", "codex")
-const FILE = join(DIR, "auth.json")
+function file(): string {
+ return join(configDir(), "codex", "auth.json")
+}
+function legacyFile(): string {
+ return join(legacyConfigDir(), "codex", "auth.json")
+}
const KEYCHAIN_SERVICE = "claude-code-proxy.codex"
const KEYCHAIN_ACCOUNT = "auth"
@@ -22,8 +26,17 @@ export async function loadAuth(): Promise<StoredAuth | undefined> {
return JSON.parse(raw) as StoredAuth
}
+ const primary = file()
+ try {
+ const raw = await readFile(primary, "utf8")
+ return JSON.parse(raw) as StoredAuth
+ } catch (err: any) {
+ if (err?.code !== "ENOENT") throw err
+ }
+ const legacy = legacyFile()
+ if (legacy === primary) return undefined
try {
- const raw = await readFile(FILE, "utf8")
+ const raw = await readFile(legacy, "utf8")
return JSON.parse(raw) as StoredAuth
} catch (err: any) {
if (err?.code === "ENOENT") return undefined
@@ -37,10 +50,11 @@ export async function saveAuth(auth: StoredAuth): Promise<void> {
return
}
- await mkdir(dirname(FILE), { recursive: true, mode: 0o700 })
- const tmp = `${FILE}.${process.pid}.${Date.now()}.tmp`
+ const path = file()
+ await mkdir(dirname(path), { recursive: true, mode: 0o700 })
+ const tmp = `${path}.${process.pid}.${Date.now()}.tmp`
await writeFile(tmp, JSON.stringify(auth, null, 2), { encoding: "utf8", mode: 0o600 })
- await rename(tmp, FILE)
+ await rename(tmp, path)
}
export async function clearAuth(): Promise<void> {
@@ -49,13 +63,15 @@ export async function clearAuth(): Promise<void> {
return
}
- try {
- await unlink(FILE)
- } catch (err: any) {
- if (err?.code !== "ENOENT") throw err
+ for (const path of [file(), legacyFile()]) {
+ try {
+ await unlink(path)
+ } catch (err: any) {
+ if (err?.code !== "ENOENT") throw err
+ }
}
}
export function authPath(): string {
- return process.platform === "darwin" ? "macOS Keychain" : FILE
+ return process.platform === "darwin" ? "macOS Keychain" : file()
}
diff --git a/src/providers/codex/client.ts b/src/providers/codex/client.ts
index 0f2cee0..73f2f03 100644
--- a/src/providers/codex/client.ts
+++ b/src/providers/codex/client.ts
@@ -1,4 +1,5 @@
import { CODEX_API_ENDPOINT, ORIGINATOR as ORIGINATOR_DEFAULT } from "./auth/constants.ts"
+import { codexOriginator, codexUserAgent } from "../../config.ts"
declare const BUILD_VERSION: string | undefined
const PROXY_VERSION = typeof BUILD_VERSION === "string" ? BUILD_VERSION : "dev"
import { forceRefresh, getAuth } from "./auth/manager.ts"
@@ -80,10 +81,10 @@ async function doFetch(
"Content-Type": "application/json",
accept: "text/event-stream",
authorization: `Bearer ${accessToken}`,
- originator: process.env.CCP_CODEX_ORIGINATOR ?? process.env.CCP_ORIGINATOR ?? ORIGINATOR_DEFAULT,
+ originator: codexOriginator(ORIGINATOR_DEFAULT),
"openai-beta": "responses=experimental",
})
- const userAgent = process.env.CCP_CODEX_USER_AGENT ?? process.env.CCP_USER_AGENT ?? `claude-code-proxy/${PROXY_VERSION}`
+ const userAgent = codexUserAgent(`claude-code-proxy/${PROXY_VERSION}`)
if (userAgent) headers.set("User-Agent", userAgent)
if (accountId) headers.set("ChatGPT-Account-Id", accountId)
if (sessionId) {
diff --git a/src/providers/codex/index.ts b/src/providers/codex/index.ts
index 4d12659..b41ff79 100644
--- a/src/providers/codex/index.ts
+++ b/src/providers/codex/index.ts
@@ -15,8 +15,7 @@ import { runBrowserLogin } from "./auth/pkce.ts"
import { runDeviceLogin } from "./auth/device.ts"
import { persistInitialTokens } from "./auth/manager.ts"
import { loadAuth, authPath, clearAuth } from "./auth/token-store.ts"
-
-const VERBOSE = !!process.env.CCP_LOG_VERBOSE
+import { logVerbose } from "../../config.ts"
interface SessionCountSnapshot {
reqId: string
@@ -101,7 +100,7 @@ async function handleCountTokens(body: AnthropicRequest, ctx: RequestContext): P
tokens,
}
}
- if (VERBOSE) {
+ if (logVerbose()) {
log.info("compaction telemetry", {
phase: "count_tokens",
model: body.model,
@@ -140,7 +139,7 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
hasContextManagement: contextManagement !== undefined,
hasJsonSchemaFormat: body.output_config?.format?.type === "json_schema",
})
- if (VERBOSE) log.debug("anthropic request body", { body })
+ if (logVerbose()) log.debug("anthropic request body", { body })
const resolvedModel = resolveModel(body.model)
@@ -158,8 +157,8 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
}
const translated = translateRequest({ ...body, model: resolvedModel }, { sessionId: ctx.sessionId })
- const localInputTokens = VERBOSE ? countTokens(body) : undefined
- const translatedInputTokens = VERBOSE ? countTranslatedTokens(translated) : undefined
+ const localInputTokens = logVerbose() ? countTokens(body) : undefined
+ const translatedInputTokens = logVerbose() ? countTranslatedTokens(translated) : undefined
if (state) {
state.lastMessage = {
reqId: ctx.reqId,
@@ -180,8 +179,8 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
hasContextManagement: contextManagement !== undefined,
promptCacheKey: translated.prompt_cache_key,
})
- if (VERBOSE) log.debug("translated request body", { body: translated })
- if (VERBOSE) {
+ if (logVerbose()) log.debug("translated request body", { body: translated })
+ if (logVerbose()) {
log.info("compaction telemetry", {
phase: "translated_request",
requestedModel: body.model,
@@ -234,7 +233,7 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
messageId,
model: body.model,
log: ctx.childLogger("codex.stream"),
- onFinish: VERBOSE
+ onFinish: logVerbose()
? (finish) => {
const mappedUsage = finish.usage ? mapUsageToAnthropic(finish.usage) : undefined
log.info("compaction telemetry", {
@@ -277,7 +276,7 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
try {
const result = await accumulateResponse(upstream.body, { messageId, model: body.model, log: ctx.childLogger("codex.accumulate") })
- if (VERBOSE) {
+ if (logVerbose()) {
const { serverModel, serverReasoningIncluded } = upstreamHeaderSnapshot(upstream.headers)
log.info("compaction telemetry", {
phase: "upstream_finish",
diff --git a/src/providers/codex/translate/model-allowlist.test.ts b/src/providers/codex/translate/model-allowlist.test.ts
new file mode 100644
index 0000000..c16fbfc
--- /dev/null
+++ b/src/providers/codex/translate/model-allowlist.test.ts
@@ -0,0 +1,56 @@
+import { describe, expect, it, afterEach } from "bun:test"
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { resolveModel } from "./model-allowlist.ts"
+import { loadConfig } from "../../../config.ts"
+
+afterEach(() => {
+ loadConfig({ forceReload: true })
+})
+
+describe("resolveModel", () => {
+ it("returns alias when no override is set", () => {
+ loadConfig({ env: {}, forceReload: true })
+ expect(resolveModel("sonnet")).toBe("gpt-5.4")
+ })
+
+ it("env CCP_CODEX_MODEL takes precedence", () => {
+ loadConfig({ env: { CCP_CODEX_MODEL: "gpt-5.2" }, forceReload: true })
+ expect(resolveModel("sonnet")).toBe("gpt-5.2")
+ })
+
+ it("config.json codex.model overrides aliases", () => {
+ const dir = mkdtempSync(join(tmpdir(), "ccp-model-"))
+ const path = join(dir, "config.json")
+ writeFileSync(path, JSON.stringify({ codex: { model: "gpt-5.5" } }))
+ try {
+ loadConfig({ configPath: path, env: {}, forceReload: true })
+ expect(resolveModel("sonnet")).toBe("gpt-5.5")
+ } finally {
+ rmSync(dir, { recursive: true, force: true })
+ }
+ })
+
+ it("empty CCP_CODEX_MODEL env is treated as unset (no regression)", () => {
+ const dir = mkdtempSync(join(tmpdir(), "ccp-model-"))
+ const path = join(dir, "config.json")
+ writeFileSync(path, JSON.stringify({ codex: { model: "gpt-5.5" } }))
+ try {
+ loadConfig({
+ configPath: path,
+ env: { CCP_CODEX_MODEL: "" },
+ forceReload: true,
+ })
+ // Empty env should fall through to file value
+ expect(resolveModel("sonnet")).toBe("gpt-5.5")
+ } finally {
+ rmSync(dir, { recursive: true, force: true })
+ }
+ })
+
+ it("empty env and no file value falls through to alias", () => {
+ loadConfig({ env: { CCP_CODEX_MODEL: "" }, forceReload: true })
+ expect(resolveModel("sonnet")).toBe("gpt-5.4")
+ })
+})
diff --git a/src/providers/codex/translate/model-allowlist.ts b/src/providers/codex/translate/model-allowlist.ts
index bc9636a..213b5f1 100644
--- a/src/providers/codex/translate/model-allowlist.ts
+++ b/src/providers/codex/translate/model-allowlist.ts
@@ -1,3 +1,5 @@
+import { codexModel } from "../../../config.ts"
+
export const ALLOWED_MODELS = new Set([
"gpt-5.2",
"gpt-5.3-codex",
@@ -17,15 +19,12 @@ export const MODEL_ALIASES = new Map<string, string>([
])
export function resolveModel(model: string): string {
- // The CCP_CODEX_MODEL environment variable overrides the model so that
- // regardless of whatever model is requested by the harness, the provided
- // model is always used.
- if (
- process.env.CCP_CODEX_MODEL !== undefined &&
- process.env.CCP_CODEX_MODEL !== ""
- ) {
- return process.env.CCP_CODEX_MODEL
- }
+ // CCP_CODEX_MODEL (env) or codex.model (config.json) overrides the model
+ // so that regardless of whatever model is requested by the harness, the
+ // provided model is always used. Empty values fall through to alias
+ // resolution.
+ const override = codexModel()
+ if (override !== undefined) return override
return MODEL_ALIASES.get(model) ?? model
}
diff --git a/src/providers/codex/translate/reducer.ts b/src/providers/codex/translate/reducer.ts
index 81c246d..e151531 100644
--- a/src/providers/codex/translate/reducer.ts
+++ b/src/providers/codex/translate/reducer.ts
@@ -1,7 +1,6 @@
import { parseSseStream } from "../../../sse.ts"
import type { Logger } from "../../../log.ts"
-
-const VERBOSE = !!process.env.CCP_LOG_VERBOSE
+import { logVerbose } from "../../../config.ts"
export class UpstreamStreamError extends Error {
constructor(
@@ -98,7 +97,7 @@ export async function* reduceUpstream(
}
const t: string = p.type || evt.event || ""
- if (VERBOSE) log.debug("upstream event", { type: t, output_index: p.output_index, item_id: p.item_id })
+ if (logVerbose()) log.debug("upstream event", { type: t, output_index: p.output_index, item_id: p.item_id })
if (t === "codex.rate_limits") {
if (p.rate_limits?.limit_reached) {
diff --git a/src/providers/codex/translate/request.ts b/src/providers/codex/translate/request.ts
index a7ae079..74c4f5b 100644
--- a/src/providers/codex/translate/request.ts
+++ b/src/providers/codex/translate/request.ts
@@ -6,6 +6,7 @@ import type {
AnthropicTextBlock,
AnthropicTool,
} from "../../../anthropic/schema.ts"
+import { codexEffort } from "../../../config.ts"
export type Effort = "none" | "low" | "medium" | "high" | "xhigh"
@@ -93,8 +94,8 @@ function toCodexEffort(
}
function resolveEffort(effort?: Effort): Effort | undefined {
- const override = process.env.CCP_CODEX_EFFORT
- if (override === undefined || override === "") {
+ const override = codexEffort()
+ if (override === undefined) {
return effort
}
if (!VALID_EFFORTS.has(override as Effort)) {
diff --git a/src/providers/kimi/auth/constants.ts b/src/providers/kimi/auth/constants.ts
index 32d5d3d..8c2553f 100644
--- a/src/providers/kimi/auth/constants.ts
+++ b/src/providers/kimi/auth/constants.ts
@@ -1,6 +1,14 @@
+import { kimiBaseUrl, kimiOauthHost } from "../../../config.ts"
+
export const CLIENT_ID = "17e5f671-d194-4dfb-9706-5516cb48c098"
-export const OAUTH_HOST = process.env.KIMI_OAUTH_HOST ?? "https://auth.kimi.com"
-export const API_BASE_URL = process.env.KIMI_BASE_URL ?? "https://api.kimi.com/coding/v1"
+// Read lazily so config.json values apply. KIMI_OAUTH_HOST / KIMI_BASE_URL
+// env vars still work (env wins over file in the getter).
+export function oauthHost(): string {
+ return kimiOauthHost()
+}
+export function apiBaseUrl(): string {
+ return kimiBaseUrl()
+}
// Masquerade as kimi-cli so the server accepts us. Bumping this in lockstep
// with kimi-cli releases may become necessary.
export const KIMI_CLI_VERSION = "1.37.0"
diff --git a/src/providers/kimi/auth/device-id.ts b/src/providers/kimi/auth/device-id.ts
index f42ac7d..570e9d9 100644
--- a/src/providers/kimi/auth/device-id.ts
+++ b/src/providers/kimi/auth/device-id.ts
@@ -1,22 +1,30 @@
import { mkdir, readFile, writeFile, chmod } from "node:fs/promises"
import { dirname, join } from "node:path"
-import { homedir } from "node:os"
+import { configDir, legacyConfigDir } from "../../../paths.ts"
-const PATH = join(homedir(), ".config", "claude-code-proxy", "kimi", "device_id")
+function path(): string {
+ return join(configDir(), "kimi", "device_id")
+}
+function legacyPath(): string {
+ return join(legacyConfigDir(), "kimi", "device_id")
+}
export async function getDeviceId(): Promise<string> {
- try {
- const raw = await readFile(PATH, "utf8")
- const trimmed = raw.trim()
- if (trimmed) return trimmed
- } catch (err: any) {
- if (err?.code !== "ENOENT") throw err
+ for (const candidate of [path(), legacyPath()]) {
+ try {
+ const raw = await readFile(candidate, "utf8")
+ const trimmed = raw.trim()
+ if (trimmed) return trimmed
+ } catch (err: any) {
+ if (err?.code !== "ENOENT") throw err
+ }
}
const id = crypto.randomUUID().replace(/-/g, "")
- await mkdir(dirname(PATH), { recursive: true })
- await writeFile(PATH, id, { encoding: "utf8", mode: 0o600 })
+ const target = path()
+ await mkdir(dirname(target), { recursive: true })
+ await writeFile(target, id, { encoding: "utf8", mode: 0o600 })
try {
- await chmod(PATH, 0o600)
+ await chmod(target, 0o600)
} catch {}
return id
}
diff --git a/src/providers/kimi/auth/headers.ts b/src/providers/kimi/auth/headers.ts
index 1439a51..21ecb53 100644
--- a/src/providers/kimi/auth/headers.ts
+++ b/src/providers/kimi/auth/headers.ts
@@ -1,6 +1,7 @@
import { hostname, release, arch, platform } from "node:os"
import { KIMI_CLI_VERSION } from "./constants.ts"
import { getDeviceId } from "./device-id.ts"
+import { kimiUserAgent } from "../../../config.ts"
function deviceModel(): string {
const a = arch()
@@ -25,6 +26,6 @@ export async function commonHeaders(): Promise<Record<string, string>> {
"X-Msh-Device-Model": asciiOnly(deviceModel()),
"X-Msh-Os-Version": asciiOnly(release()),
"X-Msh-Device-Id": deviceId,
- "User-Agent": process.env.CCP_KIMI_USER_AGENT ?? process.env.CCP_USER_AGENT ?? `KimiCLI/${KIMI_CLI_VERSION}`,
+ "User-Agent": kimiUserAgent(`KimiCLI/${KIMI_CLI_VERSION}`),
}
}
diff --git a/src/providers/kimi/auth/login.ts b/src/providers/kimi/auth/login.ts
index 48a8901..43c018e 100644
--- a/src/providers/kimi/auth/login.ts
+++ b/src/providers/kimi/auth/login.ts
@@ -1,4 +1,4 @@
-import { CLIENT_ID, OAUTH_HOST } from "./constants.ts"
+import { CLIENT_ID, oauthHost } from "./constants.ts"
import { commonHeaders } from "./headers.ts"
export interface TokenResponse {
@@ -24,7 +24,7 @@ const POLL_SAFETY_MARGIN_MS = 500
export async function runDeviceLogin(): Promise<TokenResponse> {
const headers = await commonHeaders()
- const initResp = await fetch(`${OAUTH_HOST}/api/oauth/device_authorization`, {
+ const initResp = await fetch(`${oauthHost()}/api/oauth/device_authorization`, {
method: "POST",
headers: { ...headers, "Content-Type": "application/x-www-form-urlencoded" },
body: new URLSearchParams({ client_id: CLIENT_ID }).toString(),
@@ -39,7 +39,7 @@ export async function runDeviceLogin(): Promise<TokenResponse> {
console.log(`Code: ${auth.user_code}\n`)
while (true) {
- const resp = await fetch(`${OAUTH_HOST}/api/oauth/token`, {
+ const resp = await fetch(`${oauthHost()}/api/oauth/token`, {
method: "POST",
headers: { ...headers, "Content-Type": "application/x-www-form-urlencoded" },
body: new URLSearchParams({
diff --git a/src/providers/kimi/auth/manager.ts b/src/providers/kimi/auth/manager.ts
index 2dfbbe6..dff90e4 100644
--- a/src/providers/kimi/auth/manager.ts
+++ b/src/providers/kimi/auth/manager.ts
@@ -1,4 +1,4 @@
-import { CLIENT_ID, OAUTH_HOST, REFRESH_MARGIN_MS } from "./constants.ts"
+import { CLIENT_ID, oauthHost, REFRESH_MARGIN_MS } from "./constants.ts"
import { commonHeaders } from "./headers.ts"
import { extractUserId } from "./jwt.ts"
import type { TokenResponse } from "./login.ts"
@@ -92,7 +92,7 @@ async function refreshNow(current: StoredAuth): Promise<StoredAuth> {
for (let attempt = 0; attempt < MAX_REFRESH_ATTEMPTS; attempt++) {
let resp: Response
try {
- resp = await fetch(`${OAUTH_HOST}/api/oauth/token`, {
+ resp = await fetch(`${oauthHost()}/api/oauth/token`, {
method: "POST",
headers: { ...headers, "Content-Type": "application/x-www-form-urlencoded" },
body: new URLSearchParams({
diff --git a/src/providers/kimi/auth/token-store.ts b/src/providers/kimi/auth/token-store.ts
index 0e75bf6..6bae7d3 100644
--- a/src/providers/kimi/auth/token-store.ts
+++ b/src/providers/kimi/auth/token-store.ts
@@ -1,7 +1,7 @@
import { mkdir, readFile, writeFile, unlink, rename } from "node:fs/promises"
import { dirname, join } from "node:path"
-import { homedir } from "node:os"
import { keychainGet, keychainSet, keychainDelete } from "../../../keychain.ts"
+import { configDir, legacyConfigDir } from "../../../paths.ts"
export interface StoredAuth {
access: string
@@ -11,8 +11,12 @@ export interface StoredAuth {
userId?: string
}
-const DIR = join(homedir(), ".config", "claude-code-proxy", "kimi")
-const FILE = join(DIR, "auth.json")
+function file(): string {
+ return join(configDir(), "kimi", "auth.json")
+}
+function legacyFile(): string {
+ return join(legacyConfigDir(), "kimi", "auth.json")
+}
const KEYCHAIN_SERVICE = "claude-code-proxy.kimi"
const KEYCHAIN_ACCOUNT = "auth"
@@ -23,8 +27,17 @@ export async function loadAuth(): Promise<StoredAuth | undefined> {
return JSON.parse(raw) as StoredAuth
}
+ const primary = file()
+ try {
+ const raw = await readFile(primary, "utf8")
+ return JSON.parse(raw) as StoredAuth
+ } catch (err: any) {
+ if (err?.code !== "ENOENT") throw err
+ }
+ const legacy = legacyFile()
+ if (legacy === primary) return undefined
try {
- const raw = await readFile(FILE, "utf8")
+ const raw = await readFile(legacy, "utf8")
return JSON.parse(raw) as StoredAuth
} catch (err: any) {
if (err?.code === "ENOENT") return undefined
@@ -38,10 +51,11 @@ export async function saveAuth(auth: StoredAuth): Promise<void> {
return
}
- await mkdir(dirname(FILE), { recursive: true, mode: 0o700 })
- const tmp = `${FILE}.${process.pid}.${Date.now()}.tmp`
+ const path = file()
+ await mkdir(dirname(path), { recursive: true, mode: 0o700 })
+ const tmp = `${path}.${process.pid}.${Date.now()}.tmp`
await writeFile(tmp, JSON.stringify(auth, null, 2), { encoding: "utf8", mode: 0o600 })
- await rename(tmp, FILE)
+ await rename(tmp, path)
}
export async function clearAuth(): Promise<void> {
@@ -50,13 +64,15 @@ export async function clearAuth(): Promise<void> {
return
}
- try {
- await unlink(FILE)
- } catch (err: any) {
- if (err?.code !== "ENOENT") throw err
+ for (const path of [file(), legacyFile()]) {
+ try {
+ await unlink(path)
+ } catch (err: any) {
+ if (err?.code !== "ENOENT") throw err
+ }
}
}
export function authPath(): string {
- return process.platform === "darwin" ? "macOS Keychain" : FILE
+ return process.platform === "darwin" ? "macOS Keychain" : file()
}
diff --git a/src/providers/kimi/client.ts b/src/providers/kimi/client.ts
index 07d27b7..ca1ff0a 100644
--- a/src/providers/kimi/client.ts
+++ b/src/providers/kimi/client.ts
@@ -1,4 +1,4 @@
-import { API_BASE_URL } from "./auth/constants.ts"
+import { apiBaseUrl } from "./auth/constants.ts"
import { commonHeaders } from "./auth/headers.ts"
import { forceRefresh, getAuth, KimiAuthUnauthorizedError } from "./auth/manager.ts"
import type { Logger } from "../../log.ts"
@@ -100,14 +100,14 @@ async function doFetch(
const bodyJson = JSON.stringify(body)
log.debug("posting to kimi", {
- url: `${API_BASE_URL}/chat/completions`,
+ url: `${apiBaseUrl()}/chat/completions`,
model: body.model,
messageCount: body.messages.length,
toolCount: body.tools?.length ?? 0,
requestBodyBytes: new TextEncoder().encode(bodyJson).length,
})
- return fetch(`${API_BASE_URL}/chat/completions`, {
+ return fetch(`${apiBaseUrl()}/chat/completions`, {
method: "POST",
headers,
body: bodyJson,
diff --git a/src/providers/kimi/index.ts b/src/providers/kimi/index.ts
index 1112ee1..56ddbce 100644
--- a/src/providers/kimi/index.ts
+++ b/src/providers/kimi/index.ts
@@ -14,8 +14,7 @@ import { KimiError, postKimi } from "./client.ts"
import { runDeviceLogin } from "./auth/login.ts"
import { persistInitialTokens } from "./auth/manager.ts"
import { loadAuth, clearAuth, authPath } from "./auth/token-store.ts"
-
-const VERBOSE = !!process.env.CCP_LOG_VERBOSE
+import { logVerbose } from "../../config.ts"
function jsonError(status: number, type: string, message: string): Response {
return new Response(JSON.stringify({ type: "error", error: { type, message } }), {
@@ -49,7 +48,7 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
stream: wantStream,
requestedMaxTokens: body.max_tokens,
})
- if (VERBOSE) log.debug("anthropic request body", { body })
+ if (logVerbose()) log.debug("anthropic request body", { body })
const resolvedModel = resolveModel(body.model)
try {
@@ -83,7 +82,7 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
thinking: translated.thinking?.type,
maxTokens: translated.max_tokens,
})
- if (VERBOSE) log.debug("translated request body", { body: translated })
+ if (logVerbose()) log.debug("translated request body", { body: translated })
let upstream
try {
diff --git a/src/providers/kimi/translate/reducer.ts b/src/providers/kimi/translate/reducer.ts
index 3d6eec8..841e2f9 100644
--- a/src/providers/kimi/translate/reducer.ts
+++ b/src/providers/kimi/translate/reducer.ts
@@ -1,8 +1,6 @@
import { parseSseStream } from "../../../sse.ts"
import type { Logger } from "../../../log.ts"
-const VERBOSE = !!process.env.CCP_LOG_VERBOSE
-
export class UpstreamStreamError extends Error {
constructor(
public kind: "rate_limit" | "failed",