botable-dev 0.3.1__tar.gz → 0.3.2__tar.gz

{botable_dev-0.3.1 → botable_dev-0.3.2}/.github/workflows/ci.yml

@@ -8,7 +8,8 @@ on:
 
 jobs:
   lint-and-test:
-    runs-on: ubuntu-latest
+    # Never GitHub-hosted runners (owner rule): org self-hosted Linux runners only.
+    runs-on: [self-hosted, Linux]
     strategy:
       matrix:
         python-version: ["3.10", "3.11", "3.12"]

{botable_dev-0.3.1 → botable_dev-0.3.2}/.github/workflows/publish.yml

@@ -10,7 +10,7 @@ on:
 jobs:
   publish:
     # GitHub-hosted minutes are exhausted for the org; pc-3060 is the org-level self-hosted runner (private repos only).
-    runs-on: [self-hosted, Linux, pc-3060]
+    runs-on: [self-hosted, Linux]
     permissions:
       id-token: write
       contents: read

{botable_dev-0.3.1 → botable_dev-0.3.2}/AGENTS.md

@@ -11,7 +11,7 @@
 
 ## Purpose
 
-PyPI package **`botable`** (v0.2.0) -- Typer-based CLI for generating Telegram bots via the
+PyPI package **`botable-dev`** (v0.3.2) -- Typer-based CLI for generating Telegram bots via the
 Botable platform API. Also contains the **Telegram status bot** for staging server monitoring.
 Stack: **Typer**, **Rich**, **httpx**, **OpenAI** (for local generation).
 
@@ -27,7 +27,7 @@ cli/
       __init__.py              # __version__
       __main__.py              # `python -m botable` entry
       cli.py                   # Typer app, all commands registered here
-      mcp_install.py           # Claude/Codex MCP config registration
+      mcp_install.py           # Claude/Codex/Cursor MCP config registration
       config.py                # 3-layer config merge (defaults -> user -> project)
       api_client.py            # httpx client for backend API
       generate.py              # Bot generation logic (local + remote)
@@ -66,7 +66,7 @@ Entry point: `botable = "botable.cli:app"` (defined in `pyproject.toml`).
 | `botable logs`      | Show bot status snapshot (`--json` supported) |
 | `botable version`   | Show version and effective API URL           |
 | `botable login`     | Browser device login or `--api-key`          |
-| `botable mcp install` | Register Claude Code and/or Codex MCP     |
+| `botable mcp install` | Register Claude Code, Codex, and/or Cursor MCP |
 | `botable bots`      | List user's bots                             |
 | `botable templates` | Browse available templates                   |
 | `botable credits`   | Check credit balance                         |
@@ -105,7 +105,7 @@ Later layers override earlier ones. Auth token and API URL are stored in the use
 
 - Build system: **hatchling**
 - Publish: `python -m build && twine upload dist/*`
-- Version: defined in `pyproject.toml` (`version = "0.2.0"`)
+- Version: defined in `pyproject.toml` (`version = "0.3.2"`)
 - PyPI: https://pypi.org/project/botable-dev/ (the name `botable` belongs to an unrelated package)
 - Python: `>=3.10`
 

{botable_dev-0.3.1 → botable_dev-0.3.2}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.5
 Name: botable-dev
-Version: 0.3.1
-Summary: Botable CLI: build, deploy and run Telegram bots from your terminal, Claude Code or Codex
+Version: 0.3.2
+Summary: Botable CLI: build, deploy and run Telegram bots from your terminal, Claude Code, Codex or Cursor
 Project-URL: Homepage, https://botable.dev
 Author-email: Botable Team <hello@botable.dev>
 License-Expression: MIT
@@ -87,7 +87,7 @@ botable dev
 |---------|-------------|
 | `botable login [--no-browser]` | Sign in through the browser |
 | `botable login --api-key KEY [--api-url URL]` | Save an existing API key and API URL |
-| `botable mcp install [--target claude\|codex\|all] [--scope user\|project]` | Configure agent MCP clients |
+| `botable mcp install [--target claude\|codex\|cursor\|all] [--scope user\|project]` | Configure agent MCP clients |
 | `botable logout` | Remove stored authentication |
 | `botable deploy` | Deploy to Botable cloud |
 | `botable logs [project_id]` | Show the current bot status snapshot |
@@ -96,6 +96,8 @@ botable dev
 
 ## Deploy to Cloud
 
+Cloud deployment is in **closed beta and requires an invitation** from the Botable team. Accounts without access receive an invitation message and a nonzero exit status; retrying or signing in again does not grant access.
+
 ```bash
 botable login
 
@@ -135,10 +137,14 @@ botable logs PROJECT_ID
 
 **`botable deploy` uploads the project's `.env` file**, including any secrets in it. Check its contents before deployment. `botable logs` currently returns a status snapshot; runtime log lines and live streaming are not available through the CLI API yet.
 
-`botable mcp install` registers the installed `botable-mcp` executable with Claude Code and Codex. Use `--target` to select one client. Claude uses its `claude mcp add` command when installed; without Claude, `--scope project` writes project `.mcp.json` (the default user scope requires Claude). Codex configuration goes in `~/.codex/config.toml` with a backup of an existing file. Check with `claude mcp list` or `codex mcp list`.
+`botable mcp install` defaults to `--target all`: it attempts Claude Code and writes Codex configuration, and configures Cursor only when `~/.cursor` exists (dangling directory symlinks are skipped). Use `--target cursor` to create Cursor configuration explicitly even if that directory is absent. Claude uses its `claude mcp add` command when installed; without Claude, `--scope project` writes project `.mcp.json` (the default user scope requires Claude). Codex configuration goes in `~/.codex/config.toml`, and Cursor configuration goes in `~/.cursor/mcp.json`. Empty or whitespace-only JSON is treated as an empty config, and UTF-8 BOMs are accepted. Invalid Cursor JSON is left untouched. Under `all`, invalid Cursor JSON and any Cursor filesystem error (read, directory creation, or write) produce a warning, succeeding if another client was configured; explicit `--target cursor` fails. Errors for other clients still fail the command, except unavailable clients under `all` when another client was configured.
+
+After fully writing the temporary file and before replacing an existing config, the installer creates a unique timestamped `.bak` file beside its resolved target; project-scope Claude backups go in `~/.config/botable/` to keep them out of the bot repository. New files need no backup, and earlier backups are preserved. It writes atomically, preserving existing symlinks and file permissions. Cursor requires an installed `botable-mcp` executable so its config can use an absolute path; discovery checks PATH, the active Python's directory, and Python's regular and user scripts directories. Check with `claude mcp list`, `codex mcp list`, or Cursor Settings > Tools & MCP.
 
 The MCP server exposes project creation, generation, templates, local development, deployment, bot listing, status, and the available status snapshot through its logs tool. Its former SSH staging status tool was removed because it requires operator access and is unrelated to customer bots. The MCP server uses the API URL and key saved by `botable login` (or the `BOTABLE_API_URL` environment override).
 
+The MCP server instructions and deploy tool description require the agent to show the project name/id and upload filenames, compare against your bot list, confirm an existing bot update or new bot, explain the `.env` upload, and obtain an explicit yes before deployment. They also prohibit printing secrets. These instructions remain available when the agent restarts.
+
 ### Branding
 
 Every generated bot includes a `# Built with Botable` comment. Customize or disable it:

{botable_dev-0.3.1 → botable_dev-0.3.2}/README.md

@@ -48,7 +48,7 @@ botable dev
 |---------|-------------|
 | `botable login [--no-browser]` | Sign in through the browser |
 | `botable login --api-key KEY [--api-url URL]` | Save an existing API key and API URL |
-| `botable mcp install [--target claude\|codex\|all] [--scope user\|project]` | Configure agent MCP clients |
+| `botable mcp install [--target claude\|codex\|cursor\|all] [--scope user\|project]` | Configure agent MCP clients |
 | `botable logout` | Remove stored authentication |
 | `botable deploy` | Deploy to Botable cloud |
 | `botable logs [project_id]` | Show the current bot status snapshot |
@@ -57,6 +57,8 @@ botable dev
 
 ## Deploy to Cloud
 
+Cloud deployment is in **closed beta and requires an invitation** from the Botable team. Accounts without access receive an invitation message and a nonzero exit status; retrying or signing in again does not grant access.
+
 ```bash
 botable login
 
@@ -96,10 +98,14 @@ botable logs PROJECT_ID
 
 **`botable deploy` uploads the project's `.env` file**, including any secrets in it. Check its contents before deployment. `botable logs` currently returns a status snapshot; runtime log lines and live streaming are not available through the CLI API yet.
 
-`botable mcp install` registers the installed `botable-mcp` executable with Claude Code and Codex. Use `--target` to select one client. Claude uses its `claude mcp add` command when installed; without Claude, `--scope project` writes project `.mcp.json` (the default user scope requires Claude). Codex configuration goes in `~/.codex/config.toml` with a backup of an existing file. Check with `claude mcp list` or `codex mcp list`.
+`botable mcp install` defaults to `--target all`: it attempts Claude Code and writes Codex configuration, and configures Cursor only when `~/.cursor` exists (dangling directory symlinks are skipped). Use `--target cursor` to create Cursor configuration explicitly even if that directory is absent. Claude uses its `claude mcp add` command when installed; without Claude, `--scope project` writes project `.mcp.json` (the default user scope requires Claude). Codex configuration goes in `~/.codex/config.toml`, and Cursor configuration goes in `~/.cursor/mcp.json`. Empty or whitespace-only JSON is treated as an empty config, and UTF-8 BOMs are accepted. Invalid Cursor JSON is left untouched. Under `all`, invalid Cursor JSON and any Cursor filesystem error (read, directory creation, or write) produce a warning, succeeding if another client was configured; explicit `--target cursor` fails. Errors for other clients still fail the command, except unavailable clients under `all` when another client was configured.
+
+After fully writing the temporary file and before replacing an existing config, the installer creates a unique timestamped `.bak` file beside its resolved target; project-scope Claude backups go in `~/.config/botable/` to keep them out of the bot repository. New files need no backup, and earlier backups are preserved. It writes atomically, preserving existing symlinks and file permissions. Cursor requires an installed `botable-mcp` executable so its config can use an absolute path; discovery checks PATH, the active Python's directory, and Python's regular and user scripts directories. Check with `claude mcp list`, `codex mcp list`, or Cursor Settings > Tools & MCP.
 
 The MCP server exposes project creation, generation, templates, local development, deployment, bot listing, status, and the available status snapshot through its logs tool. Its former SSH staging status tool was removed because it requires operator access and is unrelated to customer bots. The MCP server uses the API URL and key saved by `botable login` (or the `BOTABLE_API_URL` environment override).
 
+The MCP server instructions and deploy tool description require the agent to show the project name/id and upload filenames, compare against your bot list, confirm an existing bot update or new bot, explain the `.env` upload, and obtain an explicit yes before deployment. They also prohibit printing secrets. These instructions remain available when the agent restarts.
+
 ### Branding
 
 Every generated bot includes a `# Built with Botable` comment. Customize or disable it:

{botable_dev-0.3.1 → botable_dev-0.3.2}/botable_mcp/__init__.py

@@ -1,3 +1,3 @@
 """Botable MCP Server — exposes Botable CLI tools via the Model Context Protocol."""
 
-__version__ = "0.1.0"
+__version__ = "0.3.2"

{botable_dev-0.3.1 → botable_dev-0.3.2}/botable_mcp/server.py

@@ -32,7 +32,19 @@ except ModuleNotFoundError as exc:
         raise
     FastMCP = None
 
-mcp = FastMCP("botable", instructions="Botable CLI tools for Telegram bots") if FastMCP else None
+DEPLOY_CONSENT_INSTRUCTIONS = """Before every deployment, show the user the botable.toml
+[project] name and id (or state that id is absent), and the names of the files to
+upload: main.py, requirements.txt, .env, and botable.toml, reporting any absent files.
+Compare the project name and id against botable_bots_list (botable bots list).
+An existing id or a case-insensitive name match may update an existing bot. Confirm
+which bot will be overwritten, or confirm creation of a new bot; resolve ambiguity
+before deploying. Tell the user that .env will be uploaded and can contain secrets.
+Obtain an explicit yes for this deployment after showing these details, then call
+botable_deploy. Never print secrets, tokens, API keys, or .env contents.
+If deployment reports that this account needs a closed beta invitation, stop and
+explain that an invitation from the Botable team is required."""
+
+mcp = FastMCP("botable", instructions="Botable CLI tools for Telegram bots.\n" + DEPLOY_CONSENT_INSTRUCTIONS) if FastMCP else None
 tool = mcp.tool if mcp else lambda: lambda fn: fn
 
 # ---------------------------------------------------------------------------
@@ -187,7 +199,15 @@ async def botable_dev(project_dir: str) -> str:
 async def botable_deploy(project_dir: str) -> str:
     """Deploy a Botable project; return JSON with project_id, state, and message.
 
-    The CLI uploads the project's .env file with its other project files.
+    Before calling, show botable.toml [project] name/id (or absent id) and files
+    to upload: main.py, requirements.txt, .env, botable.toml (note absent files).
+    Compare name/id against botable_bots_list / botable bots list: an existing id
+    or case-insensitive name match can overwrite a bot. Confirm which bot will be
+    overwritten or that a new bot will be created, resolving ambiguity first.
+    Explicitly say .env is uploaded and may contain secrets, then obtain an
+    explicit yes for this deployment. Never print secrets, keys, tokens, or .env
+    contents. If closed beta access is refused, stop and explain the invitation
+    requirement.
     """
     project_dir = os.path.expanduser(project_dir)
     if not os.path.isdir(project_dir):

{botable_dev-0.3.1 → botable_dev-0.3.2}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "botable-dev"
-version = "0.3.1"
-description = "Botable CLI: build, deploy and run Telegram bots from your terminal, Claude Code or Codex"
+version = "0.3.2"
+description = "Botable CLI: build, deploy and run Telegram bots from your terminal, Claude Code, Codex or Cursor"
 readme = "README.md"
 license = "MIT"
 license-files = ["LICENSE"]

{botable_dev-0.3.1 → botable_dev-0.3.2}/src/botable/__init__.py

@@ -1,3 +1,3 @@
 """Botable CLI — Generate Telegram bots with AI."""
 
-__version__ = "0.3.1"
+__version__ = "0.3.2"

{botable_dev-0.3.1 → botable_dev-0.3.2}/src/botable/cli.py

@@ -419,14 +419,15 @@ app.add_typer(mcp_app, name="mcp")
 
 @mcp_app.command("install")
 def mcp_install(
-    target: str = typer.Option("all", "--target", help="claude, codex, or all"),
+    target: str = typer.Option("all", "--target", help="claude, codex, cursor, or all"),
     scope: str = typer.Option("user", "--scope", help="Claude scope: user or project"),
 ):
-    """Register the Botable MCP server with Claude Code and/or Codex."""
-    from botable.mcp_install import _mcp_command, install_claude, install_codex
+    """Register the Botable MCP server with Claude Code, Codex, and/or Cursor."""
+    from pathlib import Path
+    from botable.mcp_install import CursorConfigError, _mcp_command, install_claude, install_codex, install_cursor
 
-    if target not in ("claude", "codex", "all") or scope not in ("user", "project"):
-        error("Use --target claude|codex|all and --scope user|project.")
+    if target not in ("claude", "codex", "cursor", "all") or scope not in ("user", "project"):
+        error("Use --target claude|codex|cursor|all and --scope user|project.")
         raise typer.Exit(2)
     if _mcp_command() == "botable-mcp" and not shutil.which("botable-mcp"):
         typer.echo('Warning: botable-mcp not found; install "botable-dev[mcp]" first.')
@@ -436,19 +437,30 @@ def mcp_install(
     for name, install, verify in (
         ("claude", lambda: install_claude(scope), "claude mcp list"),
         ("codex", install_codex, "codex mcp list"),
+        ("cursor", install_cursor, "Cursor Settings > Tools & MCP"),
     ):
         if target not in (name, "all"):
             continue
         try:
+            if name == "cursor" and target == "all":
+                cursor_dir = Path.home() / ".cursor"
+                if not cursor_dir.exists():
+                    reason = "a dangling symlink" if cursor_dir.is_symlink() else "absent"
+                    typer.echo(f"Skipping Cursor: ~/.cursor is {reason} (use --target cursor to configure it explicitly).")
+                    continue
             typer.echo(install())
             typer.echo(f"Verify: {verify}")
             configured += 1
-        except FileNotFoundError as exc:
-            error(f"{name} MCP unavailable: {exc}")
-            missing = True
         except (OSError, ValueError, subprocess.CalledProcessError) as exc:
-            error(f"{name} MCP install failed: {exc}")
-            failed = True
+            if name == "cursor" and target == "all" and isinstance(exc, (OSError, CursorConfigError)):
+                typer.echo(f"Warning: cursor MCP skipped: {exc}")
+                missing = True
+            elif isinstance(exc, FileNotFoundError):
+                error(f"{name} MCP unavailable: {exc}")
+                missing = True
+            else:
+                error(f"{name} MCP install failed: {exc}")
+                failed = True
     if failed or (missing and (target != "all" or not configured)):
         raise typer.Exit(1)
 

{botable_dev-0.3.1 → botable_dev-0.3.2}/src/botable/errors.py

@@ -5,6 +5,11 @@ Provides clean error hierarchy for consistent handling across commands.
 """
 from __future__ import annotations
 
+CLOSED_BETA_DEPLOY_MESSAGE = (
+    "Cloud deployment is in closed beta and requires an invitation. "
+    "This account has not been invited. Contact the Botable team to request an invitation."
+)
+
 
 class BotableError(Exception):
     """Base exception for all Botable CLI errors."""
@@ -43,6 +48,8 @@ class APIError(BotableError):
                 detail = body.get("detail", body.get("message", detail))
             except Exception:
                 pass
+        if status == 403 and detail == "CLI deploy is not enabled for this account":
+            detail = CLOSED_BETA_DEPLOY_MESSAGE
         return cls(status, detail)
 
 

botable_dev-0.3.2/src/botable/mcp_install.py

@@ -0,0 +1,158 @@
+"""Register the installed botable-mcp console script with coding agents."""
+
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import sysconfig
+import tempfile
+from datetime import datetime, timezone
+from pathlib import Path
+
+from botable.config import tomllib
+
+
+class CursorConfigError(ValueError):
+    """Cursor config cannot be parsed safely; leave it for manual repair."""
+
+
+def _mcp_command() -> str:
+    found = shutil.which("botable-mcp")
+    if found:
+        return str(Path(found).resolve())
+    # CLI run from a venv that is not on PATH (.venv/bin/botable): the script sits next to this Python.
+    names = ("botable-mcp.exe", "botable-mcp") if os.name == "nt" else ("botable-mcp",)
+    candidates = [Path(sys.executable).with_name(name) for name in names]
+    for scheme in (None, sysconfig.get_preferred_scheme("user")):
+        scripts = sysconfig.get_path("scripts", **({"scheme": scheme} if scheme else {}))
+        if scripts:
+            candidates.extend(Path(scripts) / name for name in names)
+    for candidate in candidates:
+        if candidate.is_file() and os.access(candidate, os.X_OK):
+            return str(candidate.resolve())
+    return "botable-mcp"
+
+
+def _config_target(path: Path) -> Path:
+    if path.is_symlink() and not path.exists():
+        raise OSError(f"Cannot update {path}: dangling symlink; restore its target or remove the link first.")
+    return path.resolve()
+
+
+def _write_config(path: Path, contents: bytes, *, backup_dir: Path | None = None) -> Path | None:
+    """Finish the new file before backing up and replacing the target, keeping symlinks."""
+    target = _config_target(path)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    backup = None
+    mode = target.stat().st_mode & 0o7777 if target.exists() else 0o600
+    fd, name = tempfile.mkstemp(prefix=f".{target.name}.", suffix=".tmp", dir=target.parent)
+    temporary = Path(name)
+    try:
+        with os.fdopen(fd, "wb") as stream:
+            stream.write(contents)
+            stream.flush()
+            os.fsync(stream.fileno())
+            if hasattr(os, "fchmod"):
+                os.fchmod(stream.fileno(), mode)
+        if not hasattr(os, "fchmod"):
+            os.chmod(temporary, mode)
+        if target.exists():
+            directory = backup_dir if backup_dir is not None else target.parent
+            directory.mkdir(parents=True, exist_ok=True)
+            stamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%S%fZ")
+            fd, name = tempfile.mkstemp(prefix=f"{path.name}.{stamp}.", suffix=".bak", dir=directory)
+            os.close(fd)
+            backup = Path(name)
+            try:
+                shutil.copy2(target, backup)
+            except BaseException:
+                backup.unlink(missing_ok=True)
+                raise
+        os.replace(temporary, target)
+    finally:
+        temporary.unlink(missing_ok=True)
+    return backup
+
+
+def _read_json_config(path: Path) -> dict:
+    target = _config_target(path)
+    raw = target.read_text(encoding="utf-8-sig") if target.exists() else ""
+    data = json.loads(raw) if raw.strip() else {}
+    if not isinstance(data, dict) or not isinstance(data.get("mcpServers", {}), dict):
+        raise ValueError(f"Invalid MCP config object: {path}")
+    return data
+
+
+def install_claude(scope: str) -> str:
+    executable = _mcp_command()
+    command = ["claude", "mcp", "add", "--scope", scope, "botable", "--", executable]
+    if shutil.which("claude"):
+        subprocess.run(["claude", "mcp", "remove", "--scope", scope, "botable"], check=False)
+        print("Running: " + " ".join(command))
+        subprocess.run(command, check=True)
+        return "Registered Botable MCP with Claude Code."
+
+    if scope != "project":
+        raise FileNotFoundError("Claude CLI unavailable; use --scope project to write .mcp.json.")
+
+    path = Path.cwd() / ".mcp.json"
+    data = _read_json_config(path)
+    servers = data.setdefault("mcpServers", {})
+    if servers.get("botable") == {"command": executable}:
+        return f"Claude already configured: {path} (project scope)."
+    servers["botable"] = {"command": executable}
+    backup = _write_config(
+        path,
+        (json.dumps(data, indent=2, ensure_ascii=False) + "\n").encode("utf-8"),
+        backup_dir=Path.home() / ".config" / "botable",
+    )
+    return f"Claude CLI unavailable; merged project config {path} (project scope)." + (f" (backup: {backup})" if backup else "")
+
+
+def install_cursor() -> str:
+    executable = _mcp_command()
+    if not Path(executable).is_absolute():
+        raise FileNotFoundError('botable-mcp unavailable; install "botable-dev[mcp]" first.')
+
+    path = Path.home() / ".cursor" / "mcp.json"
+    try:
+        data = _read_json_config(path)
+    except (ValueError, UnicodeError) as exc:
+        raise CursorConfigError(f"Invalid Cursor MCP config: {path}; repair the JSON and retry.") from exc
+    servers = data.setdefault("mcpServers", {})
+    if servers.get("botable") == {"command": executable}:
+        return f"Cursor already configured: {path}"
+
+    servers["botable"] = {"command": executable}
+    backup = _write_config(path, (json.dumps(data, indent=2, ensure_ascii=False) + "\n").encode("utf-8"))
+    return f"Merged Cursor config {path}" + (f" (backup: {backup})" if backup else "")
+
+
+def install_codex() -> str:
+    executable = _mcp_command()
+    path = Path.home() / ".codex" / "config.toml"
+    target = _config_target(path)
+    raw = target.read_bytes() if target.exists() else b""
+    newline = "\r\n" if b"\r\n" in raw else "\n"
+    original = raw.decode("utf-8").replace("\r\n", "\n")
+    parsed = tomllib.loads(original) if original else {}
+    current = parsed.get("mcp_servers", {}).get("botable")
+    if isinstance(current, dict) and current.get("command") == executable and "args" not in current:
+        return f"Codex already configured: {path}"
+
+    section = re.search(r"(?m)^\[mcp_servers\.botable\][ \t]*\n", original)
+    if section:
+        next_section = re.search(r"(?m)^\[", original[section.end():])
+        end = section.end() + next_section.start() if next_section else len(original)
+        body = original[section.end():end]
+        body = re.sub(r'(?m)^(?:command|args)[ \t]*=.*\n?', '', body)
+        updated = original[:section.end()] + f"command = {json.dumps(executable)}\n" + body + original[end:]
+    elif current is not None:
+        raise ValueError("Unsupported inline Botable MCP config; edit it manually")
+    else:
+        updated = original.rstrip() + ('\n\n' if original.strip() else '') + f'[mcp_servers.botable]\ncommand = {json.dumps(executable)}\n'
+    tomllib.loads(updated)  # Refuse to write malformed TOML.
+    backup = _write_config(path, updated.replace("\n", newline).encode("utf-8"))
+    return f"Merged Codex config {path}" + (f" (backup: {backup})" if backup else "")

{botable_dev-0.3.1 → botable_dev-0.3.2}/tests/test_login_mcp_install.py

@@ -114,6 +114,7 @@ def test_device_login_opens_browser_and_ctrl_c_cancels(tmp_path, monkeypatch):
     monkeypatch.setattr(config, "GLOBAL_CONFIG_DIR", tmp_path)
     monkeypatch.setattr(config, "GLOBAL_CONFIG_FILE", tmp_path / "config.toml")
     monkeypatch.delenv("SSH_CONNECTION", raising=False)
+    monkeypatch.delenv("CI", raising=False)  # GitHub Actions sets CI=true, which suppresses the browser on macOS
     monkeypatch.setattr(cli.platform, "system", lambda: "Darwin")
     opened = []
     monkeypatch.setattr(cli.webbrowser, "open", opened.append)
@@ -139,6 +140,7 @@ def test_device_login_opens_browser_and_ctrl_c_cancels(tmp_path, monkeypatch):
 def test_mcp_install_fallback_and_codex_idempotency(tmp_path, monkeypatch):
     monkeypatch.setattr(mcp_install.Path, "home", lambda: tmp_path)
     monkeypatch.setattr(mcp_install.shutil, "which", lambda name: None)
+    monkeypatch.setattr(mcp_install, "_mcp_command", lambda: "botable-mcp")
     monkeypatch.chdir(tmp_path)
     (tmp_path / ".mcp.json").write_text('{"mcpServers":{"other":{"command":"other"}}}\n')
     codex = tmp_path / ".codex" / "config.toml"
@@ -153,7 +155,7 @@ def test_mcp_install_fallback_and_codex_idempotency(tmp_path, monkeypatch):
     assert claude["mcpServers"] == {"other": {"command": "other"}, "botable": {"command": "botable-mcp"}}
     assert codex.read_text().startswith('# keep comment\nmodel = "example"')
     assert '[mcp_servers.botable]\ncommand = "botable-mcp"' in codex.read_text()
-    assert codex.with_suffix(".toml.bak").read_text() == '# keep comment\nmodel = "example"\n'
+    assert next(codex.parent.glob("config.toml.*.bak")).read_text() == '# keep comment\nmodel = "example"\n'
 
     before = ((tmp_path / ".mcp.json").read_bytes(), codex.read_bytes())
     second = runner.invoke(cli.app, ["mcp", "install", "--scope", "project"])
@@ -161,6 +163,46 @@ def test_mcp_install_fallback_and_codex_idempotency(tmp_path, monkeypatch):
     assert before == ((tmp_path / ".mcp.json").read_bytes(), codex.read_bytes())
 
 
+@pytest.mark.parametrize("existing", [False, True])
+def test_claude_project_fallback_keeps_backups_outside_project(tmp_path, monkeypatch, existing):
+    home = tmp_path / "home"
+    project = tmp_path / "project"
+    home.mkdir()
+    project.mkdir()
+    monkeypatch.setattr(mcp_install.Path, "home", lambda: home)
+    monkeypatch.chdir(project)
+    monkeypatch.setattr(mcp_install.shutil, "which", lambda name: None)
+    monkeypatch.setattr(mcp_install, "_mcp_command", lambda: "/opt/botable/bin/botable-mcp")
+    path = project / ".mcp.json"
+    original = b'{"mcpServers":{"other":{"command":"other"}}}\n'
+    if existing:
+        path.write_bytes(original)
+        path.chmod(0o640)
+
+    result = runner.invoke(cli.app, ["mcp", "install", "--target", "claude", "--scope", "project"])
+
+    assert result.exit_code == 0, result.output
+    assert json.loads(path.read_text())["mcpServers"]["botable"] == {
+        "command": "/opt/botable/bin/botable-mcp"
+    }
+    assert list(project.iterdir()) == [path]
+    backup_dir = home / ".config" / "botable"
+    backups = list(backup_dir.glob(".mcp.json.*.bak"))
+    if existing:
+        assert len(backups) == 1
+        assert backups[0].read_bytes() == original
+        assert backups[0].stat().st_mode & 0o777 == 0o640
+        assert str(backups[0]) in " ".join(result.output.split())
+    else:
+        assert not backups
+        assert not backup_dir.exists()
+    before = path.read_bytes()
+    repeat = runner.invoke(cli.app, ["mcp", "install", "--target", "claude", "--scope", "project"])
+    assert repeat.exit_code == 0, repeat.output
+    assert path.read_bytes() == before
+    assert list(backup_dir.glob(".mcp.json.*.bak")) == backups
+
+
 def test_claude_command_uses_argv(monkeypatch):
     monkeypatch.setattr(mcp_install.shutil, "which", lambda name: "/usr/bin/claude" if name == "claude" else "/usr/bin/botable-mcp")
     commands = []
@@ -178,6 +220,7 @@ def test_claude_command_uses_argv(monkeypatch):
 def test_codex_replaces_old_command_without_touching_other_sections(tmp_path, monkeypatch):
     monkeypatch.setattr(mcp_install.Path, "home", lambda: tmp_path)
     monkeypatch.setattr(mcp_install.shutil, "which", lambda name: None)
+    monkeypatch.setattr(mcp_install, "_mcp_command", lambda: "botable-mcp")
     codex = tmp_path / ".codex" / "config.toml"
     codex.parent.mkdir()
     codex.write_text('[mcp_servers.botable]\n# botable note\ncommand = "old"\nargs = ["server.py"]\n\n[history]\npersistence = "save-all"\n')
@@ -262,6 +305,102 @@ def test_mcp_all_skips_missing_claude_user_scope(tmp_path, monkeypatch):
     assert result.exit_code == 0, result.output
     assert "Claude CLI unavailable" in result.output
     assert 'command = "/usr/bin/botable-mcp"' in (tmp_path / ".codex" / "config.toml").read_text()
+    assert not (tmp_path / ".cursor").exists()
+    assert "Skipping Cursor" in result.output
+
+
+def test_cursor_first_install_uses_absolute_executable_and_preserves_config(tmp_path, monkeypatch):
+    monkeypatch.setattr(mcp_install.Path, "home", lambda: tmp_path)
+    monkeypatch.setattr(mcp_install, "_mcp_command", lambda: "/opt/botable/bin/botable-mcp")
+    path = tmp_path / ".cursor" / "mcp.json"
+    path.parent.mkdir()
+    original = '{\n  "settings": {"theme": "dark"},\n  "mcpServers": {"other": {"command": "other-mcp"}, "botable": {"command": "old-mcp", "args": ["server.py"]}}\n}\n'
+    path.write_text(original)
+
+    result = runner.invoke(cli.app, ["mcp", "install", "--target", "cursor"])
+
+    assert result.exit_code == 0, result.output
+    assert "Cursor Settings > Tools & MCP" in result.output
+    assert json.loads(path.read_text()) == {
+        "settings": {"theme": "dark"},
+        "mcpServers": {
+            "other": {"command": "other-mcp"},
+            "botable": {"command": "/opt/botable/bin/botable-mcp"},
+        },
+    }
+    assert next(path.parent.glob("mcp.json.*.bak")).read_text() == original
+
+
+def test_cursor_first_install_creates_missing_directory(tmp_path, monkeypatch):
+    monkeypatch.setattr(mcp_install.Path, "home", lambda: tmp_path)
+    monkeypatch.setattr(mcp_install, "_mcp_command", lambda: "/opt/botable/bin/botable-mcp")
+
+    assert "Merged Cursor config" in mcp_install.install_cursor()
+    assert json.loads((tmp_path / ".cursor" / "mcp.json").read_text()) == {
+        "mcpServers": {"botable": {"command": "/opt/botable/bin/botable-mcp"}}
+    }
+    assert not (tmp_path / ".cursor" / "mcp.json.bak").exists()
+
+
+def test_cursor_idempotency_does_not_rewrite_or_replace_backup(tmp_path, monkeypatch):
+    monkeypatch.setattr(mcp_install.Path, "home", lambda: tmp_path)
+    monkeypatch.setattr(mcp_install, "_mcp_command", lambda: "/opt/botable/bin/botable-mcp")
+    path = tmp_path / ".cursor" / "mcp.json"
+    path.parent.mkdir()
+    path.write_text(json.dumps({"mcpServers": {"botable": {"command": "/opt/botable/bin/botable-mcp"}}}) + "\n")
+    backup = path.with_suffix(".json.bak")
+    backup.write_text("original backup\n")
+    before = (path.read_bytes(), backup.read_bytes())
+    writes = []
+    monkeypatch.setattr(mcp_install.Path, "write_text", lambda self, *args, **kwargs: writes.append(self))
+
+    result = runner.invoke(cli.app, ["mcp", "install", "--target", "cursor"])
+
+    assert result.exit_code == 0, result.output
+    assert "already configured" in result.output
+    assert writes == []
+    assert (path.read_bytes(), backup.read_bytes()) == before
+
+
+@pytest.mark.parametrize("contents", ['not json', '[]', '{"mcpServers": []}'])
+def test_cursor_invalid_config_is_left_unchanged(tmp_path, monkeypatch, contents):
+    monkeypatch.setattr(mcp_install.Path, "home", lambda: tmp_path)
+    monkeypatch.setattr(mcp_install, "_mcp_command", lambda: "/opt/botable/bin/botable-mcp")
+    path = tmp_path / ".cursor" / "mcp.json"
+    path.parent.mkdir()
+    path.write_text(contents)
+
+    result = runner.invoke(cli.app, ["mcp", "install", "--target", "cursor"])
+
+    assert result.exit_code == 1
+    assert path.read_text() == contents
+    assert not path.with_suffix(".json.bak").exists()
+
+
+def test_cursor_requires_an_absolute_mcp_executable(tmp_path, monkeypatch):
+    monkeypatch.setattr(mcp_install.Path, "home", lambda: tmp_path)
+    monkeypatch.setattr(mcp_install, "_mcp_command", lambda: "botable-mcp")
+
+    result = runner.invoke(cli.app, ["mcp", "install", "--target", "cursor"])
+
+    assert result.exit_code == 1
+    assert "cursor MCP unavailable" in result.output
+    assert not (tmp_path / ".cursor" / "mcp.json").exists()
+
+
+def test_mcp_all_includes_cursor_when_present(tmp_path, monkeypatch):
+    calls = []
+    monkeypatch.setattr(mcp_install.Path, "home", lambda: tmp_path)
+    (tmp_path / ".cursor").mkdir()
+    monkeypatch.setattr(mcp_install, "_mcp_command", lambda: "/opt/botable/bin/botable-mcp")
+    monkeypatch.setattr(mcp_install, "install_claude", lambda scope: calls.append(("claude", scope)) or "claude")
+    monkeypatch.setattr(mcp_install, "install_codex", lambda: calls.append(("codex", None)) or "codex")
+    monkeypatch.setattr(mcp_install, "install_cursor", lambda: calls.append(("cursor", None)) or "cursor")
+
+    result = runner.invoke(cli.app, ["mcp", "install", "--target", "all", "--scope", "project"])
+
+    assert result.exit_code == 0, result.output
+    assert calls == [("claude", "project"), ("codex", None), ("cursor", None)]
 
 
 def test_windows_config_mode_fallback(tmp_path, monkeypatch):

{botable_dev-0.3.1 → botable_dev-0.3.2}/tests/test_mcp_and_config.py

@@ -4,6 +4,8 @@ import asyncio
 import json
 import subprocess
 
+import httpx
+import pytest
 from typer.testing import CliRunner
 
 from botable import config
@@ -100,3 +102,50 @@ def test_cli_json_agent_outputs(tmp_path, monkeypatch):
     assert json.loads(deployed.output) == {"project_id": "p1", "state": "queued", "message": "queued"}
     assert json.loads(listed.output) == [{"id": "p1"}]
     assert json.loads(status.output)["current_state"] == "running"
+
+
+@pytest.mark.parametrize("json_output", [False, True])
+def test_deploy_allowlist_refusal_explains_closed_beta_and_mcp_preserves_error(tmp_path, monkeypatch, json_output):
+    from botable import cli
+    from botable.errors import CLOSED_BETA_DEPLOY_MESSAGE
+
+    (tmp_path / "botable.toml").write_text('[project]\nname = "demo"\nid = "p1"\n')
+    (tmp_path / "main.py").write_text("pass\n")
+    (tmp_path / ".env").write_text("BOT_TOKEN=private-test-token\n")
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setattr(cli, "_require_auth", lambda: "private-test-key")
+    def handle(request):
+        assert request.url.path == "/api/v1/cli/deploy"
+        return httpx.Response(403, json={"detail": "CLI deploy is not enabled for this account"})
+    real_client = httpx.AsyncClient
+    monkeypatch.setattr(httpx, "AsyncClient", lambda **kwargs: real_client(transport=httpx.MockTransport(handle), **kwargs))
+    result = runner.invoke(app, ["deploy"] + (["--json"] if json_output else []))
+    assert result.exit_code == 1, result.output
+    assert CLOSED_BETA_DEPLOY_MESSAGE in " ".join(result.output.split())
+    assert "private-test-token" not in result.output and "private-test-key" not in result.output
+
+    monkeypatch.setenv("BOTABLE_CMD", "/test/bin/botable")
+    monkeypatch.setattr(server.subprocess, "run", lambda argv, **kwargs: subprocess.CompletedProcess(argv, 1, result.output, ""))
+    output = asyncio.run(server.botable_deploy(str(tmp_path)))
+    assert output.startswith("Error (exit 1):")
+    assert CLOSED_BETA_DEPLOY_MESSAGE in " ".join(output.split())
+
+
+def test_other_deploy_403_keeps_its_actual_error():
+    from botable.errors import APIError
+    request = httpx.Request("POST", "https://example.test/api/v1/cli/deploy")
+    response = httpx.Response(403, json={"detail": "Project access denied"}, request=request)
+    with pytest.raises(httpx.HTTPStatusError) as caught:
+        response.raise_for_status()
+    assert APIError.from_httpx(caught.value).detail == "Project access denied"
+
+
+def test_deploy_consent_is_exposed_after_mcp_restart():
+    required = ["botable.toml", "name", "id", "main.py", "requirements.txt", ".env",
+                "botable bots list", "case-insensitive", "overwritten", "new bot", "explicit yes", "Never print secrets"]
+    for text in (server.DEPLOY_CONSENT_INSTRUCTIONS, server.botable_deploy.__doc__):
+        normalized = " ".join(text.split())
+        for wording in required:
+            assert wording in normalized
+    if server.mcp:
+        assert server.DEPLOY_CONSENT_INSTRUCTIONS in server.mcp.instructions

botable_dev-0.3.2/tests/test_mcp_install_safety.py

@@ -0,0 +1,304 @@
+"""Offline regression coverage for client discovery and safe config updates."""
+
+import json
+import os
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+from typer.testing import CliRunner
+
+from botable import cli, mcp_install
+
+
+runner = CliRunner()
+
+
+@pytest.fixture
+def cursor_config(tmp_path, monkeypatch):
+    monkeypatch.setattr(mcp_install.Path, "home", lambda: tmp_path)
+    monkeypatch.setattr(mcp_install, "_mcp_command", lambda: "/opt/botable/bin/botable-mcp")
+    path = tmp_path / ".cursor" / "mcp.json"
+    path.parent.mkdir()
+    return path
+
+
+@pytest.mark.parametrize("contents", ["", " \t\r\n", "\ufeff", '\ufeff{"mcpServers": {}}'])
+def test_cursor_accepts_empty_and_bom_config(cursor_config, contents):
+    cursor_config.write_text(contents, encoding="utf-8")
+    assert "Merged Cursor config" in mcp_install.install_cursor()
+    assert json.loads(cursor_config.read_text())["mcpServers"]["botable"] == {
+        "command": "/opt/botable/bin/botable-mcp"
+    }
+    assert next(cursor_config.parent.glob("mcp.json.*.bak")).read_bytes() == contents.encode("utf-8")
+
+
+@pytest.mark.parametrize("contents", ['// comment\n{}', '{"mcpServers": null}', '[]', '\ufeffnot json'])
+def test_all_warns_and_continues_for_invalid_cursor_json(cursor_config, monkeypatch, contents):
+    cursor_config.write_text(contents)
+    calls = []
+    monkeypatch.setattr(mcp_install, "install_claude", lambda scope: calls.append("claude") or "Claude configured")
+    monkeypatch.setattr(mcp_install, "install_codex", lambda: calls.append("codex") or "Codex configured")
+    result = runner.invoke(cli.app, ["mcp", "install"])
+    assert result.exit_code == 0, result.output
+    assert calls == ["claude", "codex"]
+    assert "Warning: cursor MCP skipped" in result.output
+    assert cursor_config.read_text() == contents
+    assert not list(cursor_config.parent.glob("*.bak"))
+
+
+def test_invalid_cursor_does_not_count_as_configured(cursor_config, monkeypatch):
+    cursor_config.write_text("not json")
+    def unavailable(*args):
+        raise FileNotFoundError("client unavailable")
+    monkeypatch.setattr(mcp_install, "install_claude", unavailable)
+    monkeypatch.setattr(mcp_install, "install_codex", unavailable)
+    assert runner.invoke(cli.app, ["mcp", "install"]).exit_code == 1
+
+
+@pytest.mark.parametrize("target,exit_code", [("cursor", 1), ("all", 0)])
+def test_cursor_dangling_config_symlink_is_reported(cursor_config, monkeypatch, target, exit_code):
+    cursor_config.symlink_to(cursor_config.parent / "missing.json")
+    monkeypatch.setattr(mcp_install, "install_claude", lambda scope: "Claude configured")
+    monkeypatch.setattr(mcp_install, "install_codex", lambda: "Codex configured")
+    result = runner.invoke(cli.app, ["mcp", "install", "--target", target])
+    assert result.exit_code == exit_code, result.output
+    if target == "all":
+        assert "Warning: cursor MCP skipped" in result.output
+    assert "dangling symlink" in result.output
+    assert "restore its target or remove the link" in " ".join(result.output.split())
+    assert cursor_config.is_symlink()
+    assert not list(cursor_config.parent.glob("*.bak"))
+
+
+def test_all_skips_dangling_cursor_directory_without_creating_target(tmp_path, monkeypatch):
+    monkeypatch.setattr(mcp_install.Path, "home", lambda: tmp_path)
+    monkeypatch.setattr(mcp_install, "_mcp_command", lambda: "/opt/bin/botable-mcp")
+    monkeypatch.setattr(mcp_install, "install_claude", lambda scope: "Claude configured")
+    monkeypatch.setattr(mcp_install, "install_codex", lambda: "Codex configured")
+    target = tmp_path / "missing-cursor"
+    cursor_dir = tmp_path / ".cursor"
+    cursor_dir.symlink_to(target, target_is_directory=True)
+
+    result = runner.invoke(cli.app, ["mcp", "install", "--target", "all"])
+
+    assert result.exit_code == 0, result.output
+    assert "Cursor" in result.output or "cursor" in result.output
+    assert cursor_dir.is_symlink()
+    assert not target.exists()
+
+
+@pytest.mark.parametrize("operation", ["read", "mkdir", "write", "executable"])
+@pytest.mark.parametrize("target,exit_code", [("cursor", 1), ("all", 0)])
+def test_cursor_os_errors_warn_only_for_all(cursor_config, monkeypatch, operation, target, exit_code):
+    original = b'{"mcpServers": {}}\n'
+    cursor_config.write_bytes(original)
+    monkeypatch.setattr(mcp_install, "install_claude", lambda scope: "Claude configured")
+    monkeypatch.setattr(mcp_install, "install_codex", lambda: "Codex configured")
+
+    def fail(*args, **kwargs):
+        raise PermissionError("simulated Cursor permission error")
+
+    if operation == "read":
+        read_text = Path.read_text
+        monkeypatch.setattr(Path, "read_text", lambda path, *args, **kwargs:
+                            fail() if path == cursor_config else read_text(path, *args, **kwargs))
+    elif operation == "mkdir":
+        mkdir = Path.mkdir
+        monkeypatch.setattr(Path, "mkdir", lambda path, *args, **kwargs:
+                            fail() if path == cursor_config.parent else mkdir(path, *args, **kwargs))
+    elif operation == "write":
+        monkeypatch.setattr(mcp_install.os, "fsync", fail)
+    else:
+        monkeypatch.setattr(mcp_install, "_mcp_command", lambda: "botable-mcp")
+        monkeypatch.setattr(mcp_install.shutil, "which", lambda name: None)
+
+    result = runner.invoke(cli.app, ["mcp", "install", "--target", target])
+
+    assert result.exit_code == exit_code, result.output
+    if target == "all":
+        assert "Warning: cursor MCP skipped" in result.output
+    else:
+        assert "cursor MCP" in result.output
+    assert cursor_config.read_bytes() == original
+    assert not list(cursor_config.parent.glob("*.bak"))
+    assert not list(cursor_config.parent.glob(".*.tmp"))
+
+
+def test_cursor_os_error_does_not_count_as_configured(cursor_config, monkeypatch):
+    def unavailable(*args):
+        raise FileNotFoundError("client unavailable")
+
+    monkeypatch.setattr(mcp_install, "install_claude", unavailable)
+    monkeypatch.setattr(mcp_install, "install_codex", unavailable)
+    monkeypatch.setattr(mcp_install, "install_cursor", unavailable)
+    result = runner.invoke(cli.app, ["mcp", "install", "--target", "all"])
+    assert result.exit_code == 1, result.output
+    assert "Warning: cursor MCP skipped" in result.output
+
+
+def test_cursor_keeps_unicode(cursor_config):
+    cursor_config.write_text('{"mcpServers":{"other":{"name":"Иван", "command":"日本語"}}}')
+    mcp_install.install_cursor()
+    assert "Иван" in cursor_config.read_text() and "日本語" in cursor_config.read_text()
+
+
+def test_mcp_discovery_uses_python_and_user_scripts(tmp_path, monkeypatch):
+    monkeypatch.setattr(mcp_install.shutil, "which", lambda name: None)
+    monkeypatch.setattr(mcp_install.sys, "executable", str(tmp_path / "python"))
+    regular = tmp_path / "scripts"
+    user = tmp_path / "user-scripts"
+    regular.mkdir()
+    user.mkdir()
+    monkeypatch.setattr(mcp_install.sysconfig, "get_preferred_scheme", lambda key: "user-test")
+    calls = []
+    def get_path(name, scheme=None):
+        calls.append((name, scheme))
+        return str(user if scheme == "user-test" else regular)
+    monkeypatch.setattr(mcp_install.sysconfig, "get_path", get_path)
+    user_script = user / "botable-mcp"
+    user_script.write_text("#!/bin/sh\n")
+    user_script.chmod(0o755)
+    assert mcp_install._mcp_command() == str(user_script)
+    regular_script = regular / "botable-mcp"
+    regular_script.write_text("#!/bin/sh\n")
+    regular_script.chmod(0o755)
+    assert mcp_install._mcp_command() == str(regular_script)
+    regular_script.chmod(0o644)
+    assert mcp_install._mcp_command() == str(user_script)
+    assert ("scripts", None) in calls and ("scripts", "user-test") in calls
+
+
+@pytest.mark.parametrize("location", ["python", "scripts", "user-scripts"])
+def test_windows_mcp_discovery_finds_exe_in_each_script_location(tmp_path, monkeypatch, location):
+    monkeypatch.setattr(mcp_install.shutil, "which", lambda name: None)
+    monkeypatch.setattr(mcp_install.sys, "executable", str(tmp_path / "python" / "python.exe"))
+    monkeypatch.setattr(mcp_install.sysconfig, "get_preferred_scheme", lambda key: "user-test")
+    monkeypatch.setattr(mcp_install.sysconfig, "get_path", lambda name, scheme=None:
+                        str(tmp_path / ("user-scripts" if scheme else "scripts")))
+    # Replacing only this module's os avoids making pathlib select WindowsPath on POSIX.
+    monkeypatch.setattr(mcp_install, "os", SimpleNamespace(name="nt", access=os.access, X_OK=os.X_OK))
+    script = tmp_path / location / "botable-mcp.exe"
+    script.parent.mkdir()
+    script.write_bytes(b"test executable")
+    script.chmod(0o755)
+    assert mcp_install._mcp_command() == str(script)
+
+
+@pytest.mark.parametrize("client", ["cursor", "codex", "claude"])
+def test_config_writes_preserve_symlink_mode_and_each_backup(tmp_path, monkeypatch, client):
+    monkeypatch.setattr(mcp_install.Path, "home", lambda: tmp_path)
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setattr(mcp_install.shutil, "which", lambda name: None)
+    command = ["/opt/first/bin/botable-mcp"]
+    monkeypatch.setattr(mcp_install, "_mcp_command", lambda: command[0])
+    path = {"cursor": tmp_path / ".cursor" / "mcp.json",
+            "codex": tmp_path / ".codex" / "config.toml",
+            "claude": tmp_path / ".mcp.json"}[client]
+    path.parent.mkdir(exist_ok=True)
+    target = tmp_path / "actual-config"
+    original = '# keep comment\nmodel = "example"\n' if client == "codex" else '{"mcpServers":{"other":{"command":"other"}}}\n'
+    target.write_text(original)
+    target.chmod(0o640)
+    path.symlink_to(target)
+    legacy_backup = target.parent / (path.name + ".bak")
+    legacy_backup.write_text("old backup")
+    install = {"cursor": mcp_install.install_cursor, "codex": mcp_install.install_codex,
+               "claude": lambda: mcp_install.install_claude("project")}[client]
+    install()
+    first = target.read_bytes()
+    backup_dir = tmp_path / ".config" / "botable" if client == "claude" else target.parent
+    first_backup = next(backup_dir.glob(path.name + ".*.bak"))
+    assert first_backup.read_text() == original
+    assert first_backup.stat().st_mode & 0o777 == 0o640
+    command[0] = "/opt/second/bin/botable-mcp"
+    install()
+    backups = list(backup_dir.glob(path.name + ".*.bak"))
+    assert len(backups) == 2
+    assert next(p for p in backups if p != first_backup).read_bytes() == first
+    assert first_backup.read_text() == original
+    assert legacy_backup.read_text() == "old backup"
+    assert path.is_symlink() and path.resolve() == target
+    assert target.stat().st_mode & 0o777 == 0o640
+    assert not list(target.parent.glob(".*.tmp"))
+    before = target.read_bytes()
+    install()
+    assert target.read_bytes() == before
+    assert len(list(backup_dir.glob(path.name + ".*.bak"))) == 2
+    if client == "claude":
+        assert not list(target.parent.glob(path.name + ".*.bak"))
+
+
+@pytest.mark.parametrize("operation", ["write", "flush", "fsync", "fchmod", "replace"])
+def test_failed_atomic_write_keeps_original_and_cleans_temp(cursor_config, monkeypatch, operation):
+    original = b'{"mcpServers": {}}\n'
+    cursor_config.write_bytes(original)
+    cursor_config.chmod(0o600)
+    def fail(*args, **kwargs):
+        raise OSError("simulated disk error")
+    if operation in {"write", "flush"}:
+        fdopen = mcp_install.os.fdopen
+
+        class FailingStream:
+            def __init__(self, stream):
+                self.stream = stream
+
+            def __enter__(self):
+                self.stream.__enter__()
+                return self
+
+            def __exit__(self, *args):
+                return self.stream.__exit__(*args)
+
+            def __getattr__(self, name):
+                return fail if name == operation else getattr(self.stream, name)
+
+        monkeypatch.setattr(mcp_install.os, "fdopen", lambda *args, **kwargs: FailingStream(fdopen(*args, **kwargs)))
+    else:
+        monkeypatch.setattr(mcp_install.os, operation, fail, raising=False)
+    result = runner.invoke(cli.app, ["mcp", "install", "--target", "cursor"])
+    assert result.exit_code == 1
+    assert "simulated disk error" in result.output
+    assert cursor_config.read_bytes() == original
+    backups = list(cursor_config.parent.glob("*.bak"))
+    if operation == "replace":
+        assert len(backups) == 1
+        assert backups[0].read_bytes() == original
+    else:
+        assert not backups
+    assert not list(cursor_config.parent.glob(".*.tmp"))
+
+
+@pytest.mark.parametrize("existing", [False, True])
+def test_mcp_config_mode_fallback_without_fchmod(cursor_config, monkeypatch, existing):
+    if existing:
+        cursor_config.write_text('{"mcpServers": {}}\n')
+        cursor_config.chmod(0o640)
+    monkeypatch.delattr(mcp_install.os, "fchmod", raising=False)
+    assert "Merged Cursor config" in mcp_install.install_cursor()
+    assert cursor_config.stat().st_mode & 0o777 == (0o640 if existing else 0o600)
+    assert json.loads(cursor_config.read_text())["mcpServers"]["botable"]["command"].startswith("/")
+
+
+def test_failed_fallback_chmod_keeps_original_without_backup(cursor_config, monkeypatch):
+    original = b'{"mcpServers": {}}\n'
+    cursor_config.write_bytes(original)
+    monkeypatch.delattr(mcp_install.os, "fchmod", raising=False)
+
+    def fail(*args):
+        raise OSError("simulated chmod error")
+
+    monkeypatch.setattr(mcp_install.os, "chmod", fail)
+    with pytest.raises(OSError, match="simulated chmod error"):
+        mcp_install.install_cursor()
+    assert cursor_config.read_bytes() == original
+    assert not list(cursor_config.parent.glob("*.bak"))
+    assert not list(cursor_config.parent.glob(".*.tmp"))
+
+
+def test_version_declarations_match_release():
+    import botable
+    import botable_mcp
+    from botable.config import tomllib
+    metadata = tomllib.loads((Path(__file__).parents[1] / "pyproject.toml").read_text())
+    assert metadata["project"]["version"] == botable.__version__ == botable_mcp.__version__ == "0.3.2"

botable_dev-0.3.1/src/botable/mcp_install.py

@@ -1,72 +0,0 @@
-"""Register the installed botable-mcp console script with coding agents."""
-
-import json
-import os
-import re
-import shutil
-import subprocess
-import sys
-from pathlib import Path
-
-from botable.config import tomllib
-
-
-def _mcp_command() -> str:
-    found = shutil.which("botable-mcp")
-    if found:
-        return str(Path(found).resolve())
-    # CLI run from a venv that is not on PATH (.venv/bin/botable): the script sits next to this Python.
-    sibling = Path(sys.executable).with_name("botable-mcp")
-    if sibling.is_file() and os.access(sibling, os.X_OK):
-        return str(sibling)
-    return "botable-mcp"
-
-
-def install_claude(scope: str) -> str:
-    executable = _mcp_command()
-    command = ["claude", "mcp", "add", "--scope", scope, "botable", "--", executable]
-    if shutil.which("claude"):
-        subprocess.run(["claude", "mcp", "remove", "--scope", scope, "botable"], check=False)
-        print("Running: " + " ".join(command))
-        subprocess.run(command, check=True)
-        return "Registered Botable MCP with Claude Code."
-
-    if scope != "project":
-        raise FileNotFoundError("Claude CLI unavailable; use --scope project to write .mcp.json.")
-
-    path = Path.cwd() / ".mcp.json"
-    data = json.loads(path.read_text(encoding="utf-8")) if path.exists() else {}
-    data.setdefault("mcpServers", {})["botable"] = {"command": executable}
-    path.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
-    return f"Claude CLI unavailable; merged project config {path} (project scope)."
-
-
-def install_codex() -> str:
-    executable = _mcp_command()
-    path = Path.home() / ".codex" / "config.toml"
-    raw = path.read_bytes() if path.exists() else b""
-    newline = "\r\n" if b"\r\n" in raw else "\n"
-    original = raw.decode("utf-8").replace("\r\n", "\n")
-    parsed = tomllib.loads(original) if original else {}
-    current = parsed.get("mcp_servers", {}).get("botable")
-    if isinstance(current, dict) and current.get("command") == executable and "args" not in current:
-        return f"Codex already configured: {path}"
-
-    section = re.search(r"(?m)^\[mcp_servers\.botable\][ \t]*\n", original)
-    if section:
-        next_section = re.search(r"(?m)^\[", original[section.end():])
-        end = section.end() + next_section.start() if next_section else len(original)
-        body = original[section.end():end]
-        body = re.sub(r'(?m)^(?:command|args)[ \t]*=.*\n?', '', body)
-        updated = original[:section.end()] + f"command = {json.dumps(executable)}\n" + body + original[end:]
-    elif current is not None:
-        raise ValueError("Unsupported inline Botable MCP config; edit it manually")
-    else:
-        updated = original.rstrip() + ('\n\n' if original.strip() else '') + f'[mcp_servers.botable]\ncommand = {json.dumps(executable)}\n'
-    tomllib.loads(updated)  # Refuse to write malformed TOML.
-    path.parent.mkdir(parents=True, exist_ok=True)
-    if path.exists():
-        backup = path.with_suffix(".toml.bak")
-        shutil.copy2(path, backup)
-    path.write_bytes(updated.replace("\n", newline).encode("utf-8"))
-    return f"Merged Codex config {path}" + (f" (backup: {backup})" if original else "")