reverse-api-engineer 0.4.4__tar.gz → 0.4.5__tar.gz

{reverse_api_engineer-0.4.4 → reverse_api_engineer-0.4.5}/CHANGELOG.md

@@ -5,11 +5,11 @@ 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.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.4.4] - 2026-03-15
+## [0.4.5] - 2026-03-15
 
 ### Fixed
-- **Stream closed errors (#51)**: Fixed "Error in hook callback hook_0: Stream closed" by clearing inherited `CLAUDECODE` env var from CLI subprocess and extending stream close timeout
-- **Async generator cleanup**: Avoid early return inside `query()` loop to prevent cancel-scope errors
+- **Stream closed errors (#51)**: Reverted from `query()` to `ClaudeSDKClient` which maintains a persistent bidirectional connection, eliminating "Error in hook callback hook_0: Stream closed" errors. The original AUQ fix (v0.4.3) unnecessarily switched APIs — only the `can_use_tool` callback signature needed updating
+- **CLAUDECODE env var leak**: Clear inherited `CLAUDECODE` env var from CLI subprocess to prevent nested session interference when running inside Claude Code
 - **CLI stderr noise**: Filter minified JS stack traces into a single clean error line (use `DEBUG=1` for full output)
 
 ### Changed
@@ -17,6 +17,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Agent mode**: No longer prompts for URL (agent navigates autonomously)
 - **Header UI**: Version and task labels now use mode-specific colors (agent=coral, engineer=blue, collector=gold)
 
+## [0.4.4] - 2026-03-15
+
+### Fixed
+- **Stream closed errors (#51)**: Partial fix using `query()` with env var workarounds (superseded by v0.4.5)
+
 ## [0.4.3] - 2026-03-12
 
 ### Fixed

{reverse_api_engineer-0.4.4 → reverse_api_engineer-0.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reverse-api-engineer
-Version: 0.4.4
+Version: 0.4.5
 Summary: A tool to capture browser traffic for API reverse engineering
 Project-URL: Homepage, https://github.com/kalil0321/reverse-api-engineer
 Project-URL: Repository, https://github.com/kalil0321/reverse-api-engineer

{reverse_api_engineer-0.4.4 → reverse_api_engineer-0.4.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "reverse-api-engineer"
-version = "0.4.4"
+version = "0.4.5"
 description = "A tool to capture browser traffic for API reverse engineering"
 readme = "README.md"
 requires-python = ">=3.11"

{reverse_api_engineer-0.4.4 → reverse_api_engineer-0.4.5}/src/reverse_api/auto_engineer.py

@@ -11,14 +11,13 @@ import httpx
 from claude_agent_sdk import (
     AssistantMessage,
     ClaudeAgentOptions,
-    HookMatcher,
+    ClaudeSDKClient,
     PermissionResultAllow,
     ResultMessage,
     TextBlock,
     ToolPermissionContext,
     ToolResultBlock,
     ToolUseBlock,
-    query,
 )
 
 from .engineer import ClaudeEngineer
@@ -257,105 +256,93 @@ Your final response should confirm the files were created and provide a brief su
             ],
         }
 
-        # Required: dummy hook keeps the stream open for can_use_tool
-        async def _dummy_hook(input_data: dict[str, Any], tool_use_id: str | None, context: Any) -> dict[str, Any]:
-            return {"continue_": True}
-
-        async def _prompt_stream():
-            yield {
-                "type": "user",
-                "message": {"role": "user", "content": self._build_auto_prompt()},
-            }
-
         options = ClaudeAgentOptions(
             mcp_servers={"playwright": mcp_config},
+            permission_mode="bypassPermissions",
             can_use_tool=self._handle_tool_permission,
-            hooks={"PreToolUse": [HookMatcher(matcher=None, hooks=[_dummy_hook])]},
             cwd=str(self.scripts_dir.parent.parent),  # Project root
             model=self.model,
-            env={"CLAUDECODE": "", "CLAUDE_CODE_STREAM_CLOSE_TIMEOUT": "1800000"},
+            env={"CLAUDECODE": ""},
             stderr=self._handle_cli_stderr,
         )
 
-        final_result: dict[str, Any] | None = None
-
         try:
-            # Do not break/return inside this loop — the SDK requires the
-            # async generator to be fully consumed to avoid cancel-scope errors.
-            async for message in query(prompt=_prompt_stream(), options=options):
-                # Check for usage metadata
-                if hasattr(message, "usage") and isinstance(message.usage, dict):
-                    self.usage_metadata.update(message.usage)
-
-                if isinstance(message, AssistantMessage):
-                    last_tool_name = None
-                    for block in message.content:
-                        if isinstance(block, ToolUseBlock):
-                            last_tool_name = block.name
-                            self.ui.tool_start(block.name, block.input)
-                            self.message_store.save_tool_start(block.name, block.input)
-                        elif isinstance(block, ToolResultBlock):
-                            is_error = block.is_error if block.is_error else False
-
-                            # Extract output from ToolResultBlock
-                            output = None
-                            if hasattr(block, "content"):
-                                output = block.content
-                            elif hasattr(block, "result"):
-                                output = block.result
-                            elif hasattr(block, "output"):
-                                output = block.output
-
-                            tool_name = last_tool_name or "Tool"
-                            self.ui.tool_result(tool_name, is_error, output)
-                            self.message_store.save_tool_result(tool_name, is_error, str(output) if output else None)
-                        elif isinstance(block, TextBlock):
-                            self.ui.thinking(block.text)
-                            self.message_store.save_thinking(block.text)
-
-                elif isinstance(message, ResultMessage):
-                    if message.is_error:
-                        self.ui.error(message.result or "Unknown error")
-                        self.message_store.save_error(message.result or "Unknown error")
-                    else:
-                        script_path = str(self.scripts_dir / self._get_client_filename())
-                        local_path = str(self.local_scripts_dir / self._get_client_filename()) if self.local_scripts_dir else None
-                        self.ui.success(script_path, local_path)
-
-                        # Calculate estimated cost if we have usage data
-                        if self.usage_metadata:
-                            input_tokens = self.usage_metadata.get("input_tokens", 0)
-                            output_tokens = self.usage_metadata.get("output_tokens", 0)
-                            cache_creation_tokens = self.usage_metadata.get("cache_creation_input_tokens", 0)
-                            cache_read_tokens = self.usage_metadata.get("cache_read_input_tokens", 0)
-
-                            from .pricing import calculate_cost
-
-                            cost = calculate_cost(
-                                model_id=self.model,
-                                input_tokens=input_tokens,
-                                output_tokens=output_tokens,
-                                cache_creation_tokens=cache_creation_tokens,
-                                cache_read_tokens=cache_read_tokens,
-                            )
-                            self.usage_metadata["estimated_cost_usd"] = cost
-
-                            self.ui.console.print("  [dim]Usage:[/dim]")
-                            if input_tokens > 0:
-                                self.ui.console.print(f"  [dim]  input: {input_tokens:,} tokens[/dim]")
-                            if cache_creation_tokens > 0:
-                                self.ui.console.print(f"  [dim]  cache creation: {cache_creation_tokens:,} tokens[/dim]")
-                            if cache_read_tokens > 0:
-                                self.ui.console.print(f"  [dim]  cache read: {cache_read_tokens:,} tokens[/dim]")
-                            if output_tokens > 0:
-                                self.ui.console.print(f"  [dim]  output: {output_tokens:,} tokens[/dim]")
-                            self.ui.console.print(f"  [dim]  total cost: ${cost:.4f}[/dim]")
-
-                        final_result = {
-                            "script_path": script_path,
-                            "usage": self.usage_metadata,
-                        }
-                        self.message_store.save_result(final_result)
+            async with ClaudeSDKClient(options=options) as client:
+                await client.query(self._build_auto_prompt())
+
+                async for message in client.receive_response():
+                    if hasattr(message, "usage") and isinstance(message.usage, dict):
+                        self.usage_metadata.update(message.usage)
+
+                    if isinstance(message, AssistantMessage):
+                        last_tool_name = None
+                        for block in message.content:
+                            if isinstance(block, ToolUseBlock):
+                                last_tool_name = block.name
+                                self.ui.tool_start(block.name, block.input)
+                                self.message_store.save_tool_start(block.name, block.input)
+                            elif isinstance(block, ToolResultBlock):
+                                is_error = block.is_error if block.is_error else False
+
+                                output = None
+                                if hasattr(block, "content"):
+                                    output = block.content
+                                elif hasattr(block, "result"):
+                                    output = block.result
+                                elif hasattr(block, "output"):
+                                    output = block.output
+
+                                tool_name = last_tool_name or "Tool"
+                                self.ui.tool_result(tool_name, is_error, output)
+                                self.message_store.save_tool_result(tool_name, is_error, str(output) if output else None)
+                            elif isinstance(block, TextBlock):
+                                self.ui.thinking(block.text)
+                                self.message_store.save_thinking(block.text)
+
+                    elif isinstance(message, ResultMessage):
+                        if message.is_error:
+                            self.ui.error(message.result or "Unknown error")
+                            self.message_store.save_error(message.result or "Unknown error")
+                            return None
+                        else:
+                            script_path = str(self.scripts_dir / self._get_client_filename())
+                            local_path = str(self.local_scripts_dir / self._get_client_filename()) if self.local_scripts_dir else None
+                            self.ui.success(script_path, local_path)
+
+                            if self.usage_metadata:
+                                input_tokens = self.usage_metadata.get("input_tokens", 0)
+                                output_tokens = self.usage_metadata.get("output_tokens", 0)
+                                cache_creation_tokens = self.usage_metadata.get("cache_creation_input_tokens", 0)
+                                cache_read_tokens = self.usage_metadata.get("cache_read_input_tokens", 0)
+
+                                from .pricing import calculate_cost
+
+                                cost = calculate_cost(
+                                    model_id=self.model,
+                                    input_tokens=input_tokens,
+                                    output_tokens=output_tokens,
+                                    cache_creation_tokens=cache_creation_tokens,
+                                    cache_read_tokens=cache_read_tokens,
+                                )
+                                self.usage_metadata["estimated_cost_usd"] = cost
+
+                                self.ui.console.print("  [dim]Usage:[/dim]")
+                                if input_tokens > 0:
+                                    self.ui.console.print(f"  [dim]  input: {input_tokens:,} tokens[/dim]")
+                                if cache_creation_tokens > 0:
+                                    self.ui.console.print(f"  [dim]  cache creation: {cache_creation_tokens:,} tokens[/dim]")
+                                if cache_read_tokens > 0:
+                                    self.ui.console.print(f"  [dim]  cache read: {cache_read_tokens:,} tokens[/dim]")
+                                if output_tokens > 0:
+                                    self.ui.console.print(f"  [dim]  output: {output_tokens:,} tokens[/dim]")
+                                self.ui.console.print(f"  [dim]  total cost: ${cost:.4f}[/dim]")
+
+                            result: dict[str, Any] = {
+                                "script_path": script_path,
+                                "usage": self.usage_metadata,
+                            }
+                            self.message_store.save_result(result)
+                            return result
 
         except Exception as e:
             error_msg = str(e)
@@ -374,7 +361,7 @@ Your final response should confirm the files were created and provide a brief su
                 self.ui.console.print("\n[dim]Make sure Claude Code CLI is installed: npm install -g @anthropic-ai/claude-code[/dim]")
             return None
 
-        return final_result
+        return None
 
 
 class OpenCodeAutoEngineer(OpenCodeEngineer):

{reverse_api_engineer-0.4.4 → reverse_api_engineer-0.4.5}/src/reverse_api/engineer.py

@@ -8,14 +8,13 @@ from typing import Any
 from claude_agent_sdk import (
     AssistantMessage,
     ClaudeAgentOptions,
-    HookMatcher,
+    ClaudeSDKClient,
     PermissionResultAllow,
     ResultMessage,
     TextBlock,
     ToolPermissionContext,
     ToolResultBlock,
     ToolUseBlock,
-    query,
 )
 
 from .base_engineer import BaseEngineer
@@ -46,105 +45,92 @@ class ClaudeEngineer(BaseEngineer):
         self.ui.start_analysis()
         self.message_store.save_prompt(self._build_analysis_prompt())
 
-        # Required: dummy hook keeps the stream open for can_use_tool
-        # See: https://platform.claude.com/docs/en/agent-sdk/user-input
-        async def _dummy_hook(input_data: dict[str, Any], tool_use_id: str | None, context: Any) -> dict[str, Any]:
-            return {"continue_": True}
-
-        async def _prompt_stream():
-            yield {
-                "type": "user",
-                "message": {"role": "user", "content": self._build_analysis_prompt()},
-            }
-
         options = ClaudeAgentOptions(
+            permission_mode="acceptEdits",
             can_use_tool=self._handle_tool_permission,
-            hooks={"PreToolUse": [HookMatcher(matcher=None, hooks=[_dummy_hook])]},
             cwd=str(self.scripts_dir.parent.parent),  # Project root
             model=self.model,
-            env={"CLAUDECODE": "", "CLAUDE_CODE_STREAM_CLOSE_TIMEOUT": "1800000"},
+            env={"CLAUDECODE": ""},
             stderr=self._handle_cli_stderr,
         )
 
-        final_result: dict[str, Any] | None = None
-
         try:
-            # Do not break/return inside this loop — the SDK requires the
-            # async generator to be fully consumed to avoid cancel-scope errors.
-            async for message in query(prompt=_prompt_stream(), options=options):
-                # Check for usage metadata in message if applicable
-                if hasattr(message, "usage") and isinstance(message.usage, dict):
-                    self.usage_metadata.update(message.usage)
-
-                if isinstance(message, AssistantMessage):
-                    last_tool_name = None
-                    for block in message.content:
-                        if isinstance(block, ToolUseBlock):
-                            last_tool_name = block.name
-                            self.ui.tool_start(block.name, block.input)
-                            self.message_store.save_tool_start(block.name, block.input)
-                        elif isinstance(block, ToolResultBlock):
-                            is_error = block.is_error if block.is_error else False
-
-                            # Extract output from ToolResultBlock
-                            output = None
-                            if hasattr(block, "content"):
-                                output = block.content
-                            elif hasattr(block, "result"):
-                                output = block.result
-                            elif hasattr(block, "output"):
-                                output = block.output
-
-                            tool_name = last_tool_name or "Tool"
-                            self.ui.tool_result(tool_name, is_error, output)
-                            self.message_store.save_tool_result(tool_name, is_error, str(output) if output else None)
-                        elif isinstance(block, TextBlock):
-                            self.ui.thinking(block.text)
-                            self.message_store.save_thinking(block.text)
-
-                elif isinstance(message, ResultMessage):
-                    if message.is_error:
-                        self.ui.error(message.result or "Unknown error")
-                        self.message_store.save_error(message.result or "Unknown error")
-                    else:
-                        script_path = str(self.scripts_dir / self._get_client_filename())
-                        local_path = str(self.local_scripts_dir / self._get_client_filename()) if self.local_scripts_dir else None
-                        self.ui.success(script_path, local_path)
-
-                        # Calculate estimated cost if we have usage data
-                        if self.usage_metadata:
-                            input_tokens = self.usage_metadata.get("input_tokens", 0)
-                            output_tokens = self.usage_metadata.get("output_tokens", 0)
-                            cache_creation_tokens = self.usage_metadata.get("cache_creation_input_tokens", 0)
-                            cache_read_tokens = self.usage_metadata.get("cache_read_input_tokens", 0)
-
-                            from .pricing import calculate_cost
-
-                            cost = calculate_cost(
-                                model_id=self.model,
-                                input_tokens=input_tokens,
-                                output_tokens=output_tokens,
-                                cache_creation_tokens=cache_creation_tokens,
-                                cache_read_tokens=cache_read_tokens,
-                            )
-                            self.usage_metadata["estimated_cost_usd"] = cost
-
-                            self.ui.console.print("  [dim]Usage:[/dim]")
-                            if input_tokens > 0:
-                                self.ui.console.print(f"  [dim]  input: {input_tokens:,} tokens[/dim]")
-                            if cache_creation_tokens > 0:
-                                self.ui.console.print(f"  [dim]  cache creation: {cache_creation_tokens:,} tokens[/dim]")
-                            if cache_read_tokens > 0:
-                                self.ui.console.print(f"  [dim]  cache read: {cache_read_tokens:,} tokens[/dim]")
-                            if output_tokens > 0:
-                                self.ui.console.print(f"  [dim]  output: {output_tokens:,} tokens[/dim]")
-                            self.ui.console.print(f"  [dim]  total cost: ${cost:.4f}[/dim]")
-
-                        final_result = {
-                            "script_path": script_path,
-                            "usage": self.usage_metadata,
-                        }
-                        self.message_store.save_result(final_result)
+            async with ClaudeSDKClient(options=options) as client:
+                await client.query(self._build_analysis_prompt())
+
+                async for message in client.receive_response():
+                    if hasattr(message, "usage") and isinstance(message.usage, dict):
+                        self.usage_metadata.update(message.usage)
+
+                    if isinstance(message, AssistantMessage):
+                        last_tool_name = None
+                        for block in message.content:
+                            if isinstance(block, ToolUseBlock):
+                                last_tool_name = block.name
+                                self.ui.tool_start(block.name, block.input)
+                                self.message_store.save_tool_start(block.name, block.input)
+                            elif isinstance(block, ToolResultBlock):
+                                is_error = block.is_error if block.is_error else False
+
+                                output = None
+                                if hasattr(block, "content"):
+                                    output = block.content
+                                elif hasattr(block, "result"):
+                                    output = block.result
+                                elif hasattr(block, "output"):
+                                    output = block.output
+
+                                tool_name = last_tool_name or "Tool"
+                                self.ui.tool_result(tool_name, is_error, output)
+                                self.message_store.save_tool_result(tool_name, is_error, str(output) if output else None)
+                            elif isinstance(block, TextBlock):
+                                self.ui.thinking(block.text)
+                                self.message_store.save_thinking(block.text)
+
+                    elif isinstance(message, ResultMessage):
+                        if message.is_error:
+                            self.ui.error(message.result or "Unknown error")
+                            self.message_store.save_error(message.result or "Unknown error")
+                            return None
+                        else:
+                            script_path = str(self.scripts_dir / self._get_client_filename())
+                            local_path = str(self.local_scripts_dir / self._get_client_filename()) if self.local_scripts_dir else None
+                            self.ui.success(script_path, local_path)
+
+                            if self.usage_metadata:
+                                input_tokens = self.usage_metadata.get("input_tokens", 0)
+                                output_tokens = self.usage_metadata.get("output_tokens", 0)
+                                cache_creation_tokens = self.usage_metadata.get("cache_creation_input_tokens", 0)
+                                cache_read_tokens = self.usage_metadata.get("cache_read_input_tokens", 0)
+
+                                from .pricing import calculate_cost
+
+                                cost = calculate_cost(
+                                    model_id=self.model,
+                                    input_tokens=input_tokens,
+                                    output_tokens=output_tokens,
+                                    cache_creation_tokens=cache_creation_tokens,
+                                    cache_read_tokens=cache_read_tokens,
+                                )
+                                self.usage_metadata["estimated_cost_usd"] = cost
+
+                                self.ui.console.print("  [dim]Usage:[/dim]")
+                                if input_tokens > 0:
+                                    self.ui.console.print(f"  [dim]  input: {input_tokens:,} tokens[/dim]")
+                                if cache_creation_tokens > 0:
+                                    self.ui.console.print(f"  [dim]  cache creation: {cache_creation_tokens:,} tokens[/dim]")
+                                if cache_read_tokens > 0:
+                                    self.ui.console.print(f"  [dim]  cache read: {cache_read_tokens:,} tokens[/dim]")
+                                if output_tokens > 0:
+                                    self.ui.console.print(f"  [dim]  output: {output_tokens:,} tokens[/dim]")
+                                self.ui.console.print(f"  [dim]  total cost: ${cost:.4f}[/dim]")
+
+                            result: dict[str, Any] = {
+                                "script_path": script_path,
+                                "usage": self.usage_metadata,
+                            }
+                            self.message_store.save_result(result)
+                            return result
 
         except Exception as e:
             self.ui.error(str(e))
@@ -152,7 +138,7 @@ class ClaudeEngineer(BaseEngineer):
             self.ui.console.print("\n[dim]Make sure Claude Code CLI is installed: npm install -g @anthropic-ai/claude-code[/dim]")
             return None
 
-        return final_result
+        return None
 
 
 # Keep old class name for backwards compatibility

{reverse_api_engineer-0.4.4 → reverse_api_engineer-0.4.5}/uv.lock

@@ -2158,7 +2158,7 @@ wheels = [
 
 [[package]]
 name = "reverse-api-engineer"
-version = "0.4.3"
+version = "0.4.4"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },