Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
logging: restore debug capture parity
Raine Virtaf73599981469
diff --git a/README.md b/README.mdindex f1b557c..3045353 100644--- a/README.md+++ b/README.md@@ -630,9 +630,9 @@ Windows, and at| `PORT` | `port` | `18765` | Proxy listen port || `CCP_CONFIG_DIR` | unset | platform config dir | Per-process config directory; Cursor auth uses it for file storage || `XDG_STATE_HOME` | — | `~/.local/state` | Linux/macOS 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 |-| `CCP_TRAFFIC_LOG` | — | unset | Write per-request traffic captures under `traffic/` for session debugging |+| `CCP_LOG_STDERR` | `log.stderr` | unset | Also mirror log lines to stderr; any env value enables it |+| `CCP_LOG_VERBOSE` | `log.verbose` | unset | Preserve full string fields in `proxy.log`; any env value enables it |+| `CCP_TRAFFIC_LOG` | — | unset | Write full per-request traffic captures under `traffic/` for session debugging (`1`, `true`, or `yes`) || `CCP_ALIAS_PROVIDER` | `aliasProvider` | `codex` | Route Anthropic-style aliases (`haiku`, `sonnet`, `opus`, `claude-*`) through `codex` or `kimi` || `CCP_KIMI_OAUTH_HOST` | `kimi.oauthHost` | `https://auth.kimi.com` | Override Kimi's OAuth host (debugging only) || `CCP_KIMI_BASE_URL` | `kimi.baseUrl` | `https://api.kimi.com/coding/v1` | Override Kimi's API base URL |@@ -686,6 +686,8 @@ sticky sessions or shared state before enabling continuation.sequence numbers so sorted filenames preserve emission order. Token andaccount headers are redacted, but prompt and tool content are intentionallypreserved for debugging.+ For the most complete debugging run, use `CCP_LOG_STDERR=1 CCP_LOG_VERBOSE=1+ CCP_TRAFFIC_LOG=1`.- `config.json` — optional configuration file (see table above). It lives at`~/.config/claude-code-proxy/config.json` on macOS,`${XDG_CONFIG_HOME:-$HOME/.config}/claude-code-proxy/config.json` on Linux,diff --git a/src/config.rs b/src/config.rsindex f06df4e..376b073 100644--- a/src/config.rs+++ b/src/config.rs@@ -93,14 +93,6 @@ fn parse_alias(raw: &str) -> Option<AliasProvider> {}}-fn parse_bool_raw(raw: &str) -> Option<bool> {- match raw.to_ascii_lowercase().as_str() {- "1" | "true" | "yes" => Some(true),- "0" | "false" | "no" => Some(false),- _ => None,- }-}-fn read_file_config(config_dir: &Path) -> Option<FileConfig> {let path = config_dir.join("config.json");let raw = fs::read_to_string(path).ok()?;@@ -140,10 +132,8 @@ pub fn load_config() -> LoadedConfig {out.port = port;}- if let Some(raw) = env.get("CCP_LOG_VERBOSE") {- if let Some(value) = parse_bool_raw(raw) {- out.log_verbose = value;- }+ if env.contains_key("CCP_LOG_VERBOSE") {+ out.log_verbose = true;} else if let Some(value) = file.as_ref().and_then(|f| f.log.as_ref().and_then(|v| v.verbose))@@ -151,10 +141,8 @@ pub fn load_config() -> LoadedConfig {out.log_verbose = value;}- if let Some(raw) = env.get("CCP_LOG_STDERR") {- if let Some(value) = parse_bool_raw(raw) {- out.log_stderr = value;- }+ if env.contains_key("CCP_LOG_STDERR") {+ out.log_stderr = true;} else if let Some(value) = file.as_ref().and_then(|f| f.log.as_ref().and_then(|v| v.stderr))@@ -506,6 +494,35 @@ mod tests {fn clear_env() {unsafe {std::env::remove_var("CCP_CODEX_TRANSPORT");+ std::env::remove_var("CCP_CONFIG_DIR");+ std::env::remove_var("CCP_LOG_VERBOSE");+ std::env::remove_var("CCP_LOG_STDERR");+ }+ }++ struct EnvGuard {+ key: &'static str,+ previous: Option<std::ffi::OsString>,+ }++ impl EnvGuard {+ fn set(key: &'static str, value: impl AsRef<std::ffi::OsStr>) -> Self {+ let previous = std::env::var_os(key);+ unsafe {+ std::env::set_var(key, value);+ }+ Self { key, previous }+ }+ }++ impl Drop for EnvGuard {+ fn drop(&mut self) {+ unsafe {+ match self.previous.take() {+ Some(value) => std::env::set_var(self.key, value),+ None => std::env::remove_var(self.key),+ }+ }}}@@ -576,4 +593,35 @@ mod tests {assert_eq!(CodexTransport::WebSocket.as_str(), "websocket");assert_eq!(CodexTransport::Auto.as_str(), "auto");}++ #[test]+ fn log_env_presence_enables_legacy_verbose_and_stderr() {+ let _guard = ENV_LOCK.lock().unwrap();+ clear_env();+ let config = tempfile::TempDir::new().unwrap();+ let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());+ let _verbose_env = EnvGuard::set("CCP_LOG_VERBOSE", "0");+ let _stderr_env = EnvGuard::set("CCP_LOG_STDERR", "");++ let loaded = load_config();+ assert!(loaded.log_verbose);+ assert!(loaded.log_stderr);+ }++ #[test]+ fn log_config_values_apply_without_env() {+ let _guard = ENV_LOCK.lock().unwrap();+ clear_env();+ let config = tempfile::TempDir::new().unwrap();+ std::fs::write(+ config.path().join("config.json"),+ r#"{"log":{"verbose":true,"stderr":true}}"#,+ )+ .unwrap();+ let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());++ let loaded = load_config();+ assert!(loaded.log_verbose);+ assert!(loaded.log_stderr);+ }}diff --git a/src/logging.rs b/src/logging.rsindex fa69891..e8ea24b 100644--- a/src/logging.rs+++ b/src/logging.rs@@ -162,8 +162,8 @@ fn redact_with_depth(value: Value, depth: u8) -> Value {Value::String(s) => {if config::log_verbose() {Value::String(s)- } else if s.len() > 1000 {- Value::String(format!("{}…[{} more]", &s[..1000], s.len() - 1000))+ } else if s.len() > 4000 {+ Value::String(format!("{}…[{} more]", &s[..4000], s.len() - 4000))} else {Value::String(s)}diff --git a/src/server.rs b/src/server.rsindex 8bf57c1..aba25f5 100644--- a/src/server.rs+++ b/src/server.rs@@ -1,5 +1,6 @@use crate::{anthropic::json_error,+ logging::{Logger, REDACT_KEYS, create_logger},provider::RequestContext,registry::{Registry, normalize_incoming_model},session::{self, SessionState},@@ -14,8 +15,9 @@ use axum::{routing::{get, post},};use serde::de::DeserializeOwned;-use serde_json::json;+use serde_json::{Map, Value, json};use std::sync::Arc;+use std::time::Instant;use tokio::net::TcpListener;use uuid::Uuid;@@ -25,6 +27,20 @@ pub struct ServerConfig {pub async fn serve(config: ServerConfig) -> anyhow::Result<()> {let listener = TcpListener::bind(("127.0.0.1", config.port)).await?;+ create_logger("server").info(+ "server listening",+ Some(serde_json::Map::from_iter([+ ("port".to_string(), json!(config.port)),+ (+ "logDir".to_string(),+ json!(+ crate::paths::log_file()+ .parent()+ .map(|path| path.display().to_string())+ ),+ ),+ ])),+ );let app = app(Arc::new(Registry::with_default_alias()));axum::serve(listener, app).await?;Ok(())@@ -59,33 +75,74 @@ async fn dispatch_request(req: Request<Body>,count_tokens: bool,) -> Response {+ let started_at = Instant::now();+ let log = create_logger("server");+ let req_id = Uuid::new_v4().to_string();+ let method = req.method().clone();+ let uri = req.uri().clone();+ let headers = req.headers().clone();+ let path = uri.path().to_string();+ let query = redacted_query(&uri);+ log.info(+ "request",+ Some(serde_json::Map::from_iter([+ ("reqId".to_string(), json!(&req_id)),+ ("method".to_string(), json!(method.as_str())),+ ("path".to_string(), json!(&path)),+ ("query".to_string(), json!(&query)),+ ])),+ );let session_id = req.headers().get("x-claude-code-session-id").and_then(|value| value.to_str().ok()).map(std::string::ToString::to_string);- let req_id = Uuid::new_v4().to_string();let now = current_millis();let body_bytes = match axum::body::to_bytes(req.into_body(), usize::MAX).await {Ok(bytes) => bytes,Err(err) => {- return json_error(+ let response = json_error(StatusCode::BAD_REQUEST,"invalid_request_error",format!("Invalid JSON: {err}"),);+ log_request_completed(+ &log,+ RequestLogContext {+ req_id: &req_id,+ provider: None,+ model: None,+ count_tokens,+ status: response.status(),+ started_at,+ },+ );+ return response;}};let body: crate::anthropic::schema::MessagesRequest = match parse_json_body(&body_bytes) {Ok(body) => body,- Err(response) => return *response,+ Err(response) => {+ log_request_completed(+ &log,+ RequestLogContext {+ req_id: &req_id,+ provider: None,+ model: None,+ count_tokens,+ status: response.status(),+ started_at,+ },+ );+ return *response;+ }};let model = match body.model.as_deref() {Some(model) => model,None => {- return json_error(+ let response = json_error(StatusCode::BAD_REQUEST,"invalid_request_error",format!(@@ -93,6 +150,18 @@ async fn dispatch_request(registry.unknown_model_message()),);+ log_request_completed(+ &log,+ RequestLogContext {+ req_id: &req_id,+ provider: None,+ model: None,+ count_tokens,+ status: response.status(),+ started_at,+ },+ );+ return response;}};@@ -113,7 +182,14 @@ async fn dispatch_request(let provider = match provider {Some(provider) => provider,None => {- return json_error(+ log.warn(+ "unknown model",+ Some(serde_json::Map::from_iter([+ ("reqId".to_string(), json!(&req_id)),+ ("model".to_string(), json!(&normalized_model)),+ ])),+ );+ let response = json_error(StatusCode::BAD_REQUEST,"invalid_request_error",format!(@@ -121,6 +197,18 @@ async fn dispatch_request(registry.unknown_model_message()),);+ log_request_completed(+ &log,+ RequestLogContext {+ req_id: &req_id,+ provider: None,+ model: Some(&normalized_model),+ count_tokens,+ status: response.status(),+ started_at,+ },+ );+ return response;}};@@ -145,11 +233,16 @@ async fn dispatch_request(capture.write_json("000-metadata",&json!({- "reqId": req_id,- "sessionId": session_id,+ "reqId": &req_id,+ "sessionId": &session_id,"sessionSeq": current.as_ref().map(|s| s.seq),+ "kind": if count_tokens { "count_tokens" } else { "messages" },"provider": provider.name(),- "model": normalized_model,+ "model": &normalized_model,+ "method": method.as_str(),+ "path": &path,+ "query": &query,+ "headers": headers_to_record(&headers),}),);capture.write_json(@@ -159,18 +252,84 @@ async fn dispatch_request(}let context = RequestContext {- req_id,+ req_id: req_id.clone(),session_id,session_seq: current.map(|s| s.seq),provider: provider.name().to_string(),traffic,};- if count_tokens {+ let response = if count_tokens {provider.handle_count_tokens(body, context).await} else {provider.handle_messages(body, context).await+ };+ log_request_completed(+ &log,+ RequestLogContext {+ req_id: &req_id,+ provider: Some(provider.name()),+ model: Some(&normalized_model),+ count_tokens,+ status: response.status(),+ started_at,+ },+ );+ response+}++struct RequestLogContext<'a> {+ req_id: &'a str,+ provider: Option<&'a str>,+ model: Option<&'a str>,+ count_tokens: bool,+ status: StatusCode,+ started_at: Instant,+}++fn log_request_completed(log: &Logger, ctx: RequestLogContext<'_>) {+ log.info(+ "request_completed",+ Some(serde_json::Map::from_iter([+ ("reqId".to_string(), json!(ctx.req_id)),+ ("provider".to_string(), json!(ctx.provider)),+ ("model".to_string(), json!(ctx.model)),+ ("countTokens".to_string(), json!(ctx.count_tokens)),+ ("status".to_string(), json!(ctx.status.as_u16())),+ (+ "ms".to_string(),+ json!(ctx.started_at.elapsed().as_millis()),+ ),+ ])),+ );+}++fn headers_to_record(headers: &http::HeaderMap) -> Value {+ let mut out = Map::new();+ for (key, value) in headers {+ if let Ok(raw) = value.to_str() {+ out.insert(key.as_str().to_string(), Value::String(raw.to_string()));+ }+ }+ Value::Object(out)+}++fn redacted_query(uri: &http::Uri) -> Value {+ let mut out = Map::new();+ let Some(query) = uri.query() else {+ return Value::Object(out);+ };+ for (key, value) in url::form_urlencoded::parse(query.as_bytes()) {+ let key = key.into_owned();+ let lower = key.to_lowercase();+ let value = if REDACT_KEYS.contains(&lower.as_str()) {+ Value::String(format!("[redacted len={}]", value.len()))+ } else {+ Value::String(value.into_owned())+ };+ out.insert(key, value);}+ Value::Object(out)}fn parse_json_body<T>(body: &[u8]) -> Result<T, Box<Response>>diff --git a/src/traffic.rs b/src/traffic.rsindex 7b875cd..132325b 100644--- a/src/traffic.rs+++ b/src/traffic.rs@@ -71,7 +71,12 @@ impl TrafficCapture {}pub fn write_text(&self, name: &str, text: &str) {- let path = self.next_artifact_path(name, false);+ let file = if name.ends_with(".txt") {+ name.to_string()+ } else {+ format!("{name}.txt")+ };+ let path = self.next_artifact_path(&file, false);let _ = write_bytes(path, text.as_bytes());}diff --git a/tests/foundation.rs b/tests/foundation.rsindex 7d028a1..dd044fc 100644--- a/tests/foundation.rs+++ b/tests/foundation.rs@@ -111,7 +111,7 @@ fn logging_redaction_and_truncation() {let long = "a".repeat(5000);let long_payload = redact_value(json!({"text": long}));let text = long_payload["text"].as_str().unwrap();- assert!(text.contains("[4000 more]"));+ assert!(text.contains("[1000 more]"));}#[test]