notebooklm-mcp-cli 0.7.2__tar.gz → 0.7.4__tar.gz

{notebooklm_mcp_cli-0.7.2 → notebooklm_mcp_cli-0.7.4}/CHANGELOG.md

@@ -7,21 +7,42 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [0.7.2] - 2026-06-08
+## [0.7.4] - 2026-06-15
 
 ### Added
 
-- **ChatGPT File Parameter Upload Bridge (PR #220)** — Enables direct upload of files provided by ChatGPT App/Action clients by resolving and downloading from the client's temporary HTTPS URL before uploading to Google NotebookLM. Thanks to **@insane66613**!
-- **ChatGPT Artifact Download Bridge (PR #220)** — Allows copying generated artifacts to the local server's public directory and returning public download links when the server runs behind secure tunnels. Exposes a new `/artifacts/{filename}` route in the MCP HTTP server. Thanks to **@insane66613**!
-- **Transient Source Content Polling** (`poll_source_content` service function) — Automatically handles Google NotebookLM indexing states (processing, indexing, try again) via robust polling with exponential backoff when fetching raw source contents immediately after creation.
+- **`research_status`: `auto_import` parameter** — Pass `auto_import=True` and the tool automatically imports discovered sources on completion. No separate `research_import` call needed. When `False` (default), the response includes a `next_action` hint pointing you to the exact `research_import` call to make. Fixes the empty-notebook-shell problem reported in #231.
+
+### Fixed
+
+- **`source_list_drive` timeouts on large notebooks (Fixes #232)** — Drive-source freshness checks were made one at a time, in sequence. A notebook with 50 Drive sources took ~30 seconds and routinely hit the 30-second timeout. Freshness checks now run in parallel (8 workers). Measured on a live 44-source notebook: 29s sequential → 3.1s parallel, zero rate-limit errors. If one source's freshness check fails, that source reports `stale: null` instead of failing the whole list.
+- **`research_status` default timeout too short for deep research** — The MCP default was 5 minutes; deep research frequently runs longer. Default `max_wait` bumped to 15 minutes (900s), poll interval stays 30s. The CLI `--auto-import` flow is now consistent: same 15-minute / 30-second cadence instead of the old mode-specific 10-minute / 10-second split.
+- **RPC drift detection silent on empty responses (PR #233, follow-up)** — The `RPCDriftError` doc said "instead of returning silently" but the code still returned `None` silently when the response had no `wrb.fr` chunks to compare against. Clarified the behavior in `CLAUDE.md` and added the MCP server restart requirement to the `NOTEBOOKLM_RPC_OVERRIDES` hot-patch instructions.
+
+### Community
+
+- **RPC resilience (PR #233)** — Runtime RPC-ID overrides via `NOTEBOOKLM_RPC_OVERRIDES`, loud `RPCDriftError` on rotation detection, and exponential-backoff retry for `RESOURCE_EXHAUSTED` (code 8) throttling. Thanks to **@Grobiou** for the contribution!
+
+## [0.7.3] - 2026-06-09
+
+### Added
+
+- **Scripting & Automation section in CLI_GUIDE.md (PR #226)** — Documents how to reliably parse `--json` output in automation scripts using a JSON parser rather than string splitting. Thanks to **@JanaGK2** for the first contribution!
+
+### Fixed
+
+- **Reverted ChatGPT file bridge (PR #220)** — The ChatGPT file upload/download bridge introduced an SSRF vulnerability (no hostname validation on downloaded URLs), a disk leak (every `source_get_content` call wrote files to disk with no cleanup), and unintended behavioral changes to `source_get_content` and `download_artifact` for all users. The feature has been reverted. A future release will re-introduce the polling improvements (`wait`/`poll_interval`) cleanly, and the ChatGPT integration may return in a hardened form.
+- **Tightened `no_proxy` sanitization** — The v0.7.2 sanitizer stripped all `no_proxy` entries containing `:`, incorrectly removing legitimate IPv6 loopback addresses (`::1`) and `host:port` entries. The fix now targets only CIDR-style IPv6 entries (e.g., `fe11::/16`) that crash httpx's URL parser, preserving all other valid entries.
+
+## [0.7.2] - 2026-06-08
 
 ### Fixed
 
-- **Sanitize `no_proxy` environment variable (PR #221)** — Fixed package import crashes on Windows systems by cleaning up the `no_proxy` environment variable on initialization before `httpx` parses it. Thanks to **@insane66613**!
 - **Modern Chrome Cookie DB path detection (PR #222)** — Improved the SQLite cookie database location search logic for Google Chrome to work correctly with modern Chrome setups. Thanks to **@insane66613**!
 - **Profile-aware headless refresh (PR #223)** — Fixed headless login refresh to use the default/active profile configured in the CLI configuration file instead of falling back. Thanks to **@insane66613**!
 - **`AuthHealthChecker` API fallback passed wrong cookie format, causing false `stale` on semi-stale sessions (PR #225)** — The API fallback flattened `profile.cookies` to a dict, dropping domain-specific duplicates and omitting `session_id` / `build_label`. The API probe now passes `profile.cookies` unchanged with all session fields, matching `nlm login --check`. Thanks to **@insane66613**!
 - **`server_info`, `refresh_auth`, and `studio_create` disagreed on semi-stale auth (PR #225, Fixes #224)** — These three MCP paths each ran independent auth checks, so `server_info` could report `stale` and `studio_create` refuse to run while `notebook_list` and CLI tools worked fine. All MCP auth gates now share `credentials_are_usable()` (`AuthHealthChecker` + live API confirmation), eliminating split-brain results. Thanks to **@insane66613**!
+- **Sanitize `no_proxy` environment variable (PR #221)** — Fixed package import crashes on Windows systems caused by CIDR-style IPv6 entries in `no_proxy` that httpx cannot parse. Thanks to **@insane66613**!
 
 ## [0.7.1] - 2026-06-06
 

{notebooklm_mcp_cli-0.7.2 → notebooklm_mcp_cli-0.7.4}/CLAUDE.md

@@ -78,6 +78,16 @@ save_auth_tokens(cookies=<cookie_header>)
 | `NOTEBOOKLM_SESSION_ID` | No | (DEPRECATED - auto-extracted) |
 | `NOTEBOOKLM_BL` | No | Override for build label / bl URL param (auto-extracted from page) |
 | `NOTEBOOKLM_HL` | No | Interface language and default artifact language (default: `en`) |
+| `NOTEBOOKLM_RPC_OVERRIDES` | No | Hot-patch rotated batchexecute RPC method IDs without a release. JSON object mapping `BaseClient` RPC attribute names to new IDs, e.g. `{"RPC_LIST_NOTEBOOKS": "abc123"}` |
+
+### Resilience: rotated RPC IDs
+
+NotebookLM's internal API uses short RPC "method IDs" (e.g. `wXbhsf`) that Google rotates without notice. When one rotates, calls using the old ID fail. The client now:
+
+- **Detects drift loudly**: raises `RPCDriftError` (instead of returning silently) when the server responds with **other** `wrb.fr` RPC IDs than the one requested. An empty response still returns silently (no comparison points), so use `--debug` to inspect in that case.
+- **Discovers the new ID**: run with `--debug` to log `RPC IDs in response: [...]` — the new ID for your call appears there.
+- **Hot-patches without a release**: set `NOTEBOOKLM_RPC_OVERRIDES='{"RPC_LIST_NOTEBOOKS": "<new_id>"}'` (use the `RPC_*` attribute name from `core/base.py`) to override the ID for the current session. **Restart the MCP server for the override to take effect** — the env var is read once at client init, not per call. The CLI (`nlm`) picks it up on the next invocation automatically.
+- **Auto-retries throttling**: `RESOURCE_EXHAUSTED` (RPC error code 8) responses are retried with exponential backoff.
 
 ### Token Expiration
 
@@ -157,8 +167,8 @@ src/notebooklm_tools/
 | `source_rename` | Rename a source in a notebook |
 | `source_delete` | Delete a source from notebook (REQUIRES confirmation) |
 | `research_start` | Start Web or Drive research to discover sources |
-| `research_status` | Check research progress and get results |
-| `research_import` | Import discovered sources into notebook |
+| `research_status` | Check research progress (default: 900s wait, 30s poll). Pass `auto_import=True` to automatically import sources on completion — no separate `research_import` call needed. |
+| `research_import` | Import discovered sources into notebook (manual, if `auto_import` not used) |
 | `studio_create` | Generate unified content (audio, video, infographic, slides, etc.) |
 | `download_artifact` | Download any artifact (audio, video, pdf, markdown, json). Supports `wait`, `wait_timeout`, `poll_interval` params and returns `download_url` when MCP HTTP transport is active. |
 | `export_artifact` | Export Data Tables to Google Sheets or Reports to Google Docs |

{notebooklm_mcp_cli-0.7.2 → notebooklm_mcp_cli-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: notebooklm-mcp-cli
-Version: 0.7.2
+Version: 0.7.4
 Summary: Unified CLI and MCP server for Google NotebookLM
 Project-URL: Homepage, https://github.com/jacob-bd/notebooklm-mcp-cli
 Project-URL: Repository, https://github.com/jacob-bd/notebooklm-mcp-cli

{notebooklm_mcp_cli-0.7.2 → notebooklm_mcp_cli-0.7.4}/desktop-extension/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": "0.2",
   "name": "notebooklm-mcp",
   "display_name": "NotebookLM MCP Server",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "description": "Connect Claude to Google NotebookLM. Create podcasts, research topics, generate quizzes, flashcards, mind maps, and more from your notebooks.",
   "long_description": "This extension connects Claude Desktop to Google NotebookLM via the Model Context Protocol. It provides 29 tools for managing notebooks, sources, and generating AI content.\n\n**Prerequisites:**\n1. Install the package: `pip install notebooklm-mcp-cli` or `uv tool install notebooklm-mcp-cli`\n2. Authenticate: Run `nlm login` to set up your Google account\n\n**Features:**\n- Create and manage notebooks\n- Add sources (URLs, YouTube, Google Drive, text, files)\n- Generate podcasts (Audio Overview)\n- Create quizzes, flashcards, mind maps, reports\n- Research topics with web or Drive search",
   "author": {

{notebooklm_mcp_cli-0.7.2 → notebooklm_mcp_cli-0.7.4}/docs/CLI_GUIDE.md

@@ -367,3 +367,34 @@ nlm download audio ai <artifact-id> --output podcast.mp3
 - Run `nlm login profile list` to see all profiles with their associated email addresses
 - Run `nlm doctor` to diagnose installation, auth, or config issues
 - Use `nlm setup add <client>` to quickly configure MCP for your AI tool
+
+---
+
+## Scripting & Automation
+
+### Getting IDs for piping
+
+Use `--quiet` when you only need IDs — it outputs one ID per line, no parsing required:
+
+```bash
+# Grab the first notebook ID in a shell script
+notebook_id=$(nlm notebook list --quiet | head -1)
+nlm notebook query "$notebook_id" "Summarize key points"
+```
+
+### Parsing `--json` output
+
+When you need more than just IDs (title, source count, etc.), use `--json`. It emits
+clean JSON to stdout — always parse it properly rather than splitting strings:
+
+```python
+import json
+import subprocess
+
+result = subprocess.run(
+    ["nlm", "notebook", "list", "--json"],
+    capture_output=True, text=True
+)
+notebooks = json.loads(result.stdout)
+notebook_id = notebooks[0]["id"]   # UUID like "abc12345-..."
+```

{notebooklm_mcp_cli-0.7.2 → notebooklm_mcp_cli-0.7.4}/docs/MCP_GUIDE.md

@@ -224,8 +224,10 @@ tag(action="select", query="ai research")  # Find notebooks by tag match
 
 ```
 1. research_start(query="AI trends 2026", mode="deep")
-2. research_status(notebook_id, max_wait=300)  # wait for completion
-3. research_import(notebook_id, task_id, cited_only=True, timeout=600)  # optional cited subset
+2. research_status(notebook_id, auto_import=True)  # waits up to 15 min, imports automatically
+# Or review sources first, then import manually:
+2a. research_status(notebook_id)  # waits up to 15 min, returns next_action hint
+2b. research_import(notebook_id, task_id, cited_only=True, timeout=600)  # optional cited subset
 4. studio_create(notebook_id, artifact_type="audio", confirm=True)
 5. studio_status(notebook_id)  # poll until complete
 6. download_artifact(notebook_id, artifact_type="audio", output_path="podcast.mp3")

{notebooklm_mcp_cli-0.7.2 → notebooklm_mcp_cli-0.7.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "notebooklm-mcp-cli"
-version = "0.7.2"
+version = "0.7.4"
 description = "Unified CLI and MCP server for Google NotebookLM"
 readme = "README.md"
 license = "MIT"

{notebooklm_mcp_cli-0.7.2 → notebooklm_mcp_cli-0.7.4}/src/notebooklm_tools/__init__.py

@@ -6,7 +6,7 @@ from typing import Any
 
 import notebooklm_tools.utils.env_sanitize as _env_sanitize  # noqa: F401
 
-__version__ = "0.7.2"
+__version__ = "0.7.4"
 
 __all__ = ["NotebookLMClient", "__version__"]
 

{notebooklm_mcp_cli-0.7.2 → notebooklm_mcp_cli-0.7.4}/src/notebooklm_tools/cli/ai_docs.py

@@ -304,10 +304,10 @@ nlm research start "query" --notebook-id <id>                    # Fast web (def
 nlm research start "query" --notebook-id <id> --mode deep        # Deep web (~5min)
 nlm research start "query" --notebook-id <id> --source drive     # Fast drive
 nlm research start "query" --notebook-id <id> --force            # Override pending
-nlm research start "query" --notebook-id <id> --auto-import      # Auto wait and import
+nlm research start "query" --notebook-id <id> --auto-import      # Auto wait (15min) and import
 
 # Check progress
-nlm research status <notebook-id>                    # Poll until done (5min max)
+nlm research status <notebook-id>                    # Poll until done (15min max, 30s interval)
 nlm research status <notebook-id> --max-wait 0       # Single check
 nlm research status <notebook-id> --task-id <tid>    # Specific task
 nlm research status <notebook-id> --full             # Full details

{notebooklm_mcp_cli-0.7.2 → notebooklm_mcp_cli-0.7.4}/src/notebooklm_tools/cli/commands/research.py

@@ -141,15 +141,13 @@ def start_research(
             ) as progress:
                 progress.add_task("Gathering sources...", total=None)
 
-                # Use a larger timeout for deep mode
-                max_wait = 600 if mode == "deep" else 120
                 with get_client(profile) as import_client:
                     poll_res = research_service.poll_research(
                         import_client,
                         notebook_id,
                         task_id=result["task_id"],
-                        poll_interval=10,
-                        max_wait=max_wait,
+                        poll_interval=30,
+                        max_wait=900,
                     )
 
             _display_research_status(poll_res, compact=True)

{notebooklm_mcp_cli-0.7.2 → notebooklm_mcp_cli-0.7.4}/src/notebooklm_tools/core/base.py

@@ -25,7 +25,7 @@ from notebooklm_tools.utils.config import get_base_url
 from . import constants
 from .data_types import ConversationTurn
 from .errors import ClientAuthenticationError as AuthenticationError
-from .errors import ResourceExhaustedError, RPCError
+from .errors import ResourceExhaustedError, RPCDriftError, RPCError
 from .retry import DEFAULT_BASE_DELAY, DEFAULT_MAX_DELAY, DEFAULT_MAX_RETRIES, is_retryable_error
 from .utils import (
     RPC_NAMES,
@@ -60,6 +60,28 @@ def _safe_int_env(name: str, default: int) -> int:
     return value
 
 
+def load_rpc_overrides() -> dict[str, str]:
+    """Load runtime RPC-ID overrides from NOTEBOOKLM_RPC_OVERRIDES.
+
+    Lets users hot-patch rotated batchexecute method IDs without a release.
+    The value is a JSON object mapping BaseClient RPC attribute names to new
+    IDs, e.g. '{"RPC_LIST_NOTEBOOKS": "abc123"}'. Returns {} if unset, empty,
+    or malformed (a warning is logged on malformed input).
+    """
+    raw = os.environ.get("NOTEBOOKLM_RPC_OVERRIDES", "").strip()
+    if not raw:
+        return {}
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError as e:
+        logger.warning("Ignoring malformed NOTEBOOKLM_RPC_OVERRIDES: %s", e)
+        return {}
+    if not isinstance(data, dict):
+        logger.warning("Ignoring NOTEBOOKLM_RPC_OVERRIDES: expected a JSON object")
+        return {}
+    return {str(k): str(v) for k, v in data.items()}
+
+
 def _extract_user_message(detail_data: Any, _depth: int = 0) -> str:
     """Recursively extract human-readable strings from a protobuf detail payload.
 
@@ -370,6 +392,9 @@ class BaseClient:
         # It is never held during network I/O.
         self._state_lock = threading.Lock()
 
+        # Apply any runtime RPC-ID overrides (hot-patch for rotated method IDs).
+        self._apply_rpc_overrides()
+
         # Only refresh CSRF token if not provided - tokens actually last hours/days, not minutes
         # The retry logic in _call_rpc() handles expired tokens gracefully
         if not self.csrf_token:
@@ -387,6 +412,21 @@ class BaseClient:
             self._client.close()
             self._client = None
 
+    def _apply_rpc_overrides(self) -> None:
+        """Apply NOTEBOOKLM_RPC_OVERRIDES as instance attributes.
+
+        Each entry shadows the matching class-level RPC_* constant on this
+        instance only. Unknown keys (not an existing RPC_* attribute) are
+        logged and ignored so a typo can never silently disable a tool.
+        """
+        for name, new_id in load_rpc_overrides().items():
+            if not name.startswith("RPC_") or not hasattr(type(self), name):
+                logger.warning("Ignoring unknown RPC override: %s", name)
+                continue
+            old_id = getattr(type(self), name)
+            setattr(self, name, new_id)
+            logger.warning("RPC override applied: %s %s -> %s", name, old_id, new_id)
+
     # =========================================================================
     # Cookie Handling
     # =========================================================================
@@ -647,8 +687,31 @@ class BaseClient:
                                 except json.JSONDecodeError:
                                     return result_str
                             return result_str
+        present = self._extract_present_rpc_ids(parsed_response)
+        if present and rpc_id not in present:
+            raise RPCDriftError(rpc_id, present)
         return None
 
+    def _extract_present_rpc_ids(self, parsed_response: list) -> list[str]:
+        """Return the rpc_ids of every wrb.fr chunk in a parsed response.
+
+        Used for drift diagnostics: when the expected rpc_id is missing, this
+        reveals which IDs the server actually returned so the user can set
+        NOTEBOOKLM_RPC_OVERRIDES.
+        """
+        present: list[str] = []
+        for chunk in parsed_response:
+            if isinstance(chunk, list):
+                for item in chunk:
+                    if (
+                        isinstance(item, list)
+                        and len(item) >= 2
+                        and item[0] == "wrb.fr"
+                        and isinstance(item[1], str)
+                    ):
+                        present.append(item[1])
+        return present
+
     def _call_rpc(
         self,
         rpc_id: str,
@@ -714,6 +777,8 @@ class BaseClient:
 
             # Check for RPC-level errors (soft auth failure)
             parsed = self._parse_response(response.text)
+            if logger.isEnabledFor(logging.DEBUG):
+                logger.debug("RPC IDs in response: %s", self._extract_present_rpc_ids(parsed))
             result = self._extract_rpc_result(parsed, rpc_id)
 
             # Enhanced debug logging for extracted result
@@ -764,6 +829,31 @@ class BaseClient:
             # Fall through to auth recovery below
             pass
 
+        except ResourceExhaustedError:
+            # RPC-level rate limit (HTTP 200, error code 8). Back off and retry.
+            if _server_retry < DEFAULT_MAX_RETRIES:
+                import time as _time
+
+                delay = min(DEFAULT_BASE_DELAY * (2**_server_retry), DEFAULT_MAX_DELAY)
+                logger.warning(
+                    "RPC rate limit (RESOURCE_EXHAUSTED) on %s, attempt %d/%d, retrying in %.1fs...",
+                    rpc_id,
+                    _server_retry + 1,
+                    DEFAULT_MAX_RETRIES + 1,
+                    delay,
+                )
+                _time.sleep(delay)
+                return self._call_rpc(
+                    rpc_id,
+                    params,
+                    path,
+                    timeout,
+                    _retry,
+                    _deep_retry,
+                    _server_retry=_server_retry + 1,
+                )
+            raise
+
         except AuthenticationError:
             # RPC Error 16 - fall through to auth recovery below
             pass

{notebooklm_mcp_cli-0.7.2 → notebooklm_mcp_cli-0.7.4}/src/notebooklm_tools/core/errors.py

@@ -142,3 +142,30 @@ class ResourceExhaustedError(RPCError):
 
     def __init__(self, message: str, detail_type: str = "", detail_data=None):
         super().__init__(message, error_code=8, detail_type=detail_type, detail_data=detail_data)
+
+
+class RPCDriftError(NotebookLMError):
+    """Raised when the response contains other RPC IDs but not the one requested.
+
+    The usual cause is Google rotating the batchexecute method ID. The message
+    names the missing id, lists the ids the server *did* return, and points the
+    user at NOTEBOOKLM_RPC_OVERRIDES to hot-patch it without a release.
+
+    Deliberately extends NotebookLMError directly, NOT RPCError: drift must
+    bypass the service-layer ``except RPCError`` handlers so its actionable
+    NOTEBOOKLM_RPC_OVERRIDES guidance reaches the user verbatim instead of
+    being reformatted into a generic service error. (Contrast with
+    ResourceExhaustedError, which subclasses RPCError on purpose so existing
+    handlers still catch it.)
+    """
+
+    def __init__(self, rpc_id: str, present_ids: list[str] | None = None):
+        present = ", ".join(present_ids) if present_ids else "(none)"
+        super().__init__(
+            f"No result for RPC '{rpc_id}' — the method ID may have been rotated by Google. "
+            f"RPC IDs present in the response: {present}. "
+            f'Hot-patch it by setting NOTEBOOKLM_RPC_OVERRIDES=\'{{"<ATTR_NAME>": "<new_id>"}}\' '
+            f"(run with --debug to inspect the response)."
+        )
+        self.rpc_id = rpc_id
+        self.present_ids = present_ids or []

{notebooklm_mcp_cli-0.7.2 → notebooklm_mcp_cli-0.7.4}/src/notebooklm_tools/data/AGENTS_SECTION.md

@@ -1,5 +1,5 @@
 <!-- nlm-skill-start -->
-<!-- nlm-version: 0.7.2 -->
+<!-- nlm-version: 0.7.3 -->
 ## NLM - NotebookLM CLI Expert
 
 **Triggers:** "nlm", "notebooklm", "notebook lm", "podcast", "audio overview", "research"

{notebooklm_mcp_cli-0.7.2 → notebooklm_mcp_cli-0.7.4}/src/notebooklm_tools/data/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: nlm-skill
-version: "0.7.2"
+version: "0.7.3"
 description: "Expert guide for the NotebookLM CLI (`nlm`) and MCP server - interfaces for Google NotebookLM. Use this skill when users want to interact with NotebookLM programmatically, including: creating/managing notebooks, adding sources (URLs, YouTube, text, Google Drive), generating content (podcasts, reports, quizzes, flashcards, mind maps, slides, infographics, videos, data tables), conducting research, chatting with sources, or automating NotebookLM workflows. Triggers on mentions of \"nlm\", \"notebooklm\", \"notebook lm\", \"podcast generation\", \"audio overview\", or any NotebookLM-related automation task."
 ---
 

{notebooklm_mcp_cli-0.7.2 → notebooklm_mcp_cli-0.7.4}/src/notebooklm_tools/mcp/server.py

@@ -20,23 +20,18 @@ Tool Modules:
 import argparse
 import logging
 import os
-from pathlib import Path
 
 from fastmcp import FastMCP
-from starlette.middleware import Middleware
-from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.requests import Request
-from starlette.responses import FileResponse, JSONResponse, Response
+from starlette.responses import JSONResponse
 
 from notebooklm_tools import __version__
 
-from .tools._utils import PUBLIC_DIR, reset_mcp_base_url, set_mcp_base_url
-
 _FALSY = frozenset({"false", "0", "no", "off"})
 
 
 def _env_bool(name: str, default: bool = False) -> bool:
-    """Read a boolean from an environment variable. Unset/empty → *default*; otherwise ``false|0|no|off`` (case-insensitive) → False, anything else → True."""
+    """Read a boolean from an environment variable. Unset/empty → *default*; otherwise ``false|0|no|off`` (case-insensitive) → False, anything else → True."""
     raw = os.environ.get(name, "")
     if not raw:
         return default
@@ -78,46 +73,6 @@ async def health_check(request: Request) -> JSONResponse:
     )
 
 
-class BaseUrlMiddleware(BaseHTTPMiddleware):
-    async def dispatch(self, request: Request, call_next):
-        host = request.headers.get(
-            "x-forwarded-host", request.headers.get("host", "127.0.0.1:8000")
-        )
-        proto = request.headers.get("x-forwarded-proto", "http")
-        base_url = f"{proto}://{host}"
-
-        token = set_mcp_base_url(base_url)
-        try:
-            return await call_next(request)
-        finally:
-            reset_mcp_base_url(token)
-
-
-# Ensure FastMCP applies the HTTP middleware to the actual served Starlette app.
-_original_http_app = mcp.http_app
-
-
-def _http_app_with_base_url(*args, middleware=None, **kwargs):
-    merged_middleware = [Middleware(BaseUrlMiddleware), *(middleware or [])]
-    return _original_http_app(*args, middleware=merged_middleware, **kwargs)
-
-
-mcp.http_app = _http_app_with_base_url
-
-
-# Custom route to serve public artifacts
-@mcp.custom_route("/artifacts/{filename}", methods=["GET"])
-async def get_public_artifact(request: Request) -> Response:
-    """Serve downloaded artifacts and source files via the public URL."""
-    filename = request.path_params["filename"]
-    # Clean the path to prevent directory traversal
-    safe_name = Path(filename).name
-    filepath = PUBLIC_DIR / safe_name
-    if not filepath.exists() or not filepath.is_file():
-        return Response("File not found", status_code=404)
-    return FileResponse(str(filepath))
-
-
 def _register_tools() -> None:
     """Import and register all tools from the modular tools package."""
     # Import all tool modules to populate the registry
@@ -214,7 +169,7 @@ Examples:
         default=_env_bool("NOTEBOOKLM_MCP_STATELESS", default=True),
         help=(
             "Stateless HTTP sessions (default: true). Avoids MCP SDK double-response crash "
-            "(python-sdk#2416). NOTE: this affects the MCP HTTP transport layer only — "
+            "(python-sdk#2416). NOTE: this affects the MCP HTTP transport layer only — "
             "it does NOT control the in-process conversation history cache. To bound the "
             "conversation cache (e.g. for long-lived servers), set "
             "NOTEBOOKLM_CONVERSATION_MAX_TURNS / NOTEBOOKLM_CONVERSATION_MAX_CONVS."
@@ -286,7 +241,7 @@ Examples:
             if not _env_bool("NOTEBOOKLM_ALLOW_EXTERNAL_BIND"):
                 print(
                     f"SECURITY ERROR: Refusing to bind to non-loopback address '{args.host}'.\n"
-                    "There is no built-in authentication — binding externally exposes\n"
+                    "There is no built-in authentication — binding externally exposes\n"
                     "your Google cookies to anyone on the network.\n\n"
                     "To override, set: NOTEBOOKLM_ALLOW_EXTERNAL_BIND=1",
                     file=sys.stderr,

{notebooklm_mcp_cli-0.7.2 → notebooklm_mcp_cli-0.7.4}/src/notebooklm_tools/mcp/tools/_utils.py

@@ -7,64 +7,17 @@ import logging
 import os
 import threading
 from collections.abc import Awaitable, Callable
-from contextvars import ContextVar
-from pathlib import Path
 from typing import Any, ParamSpec, TypeAlias, TypeVar, cast
 
 from notebooklm_tools.core.client import NotebookLMClient
 from notebooklm_tools.core.utils import extract_cookies_from_chrome_export
 from notebooklm_tools.services.auth import load_cached_tokens
-from notebooklm_tools.utils.config import get_data_dir
-
-mcp_base_url: ContextVar[str] = ContextVar("mcp_base_url", default="")
-_last_mcp_base_url = ""
-_base_url_lock = threading.Lock()
-PUBLIC_DIR: Path = get_data_dir() / "public_artifacts"
-
-
-def set_mcp_base_url(base_url: str) -> object:
-    """Store the current public MCP base URL for tool-generated links."""
-    global _last_mcp_base_url
-    normalized = base_url.rstrip("/")
-    with _base_url_lock:
-        _last_mcp_base_url = normalized
-    return mcp_base_url.set(normalized)
-
-
-def reset_mcp_base_url(token: object) -> None:
-    """Reset the request-local base URL without clearing the process fallback."""
-    mcp_base_url.reset(token)
-
-
-def get_mcp_base_url() -> str:
-    """Return the request-local base URL or the last seen HTTP base URL.
-
-    FastMCP may execute sync tools outside the ASGI context where the middleware
-    set the ContextVar. The process fallback preserves the tunnel host captured
-    from the current or most recent HTTP request.
-    """
-    current = mcp_base_url.get()
-    if current:
-        return current
-    with _base_url_lock:
-        return _last_mcp_base_url
-
 
 # MCP request/response logger
 mcp_logger = logging.getLogger("notebooklm_tools.mcp")
 
 # Parameters that must never appear in log output
-_SENSITIVE_PARAMS = frozenset(
-    {
-        "cookies",
-        "csrf_token",
-        "session_id",
-        "request_body",
-        "download_url",
-        "download_link",
-        "file",
-    }
-)
+_SENSITIVE_PARAMS = frozenset({"cookies", "csrf_token", "session_id", "request_body"})
 P = ParamSpec("P")
 R = TypeVar("R")
 T = TypeVar("T")
@@ -197,13 +150,10 @@ def get_mcp_instance() -> Any:
 
 
 # Registry for tools - allows registration without immediate mcp dependency
-_tool_registry: list[tuple[str, Callable[..., Any], dict[str, Any] | None]] = []
+_tool_registry: list[tuple[str, Callable[..., Any]]] = []
 
 
-def logged_tool(
-    *,
-    meta: dict[str, Any] | None = None,
-) -> Callable[[Callable[P, Any]], Callable[P, Any]]:
+def logged_tool() -> Callable[[Callable[P, Any]], Callable[P, Any]]:
     """Decorator that adds MCP request/response logging to a tool.
 
     Decorated tools are added to the internal registry for later MCP server
@@ -259,7 +209,7 @@ def logged_tool(
             wrapper = sync_wrapper
 
         # Store for later registration
-        _tool_registry.append((func.__name__, cast(Callable[..., Any], wrapper), meta))
+        _tool_registry.append((func.__name__, cast(Callable[..., Any], wrapper)))
         return wrapper
 
     return decorator
@@ -267,11 +217,8 @@ def logged_tool(
 
 def register_all_tools(mcp: Any) -> None:
     """Register all collected tools with the MCP instance."""
-    for _, wrapper, meta in _tool_registry:
-        if meta:
-            mcp.tool(meta=meta)(wrapper)
-        else:
-            mcp.tool()(wrapper)
+    for _, wrapper in _tool_registry:
+        mcp.tool()(wrapper)
 
 
 # Essential cookies for NotebookLM API authentication