cc-wiretap 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,313 @@
+import * as mockttp from 'mockttp';
+import { CompletedRequest } from 'mockttp';
+import { Server } from 'http';
+
+interface CAConfig {
+    certPath: string;
+    keyPath: string;
+    cert: string;
+    key: string;
+}
+declare function loadOrGenerateCA(): Promise<CAConfig>;
+declare function getCAPath(): string;
+
+interface ClaudeMessage {
+    role: 'user' | 'assistant';
+    content: string | ClaudeContent[];
+}
+type ClaudeContent = TextContent | ImageContent | ToolUseContent | ToolResultContent;
+interface TextContent {
+    type: 'text';
+    text: string;
+}
+interface ImageContent {
+    type: 'image';
+    source: {
+        type: 'base64';
+        media_type: string;
+        data: string;
+    };
+}
+interface ToolUseContent {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+interface ToolResultContent {
+    type: 'tool_result';
+    tool_use_id: string;
+    content: string | ClaudeContent[];
+    is_error?: boolean;
+}
+interface ClaudeRequest {
+    model: string;
+    max_tokens: number;
+    messages: ClaudeMessage[];
+    system?: string | SystemBlock[];
+    stream?: boolean;
+    tools?: ClaudeTool[];
+    tool_choice?: ToolChoice;
+    metadata?: Record<string, unknown>;
+    stop_sequences?: string[];
+    temperature?: number;
+    top_p?: number;
+    top_k?: number;
+}
+interface SystemBlock {
+    type: 'text';
+    text: string;
+    cache_control?: {
+        type: 'ephemeral';
+    };
+}
+interface ClaudeTool {
+    name: string;
+    description: string;
+    input_schema: Record<string, unknown>;
+}
+interface ToolChoice {
+    type: 'auto' | 'any' | 'tool';
+    name?: string;
+}
+interface ClaudeMessageResponse {
+    id: string;
+    type: 'message';
+    role: 'assistant';
+    content: ClaudeContent[];
+    model: string;
+    stop_reason: 'end_turn' | 'max_tokens' | 'stop_sequence' | 'tool_use' | null;
+    stop_sequence: string | null;
+    usage: TokenUsage;
+}
+interface ClaudeErrorResponse {
+    type: 'error';
+    error: {
+        type: string;
+        message: string;
+    };
+}
+type ClaudeResponse = ClaudeMessageResponse | ClaudeErrorResponse;
+interface TokenUsage {
+    input_tokens: number;
+    output_tokens: number;
+    cache_creation_input_tokens?: number;
+    cache_read_input_tokens?: number;
+}
+type SSEEvent = MessageStartEvent | ContentBlockStartEvent | ContentBlockDeltaEvent | ContentBlockStopEvent | MessageDeltaEvent | MessageStopEvent | PingEvent | ErrorEvent;
+interface MessageStartEvent {
+    type: 'message_start';
+    message: {
+        id: string;
+        type: 'message';
+        role: 'assistant';
+        content: [];
+        model: string;
+        stop_reason: null;
+        stop_sequence: null;
+        usage: TokenUsage;
+    };
+}
+interface ContentBlockStartEvent {
+    type: 'content_block_start';
+    index: number;
+    content_block: TextContent | ToolUseBlockStart;
+}
+interface ToolUseBlockStart {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+interface ContentBlockDeltaEvent {
+    type: 'content_block_delta';
+    index: number;
+    delta: TextDelta | InputJsonDelta;
+}
+interface TextDelta {
+    type: 'text_delta';
+    text: string;
+}
+interface InputJsonDelta {
+    type: 'input_json_delta';
+    partial_json: string;
+}
+interface ContentBlockStopEvent {
+    type: 'content_block_stop';
+    index: number;
+}
+interface MessageDeltaEvent {
+    type: 'message_delta';
+    delta: {
+        stop_reason: 'end_turn' | 'max_tokens' | 'stop_sequence' | 'tool_use';
+        stop_sequence: string | null;
+    };
+    usage: {
+        output_tokens: number;
+    };
+}
+interface MessageStopEvent {
+    type: 'message_stop';
+}
+interface PingEvent {
+    type: 'ping';
+}
+interface ErrorEvent {
+    type: 'error';
+    error: {
+        type: string;
+        message: string;
+    };
+}
+type WSMessage = WSRequestStart | WSRequestBody | WSResponseStart | WSResponseChunk | WSResponseComplete | WSError | WSClearAll | WSHistorySync;
+interface WSHistorySync {
+    type: 'history_sync';
+    requests: InterceptedRequest[];
+}
+interface WSClearAll {
+    type: 'clear_all';
+}
+interface WSRequestStart {
+    type: 'request_start';
+    requestId: string;
+    timestamp: number;
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+}
+interface WSRequestBody {
+    type: 'request_body';
+    requestId: string;
+    body: ClaudeRequest;
+}
+interface WSResponseStart {
+    type: 'response_start';
+    requestId: string;
+    timestamp: number;
+    statusCode: number;
+    headers: Record<string, string>;
+}
+interface WSResponseChunk {
+    type: 'response_chunk';
+    requestId: string;
+    event: SSEEvent;
+}
+interface WSResponseComplete {
+    type: 'response_complete';
+    requestId: string;
+    timestamp: number;
+    response: ClaudeResponse;
+    durationMs: number;
+}
+interface WSError {
+    type: 'error';
+    requestId?: string;
+    error: string;
+    timestamp: number;
+}
+interface InterceptedRequest {
+    id: string;
+    timestamp: number;
+    method: string;
+    url: string;
+    requestHeaders: Record<string, string>;
+    requestBody?: ClaudeRequest;
+    responseStartTime?: number;
+    statusCode?: number;
+    responseHeaders?: Record<string, string>;
+    sseEvents: SSEEvent[];
+    response?: ClaudeResponse;
+    durationMs?: number;
+    error?: string;
+}
+
+interface WiretapWebSocketServerOptions {
+    port?: number;
+    server?: Server;
+}
+declare class WiretapWebSocketServer {
+    private wss;
+    private clients;
+    private requests;
+    constructor(options?: WiretapWebSocketServerOptions);
+    private sendCurrentState;
+    private sendToClient;
+    broadcast(message: WSMessage): void;
+    addRequest(request: InterceptedRequest): void;
+    getRequest(requestId: string): InterceptedRequest | undefined;
+    getClientCount(): number;
+    getRequestCount(): number;
+    close(): Promise<void>;
+    getPort(): number | undefined;
+}
+
+declare const CLAUDE_API_HOSTS: string[];
+declare class ClaudeInterceptor {
+    private wsServer;
+    private activeRequests;
+    constructor(wsServer: WiretapWebSocketServer);
+    isClaudeRequest(request: CompletedRequest): boolean;
+    handleRequest(request: CompletedRequest): Promise<string | null>;
+    handleResponseStart(requestId: string, statusCode: number, headers: Record<string, string>): Promise<void>;
+    handleResponseChunk(requestId: string, chunk: Buffer | string): void;
+    handleResponseComplete(requestId: string): Promise<void>;
+    handleResponseError(requestId: string, error: Error): void;
+    handleNonStreamingResponse(requestId: string, _statusCode: number, bodyText: string): void;
+    private headersToRecord;
+    getActiveRequestCount(): number;
+}
+
+interface ProxyOptions {
+    port: number;
+    ca: CAConfig;
+    wsServer: WiretapWebSocketServer;
+}
+interface ProxyServer {
+    server: mockttp.Mockttp;
+    interceptor: ClaudeInterceptor;
+    stop: () => Promise<void>;
+}
+declare function createProxy(options: ProxyOptions): Promise<ProxyServer>;
+
+/**
+ * Parses a complete SSE stream chunk (may contain multiple events)
+ */
+declare function parseSSEChunk(chunk: string): SSEEvent[];
+/**
+ * SSE Stream Parser class for handling streaming data
+ */
+declare class SSEStreamParser {
+    private buffer;
+    private events;
+    /**
+     * Feed data to the parser
+     */
+    feed(data: string): SSEEvent[];
+    /**
+     * Flush any remaining buffered data
+     */
+    flush(): SSEEvent[];
+    /**
+     * Get all parsed events
+     */
+    getAllEvents(): SSEEvent[];
+    /**
+     * Reset the parser
+     */
+    reset(): void;
+}
+/**
+ * Reconstructs a complete ClaudeMessageResponse from SSE events.
+ * Streaming responses are always message responses (errors are non-streaming).
+ */
+declare function reconstructResponseFromEvents(events: SSEEvent[]): ClaudeMessageResponse | null;
+
+declare function createSetupServer(proxyPort: number): Server;
+declare function getSetupCommand(): string;
+
+interface UIServerOptions {
+    port: number;
+}
+declare function createUIServer(options: UIServerOptions): Server | null;
+
+export { CLAUDE_API_HOSTS, type ClaudeContent, type ClaudeErrorResponse, ClaudeInterceptor, type ClaudeMessage, type ClaudeMessageResponse, type ClaudeRequest, type ClaudeResponse, type ClaudeTool, type ContentBlockDeltaEvent, type ContentBlockStartEvent, type ContentBlockStopEvent, type ErrorEvent, type ImageContent, type InputJsonDelta, type InterceptedRequest, type MessageDeltaEvent, type MessageStartEvent, type MessageStopEvent, type PingEvent, type SSEEvent, SSEStreamParser, type SystemBlock, type TextContent, type TextDelta, type TokenUsage, type ToolChoice, type ToolResultContent, type ToolUseBlockStart, type ToolUseContent, type WSClearAll, type WSError, type WSHistorySync, type WSMessage, type WSRequestBody, type WSRequestStart, type WSResponseChunk, type WSResponseComplete, type WSResponseStart, WiretapWebSocketServer, createProxy, createSetupServer, createUIServer, getCAPath, getSetupCommand, loadOrGenerateCA, parseSSEChunk, reconstructResponseFromEvents };