Is Nauro MCP server safe?

proc = subprocess.run(
            ["git", "rev-parse", "--show-toplevel"],
            cwd=repo_root,
            capture_output=True,
            text=True,
            check=False,
        )

proc = subprocess.run(
            [nauro_cmd, "serve", "--stdio"],
            input="",
            timeout=timeout,
            capture_output=True,
            text=True,
            check=False,
        )

proc = subprocess.run(
            [cmd, *args],
            timeout=timeout,
            capture_output=True,
            check=False,
        )

return subprocess.run(
            ["git", *args],
            cwd=cwd,
            capture_output=True,
            text=True,
            check=False,
        )

completed = subprocess.run(
            ["git", "rev-parse", "HEAD"],
            cwd=str(cwd),
            capture_output=True,
            text=True,
            check=False,
            timeout=_GIT_TIMEOUT_SECONDS,
        )

result = subprocess.run(
            _worker_command(),
            input=request.model_dump_json(),
            encoding="utf-8",
            capture_output=True,
            timeout=timeout,
            check=False,
            creationfl …

return resources.files(__package__).joinpath(f"{name}.md").read_text(encoding="utf-8")

text = path.read_text(encoding="utf-8")

config_raw = config_path.read_bytes()

or config_path.read_bytes() != config_raw

data = json.loads(state_file.read_text())

return path.read_text(encoding="utf-8", errors="replace")

if not target.is_file() or target.read_text(encoding="utf-8") != expected:

prior_config = config_path.read_bytes() if config_path.exists() else None

or (config_path.read_bytes() if config_path.exists() else None) != prior_config

current = target.read_text(encoding="utf-8")

current = target.read_text(encoding="utf-8")

raw = json.loads(settings_path.read_text(encoding="utf-8"))

raw = json.loads(settings_path.read_text(encoding="utf-8"))

raw = json.loads(settings_path.read_text(encoding="utf-8"))

config = json.loads(config_path.read_text(encoding="utf-8"))

original = config_path.read_bytes()

existing_text = hooks_path.read_text(encoding="utf-8")

raw = json.loads(config_path.read_text(encoding="utf-8"))

current = target.read_text(encoding="utf-8")

if target.read_text(encoding="utf-8") != bundled:

current = store.read_bytes(STATE_CURRENT_FILENAME)

result["stack_revision"] = compute_stack_revision(store.read_bytes(STACK_MD))

content = _strip_bom(claude_md.read_bytes().decode("utf-8", errors="surrogateescape"))

return _strip_bom(claude_md.read_text(encoding="utf-8", errors="replace"))

return gitignore_path.read_text(encoding="utf-8").splitlines()

target.write_text(render_agent("claude_code", name), encoding="utf-8")

shutil.rmtree(store_path)

atomic_write_text(out_path, html, newline="\n")

state_file.write_text(json.dumps(payload))

target.write_text(existing.rstrip() + header + stripped + "\n", encoding="utf-8")

target.write_text(header.lstrip() + stripped + "\n", encoding="utf-8")

atomic_write_text(path, json.dumps(config, indent=2) + "\n")

target.write_text(bundled, encoding="utf-8")

backup.write_text(current, encoding="utf-8")

target.write_text(bundled, encoding="utf-8")

target.write_text(bundled, encoding="utf-8")

atomic_write_text(config_path, rendered, newline="\n")

atomic_write_text(hooks_path, _format_codex_hooks(transformed.config))

atomic_write_text(hooks_path, rendered)

claude_md.write_text(remaining + "\n", encoding="utf-8")

target.write_text(bundled, encoding="utf-8")

backup.write_text(current, encoding="utf-8")

target.write_text(bundled, encoding="utf-8")

target.write_text(bundled, encoding="utf-8")

claude_md.write_text(BRIDGE_CONTENT, encoding="utf-8")

claude_md.write_bytes(remaining.encode("utf-8", errors="surrogateescape"))

atomic_write_text(gitignore_path, "\n".join(lines) + "\n")

atomic_write_text(gitignore_path, "\n".join(lines) + "\n")

atomic_write_bytes(path, data, rename=durable_rename)

atomic_write_text(cf, json.dumps(data, indent=2) + "\n", mode=0o600)

import httpx

import httpx

lambda: httpx.post(
                f"https://{domain}/oauth/token",
                json={
                    "grant_type": "authorization_code",
                    "client_id": client_id,
                    "code": auth_code, …

me_resp = httpx.get(
            f"{api_url}/me",
            headers={"Authorization": f"Bearer {access_token}"},
            timeout=10,
        )

import httpx

with httpx.Client(trust_env=False) as client:

import httpx

return httpx.Client()

import httpx

with httpx.Client(trust_env=False) as client:

import httpx

import httpx

with httpx.Client(trust_env=False) as client:

import httpx

with httpx.Client() as client:

import httpx

import httpx

return httpx.request(
            method,
            url,
            headers={
                "Authorization": f"Bearer {token}",
                "Accept": "application/json",
            },
            json=json_body,
            timeou …

import httpx

import httpx

url = httpx.URL(endpoint)

import httpx

import httpx

with httpx.Client(trust_env=False) as client:

import httpx

"grant_type": "refresh_token",

"grant_type": "authorization_code",

"grant_type": "authorization_code",

{"grant_type": "refresh_token", "refresh_token": record.refresh_token},

"grant_type": "authorization_code",

{"grant_type": "refresh_token", "refresh_token": record.refresh_token},

server = FastMCP(

mcp = FastMCP(

"""Build FastMCP @tool() decorator kwargs from the shared registry."""

@mcp.tool(**_spec_kwargs("get_context"))

@mcp.tool(**_spec_kwargs("get_raw_file"))

@mcp.tool(**_spec_kwargs("list_decisions"))

@mcp.tool(**_spec_kwargs("get_decision"))

@mcp.tool(**_spec_kwargs("diff_since_last_session"))

@mcp.tool(**_spec_kwargs("search_decisions"))

@mcp.tool(**_spec_kwargs("check_decision"))

@mcp.tool(**_spec_kwargs("propose_decision"), structured_output=False)

@mcp.tool(**_spec_kwargs("flag_question"), structured_output=False)

@mcp.tool(**_spec_kwargs("update_state"), structured_output=False)

@mcp.tool(**_spec_kwargs("update_stack"), structured_output=False)

@mcp.tool(**_spec_kwargs("share_context"), structured_output=False)

server.add_tool(

server.add_tool(