adloop 0.6.2__tar.gz → 0.6.4__tar.gz

{adloop-0.6.2 → adloop-0.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: adloop
-Version: 0.6.2
+Version: 0.6.4
 Summary: Stop switching between Google Ads, GA4, and your code editor to figure out why conversions dropped.
 Keywords: mcp,google-ads,google-analytics,ga4,cursor,marketing
 Author: Daniel Klose
@@ -394,6 +394,7 @@ What's been shipped and what's next:
 - ~~Retry/backoff for API rate limits~~ ✓
 - ~~Setup wizard (`adloop init`)~~ ✓
 - ~~Claude Code support~~ ✓ — `CLAUDE.md`, `.mcp.json`, `.claude/rules/`, `.claude/commands/`, CLI wizard snippets
+- **Claude Desktop one-click install** — `adloop install claude-desktop` (and/or a `.dxt` extension bundle) that writes the AdLoop MCP entry into `claude_desktop_config.json` automatically, so Claude Desktop + Cowork users don't have to hand-edit JSON
 - ~~PyPI package~~ ✓ — `pip install adloop`
 - ~~Bundled OAuth credentials~~ ✓ — no Google Cloud project required, auto-discovery of GA4/Ads accounts (currently capped at 100 users pending Google verification — use [Advanced Setup](#advanced-setup-custom-google-cloud-project) in the meantime)
 - ~~Headless server support~~ ✓ — manual URL copy-paste flow for servers without a browser

{adloop-0.6.2 → adloop-0.6.4}/README.md

@@ -370,6 +370,7 @@ What's been shipped and what's next:
 - ~~Retry/backoff for API rate limits~~ ✓
 - ~~Setup wizard (`adloop init`)~~ ✓
 - ~~Claude Code support~~ ✓ — `CLAUDE.md`, `.mcp.json`, `.claude/rules/`, `.claude/commands/`, CLI wizard snippets
+- **Claude Desktop one-click install** — `adloop install claude-desktop` (and/or a `.dxt` extension bundle) that writes the AdLoop MCP entry into `claude_desktop_config.json` automatically, so Claude Desktop + Cowork users don't have to hand-edit JSON
 - ~~PyPI package~~ ✓ — `pip install adloop`
 - ~~Bundled OAuth credentials~~ ✓ — no Google Cloud project required, auto-discovery of GA4/Ads accounts (currently capped at 100 users pending Google verification — use [Advanced Setup](#advanced-setup-custom-google-cloud-project) in the meantime)
 - ~~Headless server support~~ ✓ — manual URL copy-paste flow for servers without a browser

{adloop-0.6.2 → adloop-0.6.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "adloop"
-version = "0.6.2"
+version = "0.6.4"
 description = "Stop switching between Google Ads, GA4, and your code editor to figure out why conversions dropped."
 readme = "README.md"
 authors = [

{adloop-0.6.2 → adloop-0.6.4}/src/adloop/__init__.py

@@ -2,7 +2,7 @@
 
 import sys
 
-__version__ = "0.6.2"
+__version__ = "0.6.4"
 
 
 def main() -> None:

adloop-0.6.4/src/adloop/_mcp_patches.py

@@ -0,0 +1,161 @@
+"""Runtime patches for upstream ``mcp`` / ``fastmcp`` bugs.
+
+This module exists to work around specific upstream defects that affect AdLoop
+users in the wild. Every patch in here is a **temporary workaround** — the long-
+term fix belongs upstream. Each entry below records exactly which upstream issue
+it tracks and the condition under which this file should stop patching.
+
+Currently tracked:
+
+- **modelcontextprotocol/python-sdk#2416** — ``AssertionError: Request already
+  responded to`` cancellation race in ``mcp`` 1.27.0. Reliably crashes the MCP
+  server whenever the host (Claude Cowork, Claude Code post-update, etc.) sends
+  ``notifications/cancelled`` while a synchronous tool handler is still running.
+  We replace the two racing methods (``respond`` / ``cancel``) with guard-based
+  versions that cannot double-send a JSON-RPC response.
+
+  **Remove this patch** once ``mcp`` upstream ships a fix (watch the issue,
+  check the installed source for the ``assert not self._completed`` line — if
+  it's gone, we detect that automatically and skip patching).
+
+Design goals:
+
+1. **Self-removing.** Each patch inspects the upstream source first and bails
+   out silently when the bug appears fixed. Upgrading the dependency is then
+   enough to deactivate the workaround — no code changes needed in AdLoop.
+2. **Idempotent.** ``install()`` is safe to call multiple times.
+3. **Never fatal.** If patching itself fails (e.g. upstream restructured the
+   module so inspection breaks), we log and continue — the server must start
+   even if the patch can't be applied.
+"""
+
+from __future__ import annotations
+
+import inspect
+import sys
+from typing import Any
+
+from adloop import diagnostics
+
+
+def _log(message: str) -> None:
+    """Write a single patch-status line via the diagnostics channel.
+
+    Falls back to a plain ``stderr`` write when diagnostics are disabled so
+    maintainers can still see patch activity if they go looking.
+    """
+    line = f"[adloop-patches] {message}"
+    if diagnostics.enabled():
+        diagnostics._emit("patch", message=message)  # type: ignore[attr-defined]
+        return
+    try:
+        sys.stderr.write(line + "\n")
+        sys.stderr.flush()
+    except Exception:
+        pass
+
+
+def _patch_request_responder_cancel_race() -> None:
+    """Apply the fix for python-sdk issue #2416.
+
+    Replaces ``RequestResponder.respond`` and ``RequestResponder.cancel`` with
+    versions that guard against double-responding via a synchronous
+    ``self._completed`` check before any ``await``. Exactly one of the two
+    methods wins the race; the loser returns without sending a second JSON-RPC
+    response, which in turn prevents the anyio TaskGroup from tearing the
+    entire stdio transport down.
+
+    Autodetects the upstream fix by inspecting the installed ``respond``
+    source: if the signature ``assert not self._completed`` is no longer
+    present, we assume upstream landed a fix and skip patching.
+    """
+    try:
+        from mcp.shared import session as _session_module
+    except Exception as exc:  # pragma: no cover — mcp is a hard dep
+        _log(f"skip pysdk-2416: cannot import mcp.shared.session ({exc})")
+        return
+
+    responder_cls = getattr(_session_module, "RequestResponder", None)
+    if responder_cls is None:
+        _log("skip pysdk-2416: RequestResponder class not found")
+        return
+
+    try:
+        original_respond_src = inspect.getsource(responder_cls.respond)
+    except (OSError, TypeError) as exc:
+        _log(f"skip pysdk-2416: cannot inspect respond() source ({exc})")
+        return
+
+    if "assert not self._completed" not in original_respond_src:
+        # Upstream fixed the race (or moved it). No need to patch further.
+        _log("skip pysdk-2416: upstream source no longer contains the racey assert")
+        return
+
+    if getattr(responder_cls, "_adloop_2416_patched", False):
+        return
+
+    async def respond(self: Any, response: Any) -> None:
+        """Patched RequestResponder.respond — see python-sdk#2416."""
+        if not self._entered:
+            raise RuntimeError("RequestResponder must be used as a context manager")
+        # Upstream asserts here; we return early instead. If a concurrent
+        # cancel() already marked the request complete, silently drop this
+        # response — the cancel path has already sent one error response and a
+        # second JSON-RPC reply for the same request ID would be a protocol
+        # violation as well as crashing the TaskGroup on the assert.
+        if self._completed:
+            return
+        if not self.cancelled:
+            self._completed = True
+            await self._session._send_response(
+                request_id=self.request_id, response=response
+            )
+
+    async def cancel(self: Any) -> None:
+        """Patched RequestResponder.cancel — see python-sdk#2416."""
+        if not self._entered:
+            raise RuntimeError("RequestResponder must be used as a context manager")
+        if not self._cancel_scope:
+            raise RuntimeError("No active cancel scope")
+
+        self._cancel_scope.cancel()
+        # Symmetrical guard: if the handler's respond() already ran before the
+        # cancel notification arrived, don't send a second response.
+        if self._completed:
+            return
+        self._completed = True
+
+        from mcp.types import ErrorData  # imported lazily to avoid startup cost
+
+        await self._session._send_response(
+            request_id=self.request_id,
+            response=ErrorData(code=0, message="Request cancelled", data=None),
+        )
+
+    responder_cls.respond = respond
+    responder_cls.cancel = cancel
+    responder_cls._adloop_2416_patched = True  # type: ignore[attr-defined]
+
+    _log(
+        "applied pysdk-2416: RequestResponder.respond/cancel guarded against "
+        "cancellation double-respond race"
+    )
+
+
+_INSTALLED = False
+
+
+def install() -> None:
+    """Apply all AdLoop runtime patches. Idempotent.
+
+    Call this exactly once at server startup, before ``FastMCP`` begins
+    accepting messages. Calling it multiple times is safe — we gate on a
+    module-level flag and each individual patch also has its own reentry
+    guard.
+    """
+    global _INSTALLED
+    if _INSTALLED:
+        return
+    _INSTALLED = True
+
+    _patch_request_responder_cancel_race()

{adloop-0.6.2 → adloop-0.6.4}/src/adloop/ads/write.py

@@ -1183,6 +1183,7 @@ def confirm_and_apply(
             "Plans expire when the MCP server restarts.",
         }
 
+    forced_by_config = bool(config.safety.require_dry_run) and not dry_run
     if config.safety.require_dry_run:
         dry_run = True
 
@@ -1197,16 +1198,40 @@ def confirm_and_apply(
             dry_run=True,
             result="dry_run_success",
         )
-        return {
+        response = {
             "status": "DRY_RUN_SUCCESS",
             "plan_id": plan.plan_id,
             "operation": plan.operation,
             "changes": plan.changes,
-            "message": (
+        }
+        if forced_by_config:
+            # The caller passed dry_run=false but safety.require_dry_run
+            # forced it back on. Tell them exactly why and how to unlock
+            # real writes — without this, agents (e.g. Claude Code) retry
+            # in an infinite loop because the old message said to "call
+            # again with dry_run=false", which they already did.
+            config_path = config.source_path or "~/.adloop/config.yaml"
+            response["dry_run_forced_by"] = "config.safety.require_dry_run"
+            response["config_path"] = config_path
+            response["remediation"] = (
+                f"Edit {config_path}, set 'require_dry_run: false' under "
+                "'safety:', then restart the AdLoop MCP server. Passing "
+                "dry_run=false on this tool will keep being overridden "
+                "until that flag is flipped."
+            )
+            response["message"] = (
+                f"dry_run=false was IGNORED because 'safety.require_dry_run: true' "
+                f"is set in {config_path}. No changes were made. To apply real "
+                f"changes, flip that flag to false and restart the AdLoop MCP "
+                f"server — retrying this tool with dry_run=false alone will "
+                f"never succeed while the flag is on."
+            )
+        else:
+            response["message"] = (
                 "Dry run completed — no changes were made to your Google Ads account. "
                 "To apply for real, call confirm_and_apply again with dry_run=false."
-            ),
-        }
+            )
+        return response
 
     try:
         result = _execute_plan(config, plan)

{adloop-0.6.2 → adloop-0.6.4}/src/adloop/config.py

@@ -47,6 +47,10 @@ class AdLoopConfig:
     ga4: GA4Config = field(default_factory=GA4Config)
     ads: AdsConfig = field(default_factory=AdsConfig)
     safety: SafetyConfig = field(default_factory=SafetyConfig)
+    # Absolute path the config was resolved from (even if it did not exist
+    # on disk when loaded). Used by the runtime to tell callers exactly
+    # which file to edit when a safety flag overrides their request.
+    source_path: str = ""
 
 
 def _resolve_path(path_str: str) -> Path:
@@ -66,9 +70,10 @@ def load_config(config_path: str | None = None) -> AdLoopConfig:
         config_path = os.environ.get("ADLOOP_CONFIG", "~/.adloop/config.yaml")
 
     path = _resolve_path(config_path)
+    resolved = str(path)
 
     if not path.exists():
-        return AdLoopConfig()
+        return AdLoopConfig(source_path=resolved)
 
     with open(path) as f:
         raw = yaml.safe_load(f) or {}
@@ -99,4 +104,5 @@ def load_config(config_path: str | None = None) -> AdLoopConfig:
             log_file=safety_raw.get("log_file", "~/.adloop/audit.log"),
             blocked_operations=safety_raw.get("blocked_operations", []),
         ),
+        source_path=resolved,
     )

{adloop-0.6.2 → adloop-0.6.4}/src/adloop/server.py

@@ -8,10 +8,11 @@ from typing import Callable
 from fastmcp import FastMCP
 from mcp.types import ToolAnnotations
 
-from adloop import diagnostics
+from adloop import _mcp_patches, diagnostics
 from adloop.config import load_config
 
 diagnostics.install()
+_mcp_patches.install()
 
 _READONLY = ToolAnnotations(readOnlyHint=True, destructiveHint=False)
 _WRITE = ToolAnnotations(readOnlyHint=False, destructiveHint=False)
@@ -1242,6 +1243,15 @@ def confirm_and_apply(
     IMPORTANT: Defaults to dry_run=True. You MUST explicitly pass dry_run=false
     to make real changes to the Google Ads account.
 
+    Config override: if 'safety.require_dry_run: true' is set in the user's
+    config file (default ~/.adloop/config.yaml), dry_run=false is IGNORED
+    and this tool will keep returning DRY_RUN_SUCCESS. When that happens the
+    response includes 'dry_run_forced_by', 'config_path', and 'remediation'
+    fields — surface those to the user verbatim and STOP retrying. Calling
+    this tool again with dry_run=false will not change anything until the
+    user edits the config file, sets 'require_dry_run: false', and restarts
+    the AdLoop MCP server.
+
     The plan_id comes from a prior draft_* or pause/enable tool call.
     """
     from adloop.ads.write import confirm_and_apply as _impl