claude-use 4.5.0 → 5.0.0

package/dist/types/headroom/mitm.d.ts

@@ -1,138 +0,0 @@
-import type { IncomingHttpHeaders, IncomingMessage, ServerResponse } from "node:http";
-import * as net from "node:net";
-/**
- * A CONNECT proxy the headroom supervisor runs as a second server in its own process, so an OAuth session can have headroom's compression AND Claude Code's Remote Control at once: Remote Control refuses any `ANTHROPIC_BASE_URL` other than the real API, but happily honours `HTTPS_PROXY`, so OAuth launches route at the proxy layer instead.
- *
- * Every CONNECT target is blind-tunnelled byte for byte EXCEPT the intercept host (Claude Code's own API), whose TLS this proxy terminates with a leaf certificate signed by a locally generated CA. On the terminated session, paths headroom serves are forwarded to headroom's existing loopback port over plain HTTP (compression, per-session stats, and upstream auth unchanged; the client's Authorization header passes through untouched), and every other path is piped by this proxy to the real upstream over TLS, so Remote Control's streaming, OAuth refreshes, and unknown endpoints bypass headroom entirely.
- */
-/** The one CONNECT host whose TLS gets terminated: Claude Code's own API, the upstream headroom compresses. */
-export declare const MITM_INTERCEPT_HOST = "api.anthropic.com";
-/** Paths under this prefix are what headroom serves; everything else on the terminated session goes to the real upstream. */
-export declare const HEADROOM_SERVED_PATH_PREFIX = "/v1/";
-/** The port HTTPS is served on, both the default when a CONNECT authority names none and the port non-headroom paths are piped to on the real upstream. */
-export declare const HTTPS_PORT = 443;
-/** One parsed CONNECT authority, the host lowercased and the port defaulted. */
-export interface ConnectTarget {
-    readonly host: string;
-    readonly port: number;
-}
-/** Parses a CONNECT authority (`host:port`, or a bare `host` meaning 443), or undefined when it names no host or a non-numeric port. */
-export declare function parseConnectTarget(authority: string): ConnectTarget | undefined;
-/** Whether a CONNECT target's host (port already stripped) is the one whose TLS this proxy terminates. */
-export declare function isInterceptedHost(host: string, interceptHost: string): boolean;
-/** Whether a request path on the terminated session is one headroom serves. The query string stays part of the path: `/v1/messages?beta=true` is still headroom's. */
-export declare function servedByHeadroom(path: string | undefined): boolean;
-/**
- * Headers a forwarded HTTP message keeps: everything except the hop-by-hop set, which belongs to whichever connection carried it and must not leak onto the next one. The `Connection` header's own value can name further hop-by-hop headers (RFC 9110 section 7.6.1), so those go too. Returns a fresh object; the input is the live parser's map and is never mutated.
- */
-export declare function forwardableHeaders(headers: Readonly<IncomingHttpHeaders>): IncomingHttpHeaders;
-/** A CA certificate and its private key, both as PEM. */
-export interface CaMaterial {
-    readonly certPem: string;
-    readonly keyPem: string;
-}
-/** A TLS leaf certificate and its private key, both as PEM. */
-export interface LeafCert {
-    readonly certPem: string;
-    readonly keyPem: string;
-}
-/** Generates the local CA: one RSA keypair, self-signed, CA-only by basicConstraints and keyUsage, with a random serial. Pure node-forge, no openssl, so the same code works on every platform claude-use ships to. */
-export declare function generateCa(now: Readonly<Date>): CaMaterial;
-/** Mints the TLS leaf for one host, signed by the CA: its own RSA keypair, the host in the SAN, server-auth usage only. */
-export declare function mintLeaf(ca: CaMaterial, host: string, now: Readonly<Date>): LeafCert;
-/** Mints each host's leaf once from the CA and reuses it, because a 2048-bit keypair in pure JS costs seconds and nothing about the certificate changes between sessions. */
-export declare function createLeafCache(ca: CaMaterial, now: () => Date): (host: string) => LeafCert;
-/**
- * Persistence for the CA: generated once on the machine's first headroom start and reused forever after, because regenerating it would invalidate every child's `NODE_EXTRA_CA_CERTS` pointing at the old file. The real implementation writes the key with mode 0600; injected fakes keep it in memory.
- */
-export interface MitmCertStore {
-    /** The persisted CA, or undefined when none exists yet (or only half of it does: a cert without its key can sign nothing, so it counts as absent). */
-    readonly loadCa: () => CaMaterial | undefined;
-    /** Persists both halves of the CA, the key unreadable to other users. */
-    readonly writeCa: (ca: CaMaterial) => void;
-}
-/**
- * Loads the persisted CA, generating and persisting one when no usable CA exists. A stored pair that node-forge cannot parse is treated as absent and replaced: a truncated write is the one failure mode a regeneration can actually repair, and every child that trusted the old file needs a new `NODE_EXTRA_CA_CERTS` anyway once its CA stops parsing.
- */
-export declare function ensureCa(store: MitmCertStore, generate: () => CaMaterial): CaMaterial;
-/** Where one forwarded request goes, and how. Headroom's loopback port is plain HTTP; the real upstream is TLS. */
-interface MitmForwardTarget {
-    readonly host: string;
-    readonly port: number;
-    readonly tls: boolean;
-    /** The SNI name to present; defaults to `host`. Separated so a test can connect to a local fake while presenting the production hostname. */
-    readonly servername?: string;
-    /** Extra trust anchors for the target's certificate, when it is not system-trusted (a test's local fake upstream). */
-    readonly ca?: readonly string[];
-    /** Overrides certificate verification; production leaves it at the Node default (verify against system trust or `ca`). */
-    readonly rejectUnauthorized?: boolean;
-}
-/** Handles one parsed HTTP request on a terminated TLS session. */
-type MitmRequestHandler = (request: IncomingMessage, response: ServerResponse) => void;
-/** A bound loopback listener and how to stop it. */
-interface MitmListenerHandle {
-    readonly port: number;
-    /** Stops accepting, ends every live connection, and resolves once the port is released. */
-    readonly close: () => Promise<void>;
-}
-/** Presents one leaf's server-side TLS on CONNECTed sockets. */
-interface TlsAcceptor {
-    /** Starts the TLS handshake on a socket that has just received its CONNECT response. */
-    readonly accept: (socket: net.Socket) => void;
-    /** Drops every session this acceptor is terminating. */
-    readonly close: () => void;
-}
-/** Parses HTTP over terminated sockets and serves each request through the handler, keep-alive included. */
-interface HttpParserSession {
-    readonly serve: (socket: net.Socket) => void;
-    readonly close: () => void;
-}
-/**
- * Every effect the MITM proxy performs, injected so the routing decisions and lifecycle run against fakes in unit tests (the SupervisorPorts pattern): TCP listening, TLS termination, HTTP parsing, plain TCP tunnels, and request forwarding. The real implementation is `realMitmEffects`; the TLS round-trip test uses it with redirected targets.
- */
-export interface MitmEffects {
-    /** Binds a loopback TCP listener; `preferredPort` is tried first and any free port used when it is taken (bind, do not probe: check-then-bind races). Resolves with the bound port and a close handle. */
-    readonly listenLoopback: (preferredPort: number | undefined, onSocket: (socket: net.Socket) => void) => Promise<MitmListenerHandle>;
-    /** Builds the TLS terminator for one leaf, handing each successfully handshaked session to `onSecure`. */
-    readonly createTlsAcceptor: (leaf: LeafCert, onSecure: (secure: net.Socket) => void) => TlsAcceptor;
-    /** Builds the HTTP parser bound to one request handler. */
-    readonly createHttpSession: (handler: MitmRequestHandler) => HttpParserSession;
-    /** Opens a raw TCP connection for a blind tunnel. */
-    readonly connectTcp: (host: string, port: number) => Promise<net.Socket>;
-    /** Streams one request to `target` and the response back, never buffering a body. */
-    readonly forwardHttp: (target: MitmForwardTarget, request: IncomingMessage, response: ServerResponse) => void;
-}
-/** Everything the proxy needs to route, resolved before it starts. */
-export interface MitmServerConfig {
-    /** The CONNECT host whose TLS gets terminated. */
-    readonly interceptHost: string;
-    /**
-     * Headroom's loopback port, read per request rather than captured at start-up: the daemon can crash and restart on a different port while this proxy keeps listening, and headroom-served paths must follow it. While it reads undefined (the restart window), headroom-served paths fail fast with 502 rather than silently bypassing headroom to the real upstream.
-     */
-    readonly headroomPort: () => number | undefined;
-    /** The leaf to terminate `interceptHost` with, minted and cached per host. */
-    readonly leafFor: (host: string) => LeafCert;
-    /** Where non-headroom paths on the terminated session are piped: the real upstream over TLS. */
-    readonly upstream: MitmForwardTarget;
-}
-/** A running MITM proxy. */
-export interface MitmServerHandle {
-    readonly port: number;
-    /** Stops the listener, drops every live tunnel and terminated session, and resolves once the port is released. */
-    readonly close: () => Promise<void>;
-}
-/**
- * Starts the MITM proxy: binds the listener, mints the intercept host's leaf, and wires the per-connection routing. Resolves once the listener is bound.
- *
- * The connection flow: read the CONNECT head (never more of the stream than that, so an early ClientHello glued to the head is pushed back with `unshift` and still seen by whatever consumes the socket next), then either blind-tunnel the target or terminate its TLS and parse HTTP on the session. Every effect flows through `effects`; nothing here touches the network or filesystem itself.
- */
-export declare function startMitmServer(config: MitmServerConfig, effects: MitmEffects, preferredPort: number | undefined): Promise<MitmServerHandle>;
-/** The real `MitmEffects` over node's own net, tls, and http. `connectTcp` opens real connections to the CONNECTed host, so tests that want a blind tunnel redirect it. */
-export declare function realMitmEffects(): MitmEffects;
-/** The real `MitmCertStore` on the filesystem: `ca.pem` world-readable (it is public material), `ca.key` mode 0600 exactly, chmod'ed after the write because a create's mode bits pass through the process umask. */
-export declare function realMitmCertStore(paths: {
-    readonly headroomCaDir: string;
-    readonly headroomCaCertFile: string;
-    readonly headroomCaKeyFile: string;
-}): MitmCertStore;
-export {};