chatccc 0.2.159 → 0.2.161

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatccc",
-  "version": "0.2.159",
+  "version": "0.2.161",
   "description": "Feishu bot bridge for Claude Code",
   "license": "Apache-2.0",
   "type": "module",
@@ -36,6 +36,7 @@
     "demo:claude-hi": "tsx demo/claude_say_hi.ts",
     "demo:codex-hi": "tsx demo/codex_say_hi.ts",
     "demo:ilink-echo": "tsx demo/ilink_echo_probe.ts",
+    "claude-proxy": "tsx src/litellm-proxy.ts",
     "test": "vitest run",
     "test:watch": "vitest",
     "postinstall": "node scripts/postinstall-sharp-check.mjs"

package/src/__tests__/cards.test.ts

@@ -32,27 +32,30 @@ describe("truncateContent", () => {
     expect(resultLines[20]).toBe("line 25");
   });
 
-  it("truncates chars when exceeding maxChars", () => {
-    const long = "x".repeat(9000);
-    const result = truncateContent(long, 100, 500);
-    expect(result.length).toBeLessThanOrEqual(503); // "..." + 500 chars
-    expect(result.startsWith("...")).toBe(true);
-  });
-
   it("returns empty string for empty input", () => {
     expect(truncateContent("")).toBe("");
   });
 
-  it("respects custom maxLines and maxChars", () => {
+  it("respects custom maxLines", () => {
     const lines = Array.from({ length: 10 }, (_, i) => `line ${i + 1}`);
     const text = lines.join("\n");
-    const result = truncateContent(text, 5, 1000);
+    const result = truncateContent(text, 5);
     const resultLines = result.split("\n");
     expect(resultLines[0]).toBe("line 1");
     expect(resultLines[1]).toBe("...");
     expect(resultLines[resultLines.length - 1]).toBe("line 10");
     expect(resultLines.length).toBe(6); // 1 first + "..." + 4 last
   });
+
+  it("skips leading empty lines, preserves first non-empty line", () => {
+    const lines = Array.from({ length: 25 }, (_, i) => `line ${i + 1}`);
+    const text = "\n\n\n" + lines.join("\n");
+    const result = truncateContent(text);
+    const resultLines = result.split("\n");
+    expect(resultLines[0]).toBe("line 1");
+    expect(resultLines[1]).toBe("...");
+    expect(resultLines.length).toBe(21); // 1 first + "..." + 19 last
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -106,11 +109,11 @@ describe("buildProgressCard", () => {
     const card = buildProgressCard("hello");
     const parsed = JSON.parse(card);
     const buttons = parsed.body.elements.filter((e: any) => e.tag === "button");
-    expect(buttons).toHaveLength(2);
-    expect(buttons[0].text.content).toBe("查看状态（/state）");
-    expect(buttons[0].value).toEqual({ action: "state" });
-    expect(buttons[0].element_id).toBe("action_state");
-    expect(buttons[1].text.content).toBe("停止生成（/stop）");
+    expect(buttons).toHaveLength(2);
+    expect(buttons[0].text.content).toBe("查看状态（/state）");
+    expect(buttons[0].value).toEqual({ action: "state" });
+    expect(buttons[0].element_id).toBe("action_state");
+    expect(buttons[1].text.content).toBe("停止生成（/stop）");
   });
 
   it("hides stop button when showStop is false", () => {

package/src/__tests__/session.test.ts

@@ -9,9 +9,9 @@ const mockStreamStates = new Map<string, {
   finalReply: string;
   status?: "running" | "done" | "stopped" | "error";
   turnCount?: number;
-  finalReplySentTurn?: number;
-  finalReplySentAt?: number;
-}>();
+  finalReplySentTurn?: number;
+  finalReplySentAt?: number;
+}>();
 vi.mock("../stream-state.ts", () => ({
   readStreamState: async (sid: string) => {
     const state = mockStreamStates.get(sid);
@@ -20,9 +20,9 @@ vi.mock("../stream-state.ts", () => ({
       sessionId: sid,
       accumulatedContent: state.accumulatedContent,
       finalReply: state.finalReply,
-      finalReplySentTurn: state.finalReplySentTurn,
-      finalReplySentAt: state.finalReplySentAt,
-      status: state.status ?? "running",
+      finalReplySentTurn: state.finalReplySentTurn,
+      finalReplySentAt: state.finalReplySentAt,
+      status: state.status ?? "running",
       chunkCount: 0,
       turnCount: state.turnCount ?? 0,
       contextTokens: 0,
@@ -37,18 +37,18 @@ vi.mock("../stream-state.ts", () => ({
     finalReply: string;
     status?: "running" | "done" | "stopped" | "error";
     turnCount?: number;
-    finalReplySentTurn?: number;
-    finalReplySentAt?: number;
-  }) => {
+    finalReplySentTurn?: number;
+    finalReplySentAt?: number;
+  }) => {
     mockStreamStates.set(state.sessionId, {
       accumulatedContent: state.accumulatedContent,
       finalReply: state.finalReply,
       status: state.status,
       turnCount: state.turnCount,
-      finalReplySentTurn: state.finalReplySentTurn,
-      finalReplySentAt: state.finalReplySentAt,
-    });
-  },
+      finalReplySentTurn: state.finalReplySentTurn,
+      finalReplySentAt: state.finalReplySentAt,
+    });
+  },
   createEmptyStreamState: (sid: string, cwd: string, tool: string, turnCount: number) => ({
     sessionId: sid, status: "running" as const, accumulatedContent: "", finalReply: "", chunkCount: 0, turnCount, contextTokens: 0, updatedAt: Date.now(), cwd, tool,
   }),
@@ -396,48 +396,48 @@ describe("runAgentSession process monitor", () => {
       expect.stringContaining("进程异常结束"),
     );
   });
-  it("re-injects IM skill capabilities for each resumed Claude prompt", async () => {
-    const platform = mockPlatform("feishu");
-    setSessionPlatform(platform);
-    bindChatToSession("sid-resume", "chat-resume");
-    recordLastActiveChat("sid-resume", "chat-resume");
-
-    const sentTexts: string[] = [];
-    const adapter: ToolAdapter = {
-      displayName: "Claude Code",
-      sessionDescPrefix: "Claude Code Session:",
-      createSession: async () => ({ sessionId: "sid-resume" }),
-      getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "F:\\repo" }),
-      closeSession: async () => {},
-      prompt: async function* (_sid: string, text: string) {
-        sentTexts.push(text);
-        yield { type: "assistant", blocks: [{ type: "text", text: "done" }] };
-      },
-    };
-    _setAdapterForToolForTest("claude", adapter);
-
-    await runAgentSession("sid-resume", "first prompt", platform, "chat-resume", Date.now(), "claude");
-    await runAgentSession("sid-resume", "second prompt", platform, "chat-resume", Date.now(), "claude");
-
-    expect(sentTexts).toHaveLength(2);
-    for (const text of sentTexts) {
-      expect(text).toContain("[ChatCCC IM skill: feishu-skill]");
-      expect(text).toContain("[/ChatCCC IM skill: feishu-skill]");
-      expect(text).toContain('"session_id":"sid-resume"');
-      expect(text).toContain("http://127.0.0.1:");
-      expect(text).toContain("/api/agent/send-image");
-      expect(text).toContain("[User message]");
-      expect(text).toContain("[/User message]");
-    }
-    expect(sentTexts[0]).toContain("first prompt");
-    expect(sentTexts[1]).toContain("second prompt");
-  });
-});
-
-describe("unified display loop WeChat delta", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-    resetState();
+  it("re-injects IM skill capabilities for each resumed Claude prompt", async () => {
+    const platform = mockPlatform("feishu");
+    setSessionPlatform(platform);
+    bindChatToSession("sid-resume", "chat-resume");
+    recordLastActiveChat("sid-resume", "chat-resume");
+
+    const sentTexts: string[] = [];
+    const adapter: ToolAdapter = {
+      displayName: "Claude Code",
+      sessionDescPrefix: "Claude Code Session:",
+      createSession: async () => ({ sessionId: "sid-resume" }),
+      getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "F:\\repo" }),
+      closeSession: async () => {},
+      prompt: async function* (_sid: string, text: string) {
+        sentTexts.push(text);
+        yield { type: "assistant", blocks: [{ type: "text", text: "done" }] };
+      },
+    };
+    _setAdapterForToolForTest("claude", adapter);
+
+    await runAgentSession("sid-resume", "first prompt", platform, "chat-resume", Date.now(), "claude");
+    await runAgentSession("sid-resume", "second prompt", platform, "chat-resume", Date.now(), "claude");
+
+    expect(sentTexts).toHaveLength(2);
+    for (const text of sentTexts) {
+      expect(text).toContain("[ChatCCC IM skill: feishu-skill]");
+      expect(text).toContain("[/ChatCCC IM skill: feishu-skill]");
+      expect(text).toContain('"session_id":"sid-resume"');
+      expect(text).toContain("http://127.0.0.1:");
+      expect(text).toContain("/api/agent/send-image");
+      expect(text).toContain("[User message]");
+      expect(text).toContain("[/User message]");
+    }
+    expect(sentTexts[0]).toContain("first prompt");
+    expect(sentTexts[1]).toContain("second prompt");
+  });
+});
+
+describe("unified display loop WeChat delta", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    resetState();
     resetBindingState();
     mockStreamStates.clear();
   });
@@ -500,79 +500,79 @@ describe("unified display loop WeChat delta", () => {
       2,
       "chat-wechat",
       "tool output",
-    );
-  });
-});
-
-describe("unified display loop terminal card update", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-    resetState();
-    resetBindingState();
-    mockStreamStates.clear();
-  });
-
-  afterEach(() => {
-    stopUnifiedDisplayLoop();
-    resetBindingState();
-    vi.useRealTimers();
-  });
-
-  it("does not repeat the same terminal CardKit sequence while the prompt is still active", async () => {
-    const platform = mockPlatform("feishu");
-    platform.cardUpdate = vi.fn(async () => {
-      throw new Error("CardKit update: [300317] ErrMsg: sequence number compare failed; ");
-    });
-    setSessionPlatform(platform);
-
-    bindChatToSession("sid-terminal", "chat-terminal");
-    recordLastActiveChat("sid-terminal", "chat-terminal");
-    sessionInfoMap.set("chat-terminal", {
-      sessionId: "sid-terminal",
-      turnCount: 1,
-      lastContextTokens: 0,
-      startTime: 0,
-      tool: "claude",
-    });
-    activePrompts.set("sid-terminal", {
-      controller: new AbortController(),
-      stopped: false,
-      startTime: Date.now(),
-    });
-    displayCards.set("chat-terminal", {
-      cardId: "card-terminal",
-      sequence: 109,
-      cardBusy: false,
-      cardCreatedAt: Date.now(),
-      lastSentContent: "",
-      streamErrorNotified: false,
-      sessionId: "sid-terminal",
-      turnCount: 1,
-      dotCount: 0,
-    });
-    mockStreamStates.set("sid-terminal", {
-      accumulatedContent: "partial tool output",
-      finalReply: "",
-      status: "stopped",
-      turnCount: 1,
-    });
-
-    startUnifiedDisplayLoop();
-    await vi.advanceTimersByTimeAsync(3000);
-    await vi.advanceTimersByTimeAsync(3000);
-
-    expect(platform.cardUpdate).toHaveBeenCalledTimes(1);
-    expect(platform.cardUpdate).toHaveBeenCalledWith(
-      "card-terminal",
-      expect.any(String),
-      110,
-    );
-    expect(displayCards.get("chat-terminal")?.sequence).toBe(110);
-  });
-});
-
-describe("rebuildBindingsFromRegistry", () => {
-  let registryFile = "";
+    );
+  });
+});
+
+describe("unified display loop terminal card update", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    resetState();
+    resetBindingState();
+    mockStreamStates.clear();
+  });
+
+  afterEach(() => {
+    stopUnifiedDisplayLoop();
+    resetBindingState();
+    vi.useRealTimers();
+  });
+
+  it("does not repeat the same terminal CardKit sequence while the prompt is still active", async () => {
+    const platform = mockPlatform("feishu");
+    platform.cardUpdate = vi.fn(async () => {
+      throw new Error("CardKit update: [300317] ErrMsg: sequence number compare failed; ");
+    });
+    setSessionPlatform(platform);
+
+    bindChatToSession("sid-terminal", "chat-terminal");
+    recordLastActiveChat("sid-terminal", "chat-terminal");
+    sessionInfoMap.set("chat-terminal", {
+      sessionId: "sid-terminal",
+      turnCount: 1,
+      lastContextTokens: 0,
+      startTime: 0,
+      tool: "claude",
+    });
+    activePrompts.set("sid-terminal", {
+      controller: new AbortController(),
+      stopped: false,
+      startTime: Date.now(),
+    });
+    displayCards.set("chat-terminal", {
+      cardId: "card-terminal",
+      sequence: 109,
+      cardBusy: false,
+      cardCreatedAt: Date.now(),
+      lastSentContent: "",
+      streamErrorNotified: false,
+      sessionId: "sid-terminal",
+      turnCount: 1,
+      dotCount: 0,
+    });
+    mockStreamStates.set("sid-terminal", {
+      accumulatedContent: "partial tool output",
+      finalReply: "",
+      status: "stopped",
+      turnCount: 1,
+    });
+
+    startUnifiedDisplayLoop();
+    await vi.advanceTimersByTimeAsync(3000);
+    await vi.advanceTimersByTimeAsync(3000);
+
+    expect(platform.cardUpdate).toHaveBeenCalledTimes(1);
+    expect(platform.cardUpdate).toHaveBeenCalledWith(
+      "card-terminal",
+      expect.any(String),
+      110,
+    );
+    expect(displayCards.get("chat-terminal")?.sequence).toBe(110);
+  });
+});
+
+describe("rebuildBindingsFromRegistry", () => {
+  let registryFile = "";
 
   beforeEach(async () => {
     chatSessionMap.clear();

package/src/cards.ts

@@ -32,19 +32,21 @@ export function isCodeBlockOpen(text: string): boolean {
 
 export function truncateContent(text: string, maxLines = 20, maxChars = 8000): string {
   const lines = text.split("\n");
+  // 跳过开头空行
+  let startIdx = 0;
+  while (startIdx < lines.length && lines[startIdx].trim() === "") {
+    startIdx++;
+  }
+  const effectiveLines = lines.slice(startIdx);
   let displayText: string;
-  if (lines.length > maxLines) {
-    const firstLine = lines[0];
-    const lastLines = lines.slice(-(maxLines - 1)).join("\n");
+  if (effectiveLines.length > maxLines) {
+    const firstLine = effectiveLines[0];
+    const lastLines = effectiveLines.slice(-(maxLines - 1)).join("\n");
     displayText = firstLine + "\n...\n" + lastLines;
   } else {
     displayText = text;
   }
 
-  if (displayText.length > maxChars) {
-    displayText = "..." + displayText.slice(-maxChars);
-  }
-
   // 截断后如果代码块未闭合，补上闭合标记，避免后续追加内容时误入代码块
   if (isCodeBlockOpen(displayText)) {
     displayText += "\n```";
@@ -91,8 +93,8 @@ export function buildProgressCard(
       tag: "button",
       text: { tag: "plain_text", content: "查看状态（/state）" },
       type: "default",
-      value: { action: "state" },
-      element_id: "action_state",
+      value: { action: "state" },
+      element_id: "action_state",
     });
     elements.push({
       tag: "button",

package/src/litellm-proxy.ts

@@ -0,0 +1,374 @@
+import http, { createServer, type IncomingHttpHeaders, type IncomingMessage, type ServerResponse } from "node:http";
+import https from "node:https";
+import { createWriteStream } from "node:fs";
+import { mkdir, writeFile, appendFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+type ProxyConfig = {
+  host: string;
+  port: number;
+  upstream: URL;
+  logDir: string;
+  logSecrets: boolean;
+};
+
+type RequestLog = {
+  id: string;
+  timestamp: string;
+  method: string;
+  path: string;
+  upstreamUrl: string;
+  headers: Record<string, string | string[] | undefined>;
+  bodyBytes: number;
+  bodyFile: string;
+};
+
+type ResponseLog = {
+  id: string;
+  timestamp: string;
+  status: number;
+  statusText: string;
+  headers: Record<string, string>;
+  bodyBytes: number;
+  bodyFile: string;
+  durationMs: number;
+};
+
+type RawUpstreamResponse = {
+  statusCode: number;
+  statusMessage: string;
+  headers: IncomingHttpHeaders;
+  stream: IncomingMessage;
+};
+
+const HOP_BY_HOP_HEADERS = new Set([
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+]);
+
+const SENSITIVE_HEADERS = new Set([
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key",
+  "api-key",
+]);
+
+let requestSeq = 0;
+
+function parseArgs(argv: string[]): Partial<ProxyConfig> {
+  const parsed: Partial<ProxyConfig> = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const next = argv[i + 1];
+    const readValue = () => {
+      if (!next) throw new Error(`${arg} requires a value`);
+      i++;
+      return next;
+    };
+
+    if (arg === "--host") parsed.host = readValue();
+    else if (arg === "--port") parsed.port = Number(readValue());
+    else if (arg === "--upstream") parsed.upstream = new URL(readValue());
+    else if (arg === "--log-dir") parsed.logDir = readValue();
+    else if (arg === "--log-secrets") parsed.logSecrets = true;
+    else if (arg === "--help" || arg === "-h") {
+      printHelp();
+      process.exit(0);
+    } else {
+      throw new Error(`Unknown argument: ${arg}`);
+    }
+  }
+  return parsed;
+}
+
+function readConfig(): ProxyConfig {
+  const args = parseArgs(process.argv.slice(2));
+  const upstreamRaw = args.upstream?.toString() ??
+    process.env.CHATCCC_LITELLM_PROXY_UPSTREAM ??
+    "https://litellm.hypergryph.net";
+
+  const portRaw = args.port ?? Number(process.env.CHATCCC_LITELLM_PROXY_PORT ?? "18081");
+  if (!Number.isInteger(portRaw) || portRaw <= 0 || portRaw > 65535) {
+    throw new Error(`Invalid port: ${portRaw}`);
+  }
+
+  return {
+    host: args.host ?? process.env.CHATCCC_LITELLM_PROXY_HOST ?? "127.0.0.1",
+    port: portRaw,
+    upstream: new URL(upstreamRaw),
+    logDir: args.logDir ?? process.env.CHATCCC_LITELLM_PROXY_LOG_DIR ??
+      join(homedir(), ".chatccc", "logs", "litellm-proxy"),
+    logSecrets: args.logSecrets ?? process.env.CHATCCC_LITELLM_PROXY_LOG_SECRETS === "1",
+  };
+}
+
+function printHelp(): void {
+  console.log(`Usage: npm run claude-proxy -- [options]
+
+Options:
+  --host <host>          Listen host, default 127.0.0.1
+  --port <port>          Listen port, default 18081
+  --upstream <url>       Upstream LiteLLM base URL, default https://litellm.hypergryph.net
+  --log-dir <path>       Log directory, default %USERPROFILE%/.chatccc/logs/litellm-proxy
+  --log-secrets          Log sensitive headers instead of redacting them
+
+Equivalent env vars:
+  CHATCCC_LITELLM_PROXY_HOST
+  CHATCCC_LITELLM_PROXY_PORT
+  CHATCCC_LITELLM_PROXY_UPSTREAM
+  CHATCCC_LITELLM_PROXY_LOG_DIR
+  CHATCCC_LITELLM_PROXY_LOG_SECRETS=1
+`);
+}
+
+function nextRequestId(): string {
+  const stamp = new Date().toISOString()
+    .replace(/[-:]/g, "")
+    .replace(/\.\d{3}Z$/, "Z");
+  requestSeq = (requestSeq + 1) % 1_000_000;
+  return `${stamp}-${String(requestSeq).padStart(6, "0")}`;
+}
+
+function dayDir(baseDir: string): string {
+  return join(baseDir, new Date().toISOString().slice(0, 10));
+}
+
+function toUpstreamUrl(reqUrl: string | undefined, upstream: URL): URL {
+  const path = reqUrl && reqUrl.startsWith("/") ? reqUrl : "/";
+  return new URL(path, upstream);
+}
+
+function isHopByHopHeader(name: string): boolean {
+  return HOP_BY_HOP_HEADERS.has(name.toLowerCase());
+}
+
+function copyRequestHeaders(headers: IncomingHttpHeaders, bodyLength: number): Record<string, string | string[]> {
+  const next: Record<string, string | string[]> = {};
+  for (const [name, value] of Object.entries(headers)) {
+    const lower = name.toLowerCase();
+    if (lower === "host" || lower === "content-length" || isHopByHopHeader(lower)) continue;
+    if (Array.isArray(value)) {
+      next[name] = value;
+    } else if (typeof value === "string") {
+      next[name] = value;
+    }
+  }
+  if (bodyLength > 0) next["content-length"] = String(bodyLength);
+  return next;
+}
+
+function safeHeaders<T extends Record<string, string | string[] | undefined>>(
+  headers: T,
+  logSecrets: boolean,
+): T {
+  if (logSecrets) return headers;
+  const redacted = { ...headers };
+  for (const key of Object.keys(redacted)) {
+    if (SENSITIVE_HEADERS.has(key.toLowerCase())) {
+      redacted[key as keyof T] = "[REDACTED]" as T[keyof T];
+    }
+  }
+  return redacted;
+}
+
+function responseHeaders(headers: IncomingHttpHeaders, logSecrets: boolean): Record<string, string> {
+  const result: Record<string, string> = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (value === undefined) continue;
+    result[key] = SENSITIVE_HEADERS.has(key.toLowerCase()) && !logSecrets
+      ? "[REDACTED]"
+      : Array.isArray(value) ? value.join(", ") : value;
+  }
+  return result;
+}
+
+async function readBody(req: IncomingMessage): Promise<Buffer> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of req) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks);
+}
+
+async function appendJsonl(filePath: string, value: unknown): Promise<void> {
+  await mkdir(dirname(filePath), { recursive: true });
+  await appendFile(filePath, JSON.stringify(value) + "\n", "utf-8");
+}
+
+async function logRequest(
+  config: ProxyConfig,
+  id: string,
+  req: IncomingMessage,
+  upstreamUrl: URL,
+  body: Buffer,
+  bodyFile: string,
+): Promise<void> {
+  const log: RequestLog = {
+    id,
+    timestamp: new Date().toISOString(),
+    method: req.method ?? "GET",
+    path: req.url ?? "/",
+    upstreamUrl: upstreamUrl.toString(),
+    headers: safeHeaders(req.headers, config.logSecrets),
+    bodyBytes: body.byteLength,
+    bodyFile,
+  };
+  await writeFile(bodyFile, body);
+  await appendJsonl(join(dayDir(config.logDir), "events.jsonl"), { event: "request", ...log });
+}
+
+async function logResponse(
+  config: ProxyConfig,
+  log: ResponseLog,
+): Promise<void> {
+  await appendJsonl(join(dayDir(config.logDir), "events.jsonl"), { event: "response", ...log });
+}
+
+function requestUpstream(
+  upstreamUrl: URL,
+  req: IncomingMessage,
+  body: Buffer,
+  abortSignal: AbortSignal,
+): Promise<RawUpstreamResponse> {
+  return new Promise((resolve, reject) => {
+    const transport = upstreamUrl.protocol === "https:" ? https : http;
+    const upstreamReq = transport.request({
+      protocol: upstreamUrl.protocol,
+      hostname: upstreamUrl.hostname,
+      port: upstreamUrl.port || undefined,
+      method: req.method,
+      path: `${upstreamUrl.pathname}${upstreamUrl.search}`,
+      headers: copyRequestHeaders(req.headers, body.byteLength),
+    }, (upstreamRes) => {
+      resolve({
+        statusCode: upstreamRes.statusCode ?? 502,
+        statusMessage: upstreamRes.statusMessage ?? "",
+        headers: upstreamRes.headers,
+        stream: upstreamRes,
+      });
+    });
+
+    upstreamReq.on("error", reject);
+    abortSignal.addEventListener("abort", () => upstreamReq.destroy(new Error("client aborted")), { once: true });
+
+    if (body.byteLength > 0) upstreamReq.write(body);
+    upstreamReq.end();
+  });
+}
+
+function setResponseHeaders(res: ServerResponse, headers: IncomingHttpHeaders): void {
+  for (const [key, value] of Object.entries(headers)) {
+    if (!value || isHopByHopHeader(key)) continue;
+    res.setHeader(key, value);
+  }
+}
+
+async function writeError(res: ServerResponse, status: number, error: string): Promise<void> {
+  if (res.headersSent) {
+    res.end();
+    return;
+  }
+  res.writeHead(status, { "content-type": "application/json; charset=utf-8" });
+  res.end(JSON.stringify({ error }));
+}
+
+async function handleProxyRequest(config: ProxyConfig, req: IncomingMessage, res: ServerResponse): Promise<void> {
+  const started = Date.now();
+  const id = nextRequestId();
+  const dir = dayDir(config.logDir);
+  await mkdir(dir, { recursive: true });
+
+  const upstreamUrl = toUpstreamUrl(req.url, config.upstream);
+  const requestBody = await readBody(req);
+  const requestBodyFile = join(dir, `${id}.request.body`);
+  const responseBodyFile = join(dir, `${id}.response.body`);
+  await logRequest(config, id, req, upstreamUrl, requestBody, requestBodyFile);
+
+  const abortController = new AbortController();
+  req.on("aborted", () => abortController.abort());
+
+  let upstreamResponse: RawUpstreamResponse;
+  try {
+    upstreamResponse = await requestUpstream(upstreamUrl, req, requestBody, abortController.signal);
+  } catch (err) {
+    await appendJsonl(join(dir, "events.jsonl"), {
+      event: "error",
+      id,
+      timestamp: new Date().toISOString(),
+      message: (err as Error).message,
+      durationMs: Date.now() - started,
+    });
+    await writeError(res, 502, `Proxy upstream request failed: ${(err as Error).message}`);
+    return;
+  }
+
+  res.statusCode = upstreamResponse.statusCode;
+  res.statusMessage = upstreamResponse.statusMessage;
+  setResponseHeaders(res, upstreamResponse.headers);
+
+  let responseBytes = 0;
+  const out = createWriteStream(responseBodyFile);
+  try {
+    for await (const chunk of upstreamResponse.stream) {
+      const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      responseBytes += buf.byteLength;
+      out.write(buf);
+      if (!res.write(buf)) {
+        await new Promise<void>((resolve) => res.once("drain", resolve));
+      }
+    }
+  } catch (err) {
+    await appendJsonl(join(dir, "events.jsonl"), {
+      event: "stream_error",
+      id,
+      timestamp: new Date().toISOString(),
+      message: (err as Error).message,
+      durationMs: Date.now() - started,
+    });
+  } finally {
+    out.end();
+    res.end();
+  }
+
+  await logResponse(config, {
+    id,
+    timestamp: new Date().toISOString(),
+    status: upstreamResponse.statusCode,
+    statusText: upstreamResponse.statusMessage,
+    headers: responseHeaders(upstreamResponse.headers, config.logSecrets),
+    bodyBytes: responseBytes,
+    bodyFile: responseBodyFile,
+    durationMs: Date.now() - started,
+  });
+}
+
+async function main(): Promise<void> {
+  const config = readConfig();
+  await mkdir(config.logDir, { recursive: true });
+
+  const server = createServer((req, res) => {
+    void handleProxyRequest(config, req, res).catch(async (err) => {
+      console.error(`[litellm-proxy] unhandled request error: ${(err as Error).stack ?? (err as Error).message}`);
+      await writeError(res, 500, `Proxy internal error: ${(err as Error).message}`);
+    });
+  });
+
+  server.listen(config.port, config.host, () => {
+    console.log(`[litellm-proxy] listening on http://${config.host}:${config.port}`);
+    console.log(`[litellm-proxy] upstream ${config.upstream.toString()}`);
+    console.log(`[litellm-proxy] logs ${config.logDir}`);
+  });
+}
+
+void main().catch((err) => {
+  console.error(`[litellm-proxy] failed to start: ${(err as Error).message}`);
+  process.exit(1);
+});