llm-interceptor 2.2.0__tar.gz → 2.3.0__tar.gz

{llm_interceptor-2.2.0 → llm_interceptor-2.3.0}/CHANGELOG.md

@@ -5,6 +5,22 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.3.0] - 2026-01-12
+
+### Added
+
+- **Watch session start log** - Print a clear session start marker when recording begins in watch mode
+
+## [2.2.1] - 2026-01-06
+
+### Added
+
+- **Configurable UI host/port** - Allow configuring the UI host and port
+
+### Fixed
+
+- **React hooks usage** - Avoid hooks in sessions map to prevent runtime errors
+
 ## [2.2.0] - 2026-01-05
 
 ### Added

{llm_interceptor-2.2.0 → llm_interceptor-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: llm-interceptor
-Version: 2.2.0
+Version: 2.3.0
 Summary: Intercept and analyze LLM traffic from AI coding tools
 Project-URL: Homepage, https://github.com/chouzz/llm-interceptor
 Project-URL: Documentation, https://github.com/chouzz/llm-interceptor#readme

{llm_interceptor-2.2.0 → llm_interceptor-2.3.0}/cci.example.toml

@@ -5,7 +5,7 @@
 # Proxy server binding address
 host = "127.0.0.1"
 # Proxy server port
-port = 8080
+port = 9090
 # Skip SSL verification for upstream connections (not recommended for production)
 ssl_insecure = false
 

{llm_interceptor-2.2.0 → llm_interceptor-2.3.0}/lli.example.toml

@@ -7,7 +7,7 @@
 # Proxy server binding address
 host = "127.0.0.1"
 # Proxy server port
-port = 8080
+port = 9090
 # Skip SSL verification for upstream connections (not recommended for production)
 ssl_insecure = false
 

{llm_interceptor-2.2.0 → llm_interceptor-2.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "llm-interceptor"
-version = "2.2.0"
+version = "2.3.0"
 description = "Intercept and analyze LLM traffic from AI coding tools"
 readme = "README.md"
 license = { text = "MIT" }

{llm_interceptor-2.2.0 → llm_interceptor-2.3.0}/src/cci/__init__.py

@@ -7,5 +7,5 @@ Note: The import package name `cci` is kept for backward compatibility.
 New code should prefer `llm_interceptor`.
 """
 
-__version__ = "2.2.0"
+__version__ = "2.3.0"
 __author__ = "LLM Interceptor Team"

{llm_interceptor-2.2.0 → llm_interceptor-2.3.0}/src/cci/cli.py

@@ -273,31 +273,31 @@ def _show_proxy_help() -> None:
     console.print()
 
     console.print("[bold]Environment Variables (Shell):[/]")
-    console.print("  export HTTP_PROXY=http://127.0.0.1:8080")
-    console.print("  export HTTPS_PROXY=http://127.0.0.1:8080")
+    console.print("  export HTTP_PROXY=http://127.0.0.1:9090")
+    console.print("  export HTTPS_PROXY=http://127.0.0.1:9090")
     console.print()
 
     console.print("[bold]Claude Code:[/]")
     console.print("  # Set in your shell before running claude:")
-    console.print("  export HTTP_PROXY=http://127.0.0.1:8080")
-    console.print("  export HTTPS_PROXY=http://127.0.0.1:8080")
+    console.print("  export HTTP_PROXY=http://127.0.0.1:9090")
+    console.print("  export HTTPS_PROXY=http://127.0.0.1:9090")
     console.print("  claude")
     console.print()
 
     console.print("[bold]Cursor IDE:[/]")
     console.print("  # Add to your shell profile (.bashrc, .zshrc):")
-    console.print("  export HTTP_PROXY=http://127.0.0.1:8080")
-    console.print("  export HTTPS_PROXY=http://127.0.0.1:8080")
+    console.print("  export HTTP_PROXY=http://127.0.0.1:9090")
+    console.print("  export HTTPS_PROXY=http://127.0.0.1:9090")
     console.print("  # Then restart Cursor from that terminal")
     console.print()
 
     console.print("[bold]curl:[/]")
-    console.print("  curl -x http://127.0.0.1:8080 https://api.anthropic.com/v1/messages ...")
+    console.print("  curl -x http://127.0.0.1:9090 https://api.anthropic.com/v1/messages ...")
     console.print()
 
     console.print("[bold]Python requests:[/]")
     console.print("  import requests")
-    console.print('  proxies = {"http": "http://127.0.0.1:8080", "https": "http://127.0.0.1:8080"}')
+    console.print('  proxies = {"http": "http://127.0.0.1:9090", "https": "http://127.0.0.1:9090"}')
     console.print("  requests.post(url, proxies=proxies, verify=False)")
 
 
@@ -373,6 +373,7 @@ def stats(file: str) -> None:
     "-p",
     type=int,
     default=9090,
+    show_default=True,
     help="Proxy server port (default: 9090)",
 )
 @click.option(
@@ -400,6 +401,19 @@ def stats(file: str) -> None:
     default=True,
     help="Launch the web UI (default: True)",
 )
+@click.option(
+    "--ui-host",
+    default="127.0.0.1",
+    show_default=True,
+    help="Host interface for the web UI (use 0.0.0.0 to expose on the network)",
+)
+@click.option(
+    "--ui-port",
+    default=8000,
+    show_default=True,
+    type=int,
+    help="Port for the web UI",
+)
 @click.pass_context
 def watch(
     ctx: click.Context,
@@ -408,6 +422,8 @@ def watch(
     include: tuple[str, ...],
     debug: bool,
     ui: bool,
+    ui_host: str,
+    ui_port: int,
 ) -> None:
     """
     Start watch mode for continuous session capture.
@@ -429,7 +445,7 @@ def watch(
 
         lli watch --include "*my-custom-api.com*"
 
-    Configure your target application to use this proxy:
+    Configure your target application to use this proxy (replace the port as needed):
 
         export HTTP_PROXY=http://127.0.0.1:9090
 
@@ -442,8 +458,12 @@ def watch(
     # Load configuration
     config = load_config(ctx.obj.get("config_path"))
 
-    # Apply CLI overrides
-    config.proxy.port = port
+    # Apply CLI overrides only when explicitly provided
+    port_source = ctx.get_parameter_source("port")
+    if port_source == click.core.ParameterSource.DEFAULT:
+        port = config.proxy.port
+    else:
+        config.proxy.port = port
 
     # Add custom glob patterns (user-provided via CLI)
     for pattern in include:
@@ -475,9 +495,6 @@ def watch(
     if ui:
         from cci.server import run_server
 
-        ui_host = "127.0.0.1"
-        ui_port = 8000  # TODO: Make configurable
-
         if _is_port_in_use(ui_host, ui_port):
             ui_url = f"http://{ui_host}:{ui_port}"
             console.print(
@@ -493,7 +510,7 @@ def watch(
             server_thread = threading.Thread(
                 target=run_server,
                 args=(watch_manager,),
-                kwargs={"port": ui_port},
+                kwargs={"host": ui_host, "port": ui_port},
                 daemon=True,
             )
             server_thread.start()
@@ -620,6 +637,12 @@ def _run_watch_loop(watch_manager: WatchManager, stop_event: threading.Event) ->
     """Run the main watch mode interaction loop."""
     from cci.watch import WatchState
 
+    def _recording_status_text(session_id: str) -> str:
+        return (
+            f"[bold red]◉[/] [red][REC][/] Session [bold]{session_id}[/] recording  "
+            f"[dim]Press [Enter] to STOP & PROCESS, [Esc] to CANCEL[/]"
+        )
+
     while not stop_event.is_set():
         state = watch_manager.state
 
@@ -644,13 +667,17 @@ def _run_watch_loop(watch_manager: WatchManager, stop_event: threading.Event) ->
                 session = watch_manager.start_recording()
                 session_id = session.session_id
 
-                # Display RECORDING status with spinner pinned at bottom
-                rec_status_text = (
-                    f"[bold red]◉[/] [red][REC][/] Session [bold]{session_id}[/] recording  "
-                    f"[dim]Press [Enter] to STOP & PROCESS, [Esc] to CANCEL[/]"
+                console.print(
+                    f"\n[bold green]▶[/] [green][START][/] Session [bold]{session_id}[/] "
+                    f"recording (requests: {session.request_count})"
                 )
 
-                with console.status(rec_status_text, spinner="point", spinner_style="red"):
+                # Display RECORDING status once to avoid spinner refresh noise
+                with console.status(
+                    _recording_status_text(session_id),
+                    spinner="point",
+                    spinner_style="red",
+                ):
                     try:
                         key = _wait_for_enter_or_escape()
                     except EOFError:
@@ -660,10 +687,11 @@ def _run_watch_loop(watch_manager: WatchManager, stop_event: threading.Event) ->
                     break
 
                 if key == "escape":
-                    watch_manager.cancel_recording()
+                    cancelled = watch_manager.cancel_recording()
                     console.print(
                         f"\n[bold yellow]✖[/] [yellow][CANCEL][/]"
-                        f" Session [bold]{session_id}[/] cancelled (no output generated)."
+                        f" Session [bold]{session_id}[/] cancelled "
+                        f"(requests: {cancelled.request_count})."
                     )
                     console.print()
                 else:
@@ -671,7 +699,8 @@ def _run_watch_loop(watch_manager: WatchManager, stop_event: threading.Event) ->
                     session = watch_manager.stop_recording()
                     console.print(
                         f"\n[bold yellow]⏳[/] [yellow][BUSY][/] Processing "
-                        f"Session [bold]{session_id}[/]..."
+                        f"Session [bold]{session_id}[/] "
+                        f"(requests: {session.request_count})..."
                     )
 
                     # Process the session
@@ -688,12 +717,11 @@ def _run_watch_loop(watch_manager: WatchManager, stop_event: threading.Event) ->
             session_id = (
                 watch_manager.current_session.session_id if watch_manager.current_session else "?"
             )
-            rec_status_text = (
-                f"[bold red]◉[/] [red][REC][/] Session [bold]{session_id}[/] recording  "
-                f"[dim]Press [Enter] to STOP & PROCESS, [Esc] to CANCEL[/]"
-            )
-
-            with console.status(rec_status_text, spinner="point", spinner_style="red"):
+            with console.status(
+                _recording_status_text(session_id),
+                spinner="point",
+                spinner_style="red",
+            ):
                 try:
                     key = _wait_for_enter_or_escape()
                 except EOFError:
@@ -707,7 +735,8 @@ def _run_watch_loop(watch_manager: WatchManager, stop_event: threading.Event) ->
                     cancelled = watch_manager.cancel_recording()
                     console.print(
                         f"\n[bold yellow]✖[/] [yellow][CANCEL][/]"
-                        f" Session [bold]{cancelled.session_id}[/] cancelled (no output generated)."
+                        f" Session [bold]{cancelled.session_id}[/] cancelled "
+                        f"(requests: {cancelled.request_count})."
                     )
                     console.print()
                 else:
@@ -716,7 +745,8 @@ def _run_watch_loop(watch_manager: WatchManager, stop_event: threading.Event) ->
                     session_id = session.session_id
                     console.print(
                         f"\n[bold yellow]⏳[/] [yellow][BUSY][/] Processing "
-                        f"Session [bold]{session_id}[/]..."
+                        f"Session [bold]{session_id}[/] "
+                        f"(requests: {session.request_count})..."
                     )
 
                     # Process the session
@@ -733,28 +763,46 @@ def _run_watch_loop(watch_manager: WatchManager, stop_event: threading.Event) ->
             time.sleep(0.1)
 
 
-def _wait_for_enter_or_escape() -> Literal["enter", "escape"]:
+def _wait_for_enter_or_escape(
+    timeout: float | None = None,
+) -> Literal["enter", "escape"] | None:
     """
     Wait for a single keypress: Enter or Escape.
 
     Falls back to line-buffered input when stdin is not a TTY (e.g. piped).
     """
     if not sys.stdin.isatty():
-        input()
-        return "enter"
+        if timeout is None:
+            input()
+            return "enter"
+        return None
 
     if sys.platform.startswith("win"):
         # Windows: use msvcrt for unbuffered key input
         import msvcrt
+        import time
 
-        while True:
-            ch = msvcrt.getwch()
-            if ch in ("\r", "\n"):
-                return "enter"
-            if ch == "\x1b":
-                return "escape"
+        if timeout is None:
+            while True:
+                ch = msvcrt.getwch()
+                if ch in ("\r", "\n"):
+                    return "enter"
+                if ch == "\x1b":
+                    return "escape"
+        else:
+            end_time = time.time() + timeout
+            while time.time() < end_time:
+                if msvcrt.kbhit():
+                    ch = msvcrt.getwch()
+                    if ch in ("\r", "\n"):
+                        return "enter"
+                    if ch == "\x1b":
+                        return "escape"
+                time.sleep(0.01)
+            return None
     else:
         # POSIX: temporarily switch terminal to raw mode
+        import select
         import termios
         import tty
 
@@ -762,7 +810,19 @@ def _wait_for_enter_or_escape() -> Literal["enter", "escape"]:
         old = termios.tcgetattr(fd)
         try:
             tty.setraw(fd)
-            while True:
+            if timeout is None:
+                while True:
+                    rlist, _, _ = select.select([fd], [], [])
+                    if rlist:
+                        ch = sys.stdin.read(1)
+                        if ch in ("\r", "\n"):
+                            return "enter"
+                        if ch == "\x1b":
+                            return "escape"
+            else:
+                rlist, _, _ = select.select([fd], [], [], timeout)
+                if not rlist:
+                    return None
                 ch = sys.stdin.read(1)
                 if ch in ("\r", "\n"):
                     return "enter"
@@ -771,6 +831,8 @@ def _wait_for_enter_or_escape() -> Literal["enter", "escape"]:
         finally:
             termios.tcsetattr(fd, termios.TCSADRAIN, old)
 
+    return None
+
 
 def _is_port_in_use(host: str, port: int) -> bool:
     """Return True if the given host:port combination is already bound."""

{llm_interceptor-2.2.0 → llm_interceptor-2.3.0}/src/cci/config.py

@@ -61,7 +61,7 @@ class ProxyConfig(BaseModel):
     """Proxy server configuration."""
 
     host: str = "127.0.0.1"
-    port: int = 8080
+    port: int = 9090
     # SSL verification mode
     ssl_insecure: bool = False
 

{llm_interceptor-2.2.0 → llm_interceptor-2.3.0}/src/cci/logger.py

@@ -67,6 +67,7 @@ def setup_logger(
         console=console,
         show_time=True,
         show_path=False,
+        show_level=False,
         rich_tracebacks=True,
         tracebacks_show_locals=level.upper() == "DEBUG",
         markup=True,
@@ -115,10 +116,17 @@ def log_request_summary(
     url: str,
     status: int | None = None,
     latency_ms: float | None = None,
+    captured: bool = True,
 ) -> None:
     """Log a formatted request summary."""
     logger = get_logger()
 
+    # Capture status indicator
+    if captured:
+        cap_str = "[bold green][CAPT][/bold green]"
+    else:
+        cap_str = "[bold magenta][SKIP][/bold magenta]"
+
     # Color coding based on status
     if status is None:
         status_str = "→"
@@ -131,7 +139,7 @@ def log_request_summary(
 
     latency_str = f" ({latency_ms:.0f}ms)" if latency_ms else ""
 
-    logger.info(f"{method} {url} {status_str}{latency_str}")
+    logger.info(f"{cap_str} {method} {url} {status_str}{latency_str}")
 
 
 def log_streaming_progress(request_id: str, chunk_count: int) -> None:

{llm_interceptor-2.2.0 → llm_interceptor-2.3.0}/src/cci/proxy.py

@@ -64,19 +64,26 @@ class WatchAddon:
     def request(self, flow: http.HTTPFlow) -> None:
         """Handle an outgoing request."""
         url = flow.request.pretty_url
+        method = flow.request.method
 
-        self._logger.debug("Intercepted request: %s %s", flow.request.method, url)
+        self._logger.debug("Intercepted request: %s %s", method, url)
 
-        if not self.url_filter.should_capture(url):
-            self._logger.debug("URL not matched, skipping: %s", url)
-            return
+        # Determine if we should capture this request
+        should_capture = self.url_filter.should_capture(url)
 
-        # Generate unique request ID
+        # Log summary for all requests
+        log_request_summary(method, url, captured=should_capture)
+
+        # Generate unique request ID and track timing for all requests
         request_id = str(uuid4())
         flow_id = id(flow)
         self._request_ids[flow_id] = request_id
         self._request_times[flow_id] = time.time()
 
+        if not should_capture:
+            self._logger.debug("URL not matched, skipping: %s", url)
+            return
+
         # Capture current session ID for this request
         session_id = self.watch_manager.current_session_id
         self._request_sessions[flow_id] = session_id
@@ -96,7 +103,7 @@ class WatchAddon:
             "type": "request",
             "id": request_id,
             "timestamp": datetime.now(timezone.utc).isoformat(),
-            "method": flow.request.method,
+            "method": method,
             "url": url,
             "headers": headers,
             "body": body,
@@ -108,14 +115,31 @@ class WatchAddon:
     def response(self, flow: http.HTTPFlow) -> None:
         """Handle a response."""
         url = flow.request.pretty_url
-        if not self.url_filter.should_capture(url):
-            return
+        method = flow.request.method
+        status_code = flow.response.status_code
+
+        # Determine if we should capture this response
+        should_capture = self.url_filter.should_capture(url)
 
         flow_id = id(flow)
         request_id = self._request_ids.get(flow_id, str(uuid4()))
         start_time = self._request_times.get(flow_id, time.time())
         latency_ms = (time.time() - start_time) * 1000
 
+        # Log summary for all responses
+        log_request_summary(
+            method,
+            url,
+            status_code,
+            latency_ms,
+            captured=should_capture,
+        )
+
+        if not should_capture:
+            # Cleanup and exit early if not capturing
+            self._cleanup_flow(flow_id)
+            return
+
         # Use the session ID from the request start
         session_id = self._request_sessions.get(flow_id)
 
@@ -125,7 +149,7 @@ class WatchAddon:
 
         self._logger.debug(
             "Response received: %s %s (streaming=%s, content-type=%s)",
-            flow.response.status_code,
+            status_code,
             url,
             is_streaming,
             content_type,
@@ -141,7 +165,7 @@ class WatchAddon:
                     "type": "response_chunk",
                     "request_id": request_id,
                     "timestamp": datetime.now(timezone.utc).isoformat(),
-                    "status_code": flow.response.status_code,
+                    "status_code": status_code,
                     "chunk_index": chunk_index,
                     "content": event_content,
                 }
@@ -153,7 +177,7 @@ class WatchAddon:
                 "type": "response_meta",
                 "request_id": request_id,
                 "total_latency_ms": latency_ms,
-                "status_code": flow.response.status_code,
+                "status_code": status_code,
                 "total_chunks": len(sse_events),
             }
             self.watch_manager.write_record(meta_record, session_id=session_id)
@@ -168,20 +192,13 @@ class WatchAddon:
                 "type": "response",
                 "request_id": request_id,
                 "timestamp": datetime.now(timezone.utc).isoformat(),
-                "status_code": flow.response.status_code,
+                "status_code": status_code,
                 "headers": headers,
                 "body": body,
                 "latency_ms": latency_ms,
             }
             self.watch_manager.write_record(record, session_id=session_id)
 
-        log_request_summary(
-            flow.request.method,
-            url,
-            flow.response.status_code,
-            latency_ms,
-        )
-
         # Cleanup
         self._cleanup_flow(flow_id)
 

{llm_interceptor-2.2.0 → llm_interceptor-2.3.0}/ui/README.md

@@ -23,6 +23,11 @@ This UI is bundled with the `llm-interceptor` Python package.
     lli watch --include "*example.com*"
     ```
 
+    To expose the UI on your network:
+    ```bash
+    lli watch --ui-host 0.0.0.0 --ui-port 8000
+    ```
+
 2.  **Open the Dashboard**:
     The CLI will print a URL (usually `http://localhost:8000`). Click it to open the dashboard.