cad-mcp 0.10.0__tar.gz

cad_mcp-0.10.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Thompson Labs LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cad_mcp-0.10.0/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: cad-mcp
+Version: 0.10.0
+Summary: The stdio transport an agent app starts for text-to-cad's CAD app: MCP carried to the device's CAD server, with the standard library alone.
+Author: earthtojake
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/earthtojake/text-to-cad
+Project-URL: Repository, https://github.com/earthtojake/text-to-cad
+Project-URL: Issues, https://github.com/earthtojake/text-to-cad/issues
+Keywords: cad,mcp,agent-skills
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Multimedia :: Graphics :: 3D Modeling
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# cad-mcp
+
+The stdio transport an agent app starts for text-to-cad's CAD app (`cad-mcp`): it carries the app's MCP
+requests to the CAD server on this computer, over HTTP, and the server's answers back. The standard
+library alone, imported as `cad_mcp`.
+
+It holds no tool, view or document: the server does. What it does on its own:
+
+- **Reaches the server** the way every client does: through the server's door in its folder, which names
+  the server's HTTP endpoint and token. When none answers, it starts the current installation's server
+  (`installations/current` in the user's state folder), whatever release it is itself.
+- **Registers one first** on a computer with no installation current: the server its own environment
+  carries, else the server of its own release, installed by `uvx`.
+- **Holds the server** while the app runs, under a name its sessions are opened by, which end when the
+  app quits.
+- **Opens the person's browser** where a text-only app's `cad_show` asks, in the app's own environment,
+  never in the server's, and tells the server whether it opened.
+- **Says which app started it**, read from its parent processes, which only it can see.

cad_mcp-0.10.0/README.md

@@ -0,0 +1,18 @@
+# cad-mcp
+
+The stdio transport an agent app starts for text-to-cad's CAD app (`cad-mcp`): it carries the app's MCP
+requests to the CAD server on this computer, over HTTP, and the server's answers back. The standard
+library alone, imported as `cad_mcp`.
+
+It holds no tool, view or document: the server does. What it does on its own:
+
+- **Reaches the server** the way every client does: through the server's door in its folder, which names
+  the server's HTTP endpoint and token. When none answers, it starts the current installation's server
+  (`installations/current` in the user's state folder), whatever release it is itself.
+- **Registers one first** on a computer with no installation current: the server its own environment
+  carries, else the server of its own release, installed by `uvx`.
+- **Holds the server** while the app runs, under a name its sessions are opened by, which end when the
+  app quits.
+- **Opens the person's browser** where a text-only app's `cad_show` asks, in the app's own environment,
+  never in the server's, and tells the server whether it opened.
+- **Says which app started it**, read from its parent processes, which only it can see.

cad_mcp-0.10.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cad-mcp"
+version = "0.10.0"
+description = "The stdio transport an agent app starts for text-to-cad's CAD app: MCP carried to the device's CAD server, with the standard library alone."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.14"
+authors = [{ name = "earthtojake" }]
+keywords = ["cad", "mcp", "agent-skills"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.14",
+  "Topic :: Multimedia :: Graphics :: 3D Modeling",
+]
+# The standard library alone: an agent app installs this to start the CAD app, and the server it
+# reaches is installed on its own (the install command), or by this transport on a device with none.
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/earthtojake/text-to-cad"
+Repository = "https://github.com/earthtojake/text-to-cad"
+Issues = "https://github.com/earthtojake/text-to-cad/issues"
+
+[project.scripts]
+cad-mcp = "cad_mcp.shim:main"
+
+[tool.pyrefly]
+preset = "basic"
+project-includes = ["src"]
+search-path = ["src"]
+use-ignore-files = false
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["cad_mcp", "cad_mcp.*"]

cad_mcp-0.10.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cad_mcp-0.10.0/src/cad_mcp/__init__.py

@@ -0,0 +1,53 @@
+"""CAD beside an agent's chat: the stdio transport an agent app starts, forwarding MCP to the device's CAD
+server over HTTP (``shim``).
+
+The standard library alone. It reads where the server is the way the server's own clients do -- the
+engine folder's door, the current installation in the state folder (``engine``) -- starts the current
+installation's server when none answers, and installs one, the release it belongs to, when the device has
+none. Everything CAD is, the server is: this process carries the host's requests to it and its answers
+back, opens the person's browser where a text host's ``cad_show`` asks, and tells the server which host
+started it.
+"""
+
+from __future__ import annotations
+
+from functools import cache as _cache
+from pathlib import Path as _Path
+
+# The distribution this package ships in, whose release it is (``__version__``).
+DISTRIBUTION = "cad-mcp"
+
+__all__ = ["DISTRIBUTION", "__version__"]
+
+
+def __getattr__(name: str):
+    if name == "__version__":
+        return _version()
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+@_cache
+def _version() -> str:
+    """The version declared beside this very package: the source tree's ``pyproject.toml`` two levels up
+    (``src/cad_mcp``), else the newest ``.dist-info`` of its distribution installed beside it; ``0+unknown``
+    with neither. Never the first metadata on the import path, which can be another install's."""
+    import tomllib
+
+    package = _Path(__file__).resolve().parent
+    try:
+        with (package.parent.parent / "pyproject.toml").open("rb") as handle:
+            project = tomllib.load(handle).get("project") or {}
+        if project.get("name") == DISTRIBUTION and project.get("version"):
+            return str(project["version"])
+    except (OSError, ValueError):
+        pass
+    stem = DISTRIBUTION.replace("-", "_")
+    found = []
+    for metadata in package.parent.glob(f"{stem}-*.dist-info"):
+        try:
+            found.append((metadata.stat().st_mtime_ns, metadata.name))
+        except OSError:
+            continue
+    if found:
+        return max(found)[1][len(stem) + 1:-len(".dist-info")]
+    return "0+unknown"

cad_mcp-0.10.0/src/cad_mcp/__main__.py

@@ -0,0 +1,7 @@
+"""``python -m cad_mcp``: the stdio transport (``shim.main``)."""
+
+import sys
+
+from cad_mcp.shim import main
+
+sys.exit(main())

cad_mcp-0.10.0/src/cad_mcp/browser.py

@@ -0,0 +1,156 @@
+"""The one act of its own a text host's ``cad_show`` asks of this process: opening the person's browser.
+
+The server runs in the environment of whatever started it (another agent's shell, another ``BROWSER``, no
+display), so it never opens a browser itself: this process, which the host started in the person's own
+environment, does. It says at initialize that it opens one for its host, and whether it can
+(``transport_browser``); the server's answer then carries the page to open in its result's ``_meta``
+(``OPEN``), which this process opens and strips before the host sees the result (``deliver``), and before
+that it tells the server on its session whether the page opened (``OPENED``): the server counts a page as
+open in the person's browser only once told it opened, so after a failed open the next ``cad_show`` opens
+it again.
+
+The page's URL carries a link, a credential for a day, and a browser (or the launcher that starts it) is
+given its URL as an argument, which other local users may read in the process list. So the browser is
+given a file instead: a page of one redirect to the URL, written owner-only (0600) in the engine folder,
+which is this user's alone (``engine.folder_refusal``), and removed after ``KEEP_SECONDS``.
+"""
+from __future__ import annotations
+
+import html
+import json
+import os
+import secrets
+import sys
+import threading
+import time
+import webbrowser
+from pathlib import Path
+from typing import Any, Callable
+
+from cad_mcp import engine
+
+# A text host's cad_show result: ``{"url", "said", "failed"}``, the page this process opens, the sentence
+# of the result that says it opened, and the one it says in its place where the open fails (``{reason}``
+# the failure). Only a transport that declared ``transport_browser`` is sent it.
+OPEN = "dev.texttocad/open"
+# This process's word on that page, the notification it sends on its session once its open returned and
+# before its host has the answer: ``{"url", "opened"}``.
+OPENED = "notifications/dev.texttocad/opened"
+KEEP_SECONDS = 10.0
+PREFIX = "open-"
+
+
+class CannotOpen(Exception):
+    """No browser could be opened here, said in words (no display, no opener, a refused folder)."""
+
+
+def display_refusal(environ: Any = None) -> str | None:
+    """Why no browser can be shown to the person from this process, or None: a remote shell with no
+    forwarded display, or a POSIX desktop-less session (no X11 or Wayland display)."""
+    environ = os.environ if environ is None else environ
+    if os.name == "nt":
+        return None
+    shown = environ.get("DISPLAY") or environ.get("WAYLAND_DISPLAY")
+    if (environ.get("SSH_CONNECTION") or environ.get("SSH_TTY")) and not shown:
+        return "this is a remote session with no display to open a browser on"
+    if sys.platform != "darwin" and not shown:
+        return "there is no display to open a browser on"
+    return None
+
+
+def transport_browser() -> dict[str, Any]:
+    """What this process says of its browser at initialize: that it opens one for its host, and
+    ``refusal``, why none can be opened from its environment, or None."""
+    return {"refusal": display_refusal()}
+
+
+def redirect_page(url: str) -> bytes:
+    """A page that only navigates to ``url``, sending no referrer."""
+    return ('<!doctype html><html><head><meta charset="utf-8"><meta name="referrer" content="no-referrer">'
+            f'<meta http-equiv="refresh" content="0;url={html.escape(url, quote=True)}"><title>CAD</title></head>'
+            f'<body><script>location.replace({json.dumps(url)})</script></body></html>\n').encode("utf-8")
+
+
+def _sweep(folder: Path) -> None:
+    stale = time.time() - KEEP_SECONDS
+    for found in folder.glob(f"{PREFIX}*.html"):
+        try:
+            if found.lstat().st_mtime < stale:
+                found.unlink()
+        except OSError:
+            pass
+
+
+def _remove_later(path: Path) -> None:
+    def remove() -> None:
+        time.sleep(KEEP_SECONDS)
+        try:
+            path.unlink()
+        except OSError:
+            pass
+
+    threading.Thread(target=remove, name="cad-mcp-browser-open", daemon=True).start()
+
+
+def open_page(url: str, *, opener: Callable[[str], bool] = webbrowser.open) -> Path:
+    """Open ``url`` in the browser through an owner-only redirect file; the file's path, or ``CannotOpen``
+    when no browser can be opened here."""
+    refusal = display_refusal()
+    if refusal is not None:
+        raise CannotOpen(refusal)
+    folder = engine.engine_dir()
+    try:
+        folder.mkdir(parents=True, exist_ok=True, mode=0o700)
+    except OSError as error:
+        raise CannotOpen(f"the engine's folder {folder} cannot be made: {error.strerror or error}") from error
+    refusal = engine.folder_refusal(folder)
+    if refusal is not None:
+        raise CannotOpen(refusal)
+    _sweep(folder)
+    path = folder / f"{PREFIX}{secrets.token_hex(8)}.html"
+    descriptor = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, "O_NOFOLLOW", 0), 0o600)
+    with os.fdopen(descriptor, "wb") as handle:
+        handle.write(redirect_page(url))
+    try:
+        opened = opener(path.as_uri())
+    except Exception as error:  # noqa: BLE001 - any opener's failure is "no browser here"
+        opened, reason = False, str(error)
+    else:
+        reason = "no browser could be started here (no display, or no browser to open)"
+    if not opened:
+        path.unlink(missing_ok=True)
+        raise CannotOpen(reason)
+    _remove_later(path)
+    return path
+
+
+def deliver(result: Any, opener: Callable[[str], bool] | None = None,
+            tell: Callable[[str, bool], None] = lambda url, opened: None) -> Any:
+    """``result`` as the host is given it: a page the server asked this process to open (``OPEN``) opened
+    here (``open_page``) by ``opener`` (``webbrowser.open``, which reads this process's ``BROWSER``), and the
+    request removed; where no browser opens, the sentence that said it did replaced by the one that says why
+    not. Whether it opened is told, ``tell(url, opened)`` (the server, ``OPENED``), before the result is
+    returned."""
+    meta = result.get("_meta") if isinstance(result, dict) else None
+    if not isinstance(meta, dict) or OPEN not in meta:
+        return result
+    asked = meta.pop(OPEN)
+    if not meta:
+        del result["_meta"]
+    if not isinstance(asked, dict):
+        return result
+    url, said, failed = asked.get("url"), asked.get("said"), asked.get("failed")
+    if not isinstance(url, str) or not url.startswith(("http://", "https://")):
+        return result  # only a page the server serves is opened, never a file or a program
+    try:
+        open_page(url, opener=opener or webbrowser.open)
+    except CannotOpen as failure:
+        tell(url, False)
+        if isinstance(said, str) and isinstance(failed, str):
+            instead = failed.replace("{reason}", str(failure))
+            for item in result.get("content") or []:
+                if isinstance(item, dict) and isinstance(item.get("text"), str):
+                    item["text"] = item["text"].replace(said, instead, 1)
+    else:
+        tell(url, True)
+    return result