dcc-mcp-krita 0.2.0__tar.gz

dcc_mcp_krita-0.2.0/.gitignore

@@ -0,0 +1,6 @@
+.venv/
+__pycache__/
+.pytest_cache/
+.ruff_cache/
+dist/
+*.egg-info/

dcc_mcp_krita-0.2.0/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+## [0.2.0](https://github.com/dcc-mcp/dcc-mcp-krita/compare/v0.1.0...v0.2.0) (2026-07-25)
+
+
+### Features
+
+* add DCC MCP adapter ([fc7aeac](https://github.com/dcc-mcp/dcc-mcp-krita/commit/fc7aeac768c5aff17c7c553a83449e7c962800c9))
+* add unified menu with Copy Instance ID, Server Info, and About DCC MCP ([#2](https://github.com/dcc-mcp/dcc-mcp-krita/issues/2)) ([e03addf](https://github.com/dcc-mcp/dcc-mcp-krita/commit/e03addf8f2963254b189772fe44757a5f9e20ebf))
+
+
+### Documentation
+
+* optimize workflow showcase ([7a37b8d](https://github.com/dcc-mcp/dcc-mcp-krita/commit/7a37b8df6adb34f71cb815d2a52ff739d399599d))
+* redesign DCC-MCP brand visuals ([0952d40](https://github.com/dcc-mcp/dcc-mcp-krita/commit/0952d40c4d4e11d719144d8d972281d9d2b4c69a))
+
+## 0.1.0
+
+- Initial Krita session bridge and MCP adapter.

dcc_mcp_krita-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 loonghao
+
+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.

dcc_mcp_krita-0.2.0/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: dcc-mcp-krita
+Version: 0.2.0
+Summary: Krita adapter for the DCC Model Context Protocol
+Project-URL: Homepage, https://github.com/dcc-mcp/dcc-mcp-krita
+Project-URL: Repository, https://github.com/dcc-mcp/dcc-mcp-krita
+Project-URL: Issues, https://github.com/dcc-mcp/dcc-mcp-krita/issues
+Author-email: loonghao <hal.long@outlook.com>
+License: MIT
+License-File: LICENSE
+Keywords: automation,dcc,image-editing,krita,mcp
+Requires-Python: >=3.9
+Requires-Dist: dcc-mcp-core<1.0.0,>=0.19.38
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.8; extra == 'dev'
+Requires-Dist: twine>=6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# dcc-mcp-krita
+
+![DCC-MCP Krita](docs/images/dcc-mcp-krita.svg)
+
+Krita adapter for the DCC Model Context Protocol ecosystem.
+
+![Krita game-art workflow](docs/images/dcc-mcp-krita-showcase.webp)
+
+The adapter uses a small Krita Python plug-in and a loopback JSON-lines bridge.
+The MCP server runs in the normal Python environment; KRITA API calls stay inside
+the plug-in process. It does not expose arbitrary Python or Script-Fu execution.
+
+## Install
+
+```bash
+pip install dcc-mcp-krita
+dcc-mcp-krita-install
+```
+
+Restart Krita, enable the bundled Python plug-in, then start:
+
+```bash
+dcc-mcp-krita
+```
+
+The MCP endpoint defaults to `http://127.0.0.1:8767/mcp`; the plug-in bridge uses
+`127.0.0.1:3848`. Override the latter with `DCC_MCP_KRITA_BRIDGE_PORT` before
+starting both processes.
+
+## Current tools
+
+- Check KRITA bridge status and version.
+- List open images with dimensions.
+- Inspect the active image.
+
+The first release targets safe session discovery. Image mutation and export will
+be added only through typed KRITA procedures, not arbitrary source evaluation.
+
+## Development
+
+```bash
+python -m pip install -e ".[dev]"
+python -m pytest
+python -m ruff check src tests tools
+python tools/lint_skills.py
+python -m build
+python -m twine check dist/*
+```
+
+Krita plug-in API reference: https://developer.krita.org/api/3.0/

dcc_mcp_krita-0.2.0/README.md

@@ -0,0 +1,50 @@
+# dcc-mcp-krita
+
+![DCC-MCP Krita](docs/images/dcc-mcp-krita.svg)
+
+Krita adapter for the DCC Model Context Protocol ecosystem.
+
+![Krita game-art workflow](docs/images/dcc-mcp-krita-showcase.webp)
+
+The adapter uses a small Krita Python plug-in and a loopback JSON-lines bridge.
+The MCP server runs in the normal Python environment; KRITA API calls stay inside
+the plug-in process. It does not expose arbitrary Python or Script-Fu execution.
+
+## Install
+
+```bash
+pip install dcc-mcp-krita
+dcc-mcp-krita-install
+```
+
+Restart Krita, enable the bundled Python plug-in, then start:
+
+```bash
+dcc-mcp-krita
+```
+
+The MCP endpoint defaults to `http://127.0.0.1:8767/mcp`; the plug-in bridge uses
+`127.0.0.1:3848`. Override the latter with `DCC_MCP_KRITA_BRIDGE_PORT` before
+starting both processes.
+
+## Current tools
+
+- Check KRITA bridge status and version.
+- List open images with dimensions.
+- Inspect the active image.
+
+The first release targets safe session discovery. Image mutation and export will
+be added only through typed KRITA procedures, not arbitrary source evaluation.
+
+## Development
+
+```bash
+python -m pip install -e ".[dev]"
+python -m pytest
+python -m ruff check src tests tools
+python tools/lint_skills.py
+python -m build
+python -m twine check dist/*
+```
+
+Krita plug-in API reference: https://developer.krita.org/api/3.0/

dcc_mcp_krita-0.2.0/bridge/krita-plugin/dcc_mcp_krita/__init__.py

@@ -0,0 +1,301 @@
+"""DCC MCP Krita — unified menu and JSON-lines bridge server.
+
+This pykrita extension provides:
+1. A background JSON-lines bridge server for external MCP communication.
+2. Unified menu actions: Copy Instance ID, Server Info, About DCC MCP.
+
+The bridge server runs in a daemon thread so Krita's UI remains responsive.
+Menu actions appear under Tools → Scripts (standard Krita extension location).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import socketserver
+import sys
+import threading
+
+# The Krita module is only available inside Krita's embedded Python.
+# This typing-only import silences static analysis without affecting runtime.
+if False:  # pragma: no cover
+    from krita import Extension, Krita  # noqa: F401
+
+BRIDGE_PORT: int = int(os.environ.get("DCC_MCP_KRITA_BRIDGE_PORT", "3848"))
+
+_bridge_thread: threading.Thread | None = None
+_bridge_server: socketserver.ThreadingTCPServer | None = None
+
+
+# ── Version (hard-coded to avoid import-time side-effects) ───────────────────
+
+VERSION: str = "0.2.0"
+
+# ── Bridge server ────────────────────────────────────────────────────────────
+
+
+def _document_info(document):
+    """Extract metadata from a Krita Document for the bridge."""
+    return {
+        "name": document.name(),
+        "width": document.width(),
+        "height": document.height(),
+    }
+
+
+class _BridgeHandler(socketserver.StreamRequestHandler):
+    """Single-request JSON-lines handler for the Krita bridge."""
+
+    def handle(self) -> None:
+        try:
+            request = json.loads(self.rfile.readline())
+        except (json.JSONDecodeError, ValueError):
+            return
+        method = request.get("method", "")
+        app = Krita.instance()
+        documents = app.documents()
+        if method in {"krita.get_status", "krita.ping"}:
+            result = {"ready": True, "krita_version": app.version(), "bridge_port": BRIDGE_PORT}
+        elif method in {"krita.list_documents", "krita.list_images"}:
+            result = [_document_info(document) for document in documents]
+        elif method in {"krita.get_active_document", "krita.get_active_image"}:
+            document = app.activeDocument()
+            result = _document_info(document) if document else None
+        else:
+            result = {"error": f"Unsupported Krita bridge method: {method}"}
+        self.wfile.write(
+            (
+                json.dumps(
+                    {"jsonrpc": "2.0", "id": request.get("id"), "result": result}
+                )
+                + "\n"
+            ).encode()
+        )
+
+
+def _start_bridge() -> None:
+    """Start the TCP bridge server in a background daemon thread.
+
+    Idempotent — if already running, this is a no-op.
+    """
+    global _bridge_thread, _bridge_server
+    if _bridge_thread is not None and _bridge_thread.is_alive():
+        return
+
+    class _Server(socketserver.ThreadingTCPServer):
+        allow_reuse_address = True
+        daemon_threads = True
+
+    _bridge_server = _Server(("127.0.0.1", BRIDGE_PORT), _BridgeHandler)
+    _bridge_thread = threading.Thread(target=_bridge_server.serve_forever, daemon=True)
+    _bridge_thread.start()
+
+
+def _stop_bridge() -> None:
+    """Shut down the bridge server."""
+    global _bridge_thread, _bridge_server
+    if _bridge_server is not None:
+        _bridge_server.shutdown()
+        _bridge_server.server_close()
+        _bridge_server = None
+    _bridge_thread = None
+
+
+# ── Clipboard helper ─────────────────────────────────────────────────────────
+
+
+def _set_clipboard_text(text: str) -> None:
+    """Set the system clipboard text.
+
+    Tries PyQt5 (Krita's bundled binding) first, then PySide2 as fallback.
+    Raises RuntimeError if neither binding is available.
+    """
+    for binding in ("PyQt5", "PySide2"):
+        try:
+            mod = __import__(binding)
+            app = mod.QtWidgets.QApplication.instance()
+            if app is not None:
+                app.clipboard().setText(text)
+                return
+        except Exception:
+            continue
+    raise RuntimeError("Unable to access system clipboard (no Qt binding available)")
+
+
+# ── Instance ID resolution ───────────────────────────────────────────────────
+
+
+def _resolve_instance_id() -> str:
+    """Resolve the DCC MCP instance UUID.
+
+    Priority:
+    1. ``DCC_MCP_INSTANCE_ID`` environment variable.
+    2. Running server's ``instance_id`` attribute.
+    Falls back to ``"unknown"``.
+    """
+    instance_id = os.environ.get("DCC_MCP_INSTANCE_ID")
+    if instance_id:
+        return instance_id
+
+    try:
+        from dcc_mcp_krita.server import _server  # type: ignore[import-not-found]
+
+        if _server is not None and getattr(_server, "is_running", False):
+            sid = getattr(_server, "instance_id", None)
+            if isinstance(sid, str):
+                return sid
+    except Exception:
+        pass
+
+    return "unknown"
+
+
+def _server_url() -> str:
+    """Return the MCP server URL or a placeholder."""
+    try:
+        from dcc_mcp_krita.server import _server  # type: ignore[import-not-found]
+
+        if _server is not None and getattr(_server, "is_running", False):
+            return getattr(_server, "mcp_url", "N/A")
+    except Exception:
+        pass
+    return "N/A"
+
+
+# ── Menu actions ─────────────────────────────────────────────────────────────
+
+
+def _copy_instance_id() -> None:
+    """Copy the DCC MCP instance UUID to the system clipboard.
+
+    Falls back to ``print()`` when the clipboard is unavailable (headless).
+    """
+    instance_id = _resolve_instance_id()
+    copied = False
+    try:
+        _set_clipboard_text(instance_id)
+        copied = True
+    except RuntimeError:
+        pass
+
+    if copied:
+        print(f"DCC MCP: Instance ID copied to clipboard: {instance_id}")  # noqa: T201
+    else:
+        print(f"DCC MCP Instance ID: {instance_id}")  # noqa: T201
+
+
+def _show_server_info() -> None:
+    """Display DCC MCP server status information in a dialog."""
+    instance_id = _resolve_instance_id()
+    mcp_url = _server_url()
+
+    krita_version = "unknown"
+    try:
+        krita_version = Krita.instance().version()
+    except Exception:
+        pass
+
+    core_version = "unknown"
+    try:
+        from dcc_mcp_core.server_base import _package_version  # type: ignore[import-not-found]
+
+        core_version = _package_version() or "unknown"
+    except Exception:
+        pass
+
+    gateway_port_str = os.environ.get("DCC_MCP_GATEWAY_PORT", "0")
+    try:
+        gp = int(gateway_port_str)
+    except ValueError:
+        gp = 0
+    gateway_display = "disabled" if gp <= 0 else str(gp)
+
+    lines = [
+        f"Instance UUID: {instance_id}",
+        f"DCC: Krita {krita_version}",
+        f"PID: {os.getpid()}",
+        f"MCP URL: {mcp_url}",
+        f"Gateway Port: {gateway_display}",
+        f"Core Version: {core_version}",
+        f"Adapter Version: {VERSION}",
+        f"Python: {sys.version.split()[0]}",
+    ]
+    _show_message_box("DCC MCP — Server Info", "\n".join(lines))
+
+
+def _show_about() -> None:
+    """Show the About DCC MCP dialog with version information."""
+    krita_version = "unknown"
+    try:
+        krita_version = Krita.instance().version()
+    except Exception:
+        pass
+
+    text = (
+        f"dcc-mcp-krita v{VERSION}\n"
+        f"Krita {krita_version}\n"
+        f"Python {sys.version.split()[0]}\n\n"
+        "DCC MCP — AI-driven DCC automation.\n"
+        "https://github.com/dcc-mcp/dcc-mcp-krita"
+    )
+    _show_message_box("About DCC MCP", text)
+
+
+def _show_message_box(title: str, text: str) -> None:
+    """Show a message box using PyQt5 (Krita's bundled binding)."""
+    try:
+        from PyQt5.QtWidgets import QMessageBox
+    except ImportError:
+        try:
+            from PySide2.QtWidgets import QMessageBox
+        except ImportError:
+            print(f"{title}\n{text}")  # noqa: T201
+            return
+
+    try:
+        window = Krita.instance().activeWindow()
+        if window is not None:
+            qwin = window.qwindow()
+            if qwin is not None:
+                QMessageBox.information(qwin, title, text)
+                return
+    except Exception:
+        pass
+
+    print(f"{title}\n{text}")  # noqa: T201
+
+
+# ── Pykrita Extension ───────────────────────────────────────────────────────
+
+
+class DccMcpKritaExtension(Extension):  # type: ignore[name-defined]  # noqa: F821
+    """Krita pykrita extension for DCC MCP.
+
+    Registers unified menu actions and starts the bridge server on load.
+    """
+
+    def __init__(self, parent: object) -> None:  # noqa: D107
+        super().__init__(parent)  # type: ignore[call-arg]
+
+    def setup(self) -> None:  # noqa: D102
+        _start_bridge()
+
+    def createActions(self, window: object) -> None:  # noqa: D102, N802
+        copy_action = window.createAction(
+            "dcc_mcp_copy_instance_id", "Copy Instance ID", "tools/scripts"
+        )
+        copy_action.triggered.connect(_copy_instance_id)
+
+        server_action = window.createAction(
+            "dcc_mcp_server_info", "Server Info", "tools/scripts"
+        )
+        server_action.triggered.connect(_show_server_info)
+
+        about_action = window.createAction(
+            "dcc_mcp_about", "About DCC MCP", "tools/scripts"
+        )
+        about_action.triggered.connect(_show_about)
+
+
+# Register the extension when Krita loads this module.
+Krita.instance().addExtension(DccMcpKritaExtension(Krita.instance()))

dcc_mcp_krita-0.2.0/bridge/krita-plugin/dcc_mcp_krita.desktop

@@ -0,0 +1,7 @@
+[Desktop Entry]
+Type=Service
+X-KDE-ServiceTypes=Krita/PythonPlugin
+X-Python-2-Compatible=false
+X-Krita-Version=28
+Name=DCC MCP Krita
+Comment=DCC MCP integration for Krita — AI-driven automation bridge

dcc_mcp_krita-0.2.0/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["hatchling>=1.26"]
+build-backend = "hatchling.build"
+
+[project]
+name = "dcc-mcp-krita"
+version = "0.2.0"
+description = "Krita adapter for the DCC Model Context Protocol"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "loonghao", email = "hal.long@outlook.com" }]
+keywords = ["krita", "image-editing", "mcp", "dcc", "automation"]
+dependencies = ["dcc-mcp-core>=0.19.38,<1.0.0"]
+
+[project.optional-dependencies]
+dev = ["build>=1.2", "pytest>=8", "ruff>=0.8", "twine>=6"]
+
+[project.urls]
+Homepage = "https://github.com/dcc-mcp/dcc-mcp-krita"
+Repository = "https://github.com/dcc-mcp/dcc-mcp-krita"
+Issues = "https://github.com/dcc-mcp/dcc-mcp-krita/issues"
+
+[project.scripts]
+dcc-mcp-krita = "dcc_mcp_krita.server:main"
+dcc-mcp-krita-install = "dcc_mcp_krita.install:main"
+
+[project.entry-points."dcc_mcp.adapters"]
+krita = "dcc_mcp_krita:KritaMcpServer"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/dcc_mcp_krita"]
+artifacts = ["src/dcc_mcp_krita/skills/**"]
+
+[tool.hatch.build.targets.wheel.force-include]
+"bridge/krita-plugin/dcc_mcp_krita.desktop" = "dcc_mcp_krita/krita_plugin/dcc_mcp_krita.desktop"
+"bridge/krita-plugin/dcc_mcp_krita/__init__.py" = "dcc_mcp_krita/krita_plugin/dcc_mcp_krita/__init__.py"
+
+[tool.hatch.build.targets.sdist]
+include = ["src/dcc_mcp_krita", "bridge", "tests", "README.md", "LICENSE", "CHANGELOG.md", "tools"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src", "."]
+
+[tool.ruff]
+target-version = "py39"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B"]

dcc_mcp_krita-0.2.0/src/dcc_mcp_krita/__init__.py

@@ -0,0 +1,3 @@
+from .server import KritaMcpServer
+
+__all__ = ["KritaMcpServer"]

dcc_mcp_krita-0.2.0/src/dcc_mcp_krita/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

dcc_mcp_krita-0.2.0/src/dcc_mcp_krita/bridge.py

@@ -0,0 +1,51 @@
+"""Small JSON-lines client for the Krita plug-in bridge."""
+
+from __future__ import annotations
+
+import json
+import os
+import socket
+from typing import Any
+
+
+class KritaBridgeError(RuntimeError):
+    """Raised when the KRITA plug-in bridge is unavailable or rejects a call."""
+
+
+class KritaBridge:
+    def __init__(self, host: str = "127.0.0.1", port: int = 3848, timeout: float = 10.0) -> None:
+        self.host = host
+        self.port = port
+        self.timeout = timeout
+
+    @classmethod
+    def from_env(cls) -> "KritaBridge":
+        return cls(
+            host=os.environ.get("DCC_MCP_KRITA_BRIDGE_HOST", "127.0.0.1"),
+            port=int(os.environ.get("DCC_MCP_KRITA_BRIDGE_PORT", "3848")),
+            timeout=float(os.environ.get("DCC_MCP_KRITA_BRIDGE_TIMEOUT", "10")),
+        )
+
+    def call(self, method: str, **params: Any) -> Any:
+        request = json.dumps({"jsonrpc": "2.0", "id": 1, "method": method, "params": params})
+        try:
+            with socket.create_connection(
+                (self.host, self.port), timeout=self.timeout
+            ) as connection:
+                connection.sendall((request + "\n").encode("utf-8"))
+                response = connection.makefile("r", encoding="utf-8").readline()
+        except OSError as exc:
+            raise KritaBridgeError(
+                f"KRITA bridge unavailable at {self.host}:{self.port}; "
+                "install and run the Krita plug-in"
+            ) from exc
+        if not response:
+            raise KritaBridgeError("KRITA bridge closed the connection without a response")
+        payload = json.loads(response)
+        if "error" in payload:
+            raise KritaBridgeError(str(payload["error"]))
+        return payload.get("result")
+
+
+def get_bridge() -> KritaBridge:
+    return KritaBridge.from_env()

dcc_mcp_krita-0.2.0/src/dcc_mcp_krita/install.py

@@ -0,0 +1,82 @@
+"""Install the Krita pykrita extension into the user pykrita directory."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import shutil
+from pathlib import Path
+
+_PLUGIN_NAME = "dcc_mcp_krita"
+
+
+def default_pykrita_dir() -> Path:
+    """Return the default Krita pykrita directory for the current platform."""
+    if os.name == "nt":
+        root = Path(os.environ.get("APPDATA", Path.home() / "AppData" / "Roaming"))
+        return root / "krita" / "pykrita"
+    return (
+        Path(os.environ.get("XDG_DATA_HOME", Path.home() / ".local" / "share"))
+        / "krita"
+        / "pykrita"
+    )
+
+
+def _resolve_source_dir() -> Path:
+    """Find the bridge/krita-plugin directory (dev) or installed wheel location."""
+    # Wheel layout: dcc_mcp_krita/krita_plugin/...
+    candidate = (
+        Path(__file__).resolve().parent / "krita_plugin"
+    )
+    if candidate.is_dir():
+        return candidate
+
+    # Dev layout: ../../bridge/krita-plugin
+    candidate = Path(__file__).resolve().parents[2] / "bridge" / "krita-plugin"
+    if candidate.is_dir():
+        return candidate
+
+    raise FileNotFoundError(
+        "Bundled Krita plugin directory not found (tried wheel and dev layouts)"
+    )
+
+
+def install(destination: Path | None = None) -> Path:
+    """Install the pykrita extension into the user's Krita pykrita directory.
+
+    Copies:
+    - ``dcc_mcp_krita.desktop`` → ``<pykrita>/dcc_mcp_krita.desktop``
+    - ``dcc_mcp_krita/`` module → ``<pykrita>/dcc_mcp_krita/``
+    """
+    target = (destination or default_pykrita_dir()).expanduser().resolve()
+    target.mkdir(parents=True, exist_ok=True)
+
+    source_dir = _resolve_source_dir()
+
+    # Install .desktop file
+    desktop_src = source_dir / f"{_PLUGIN_NAME}.desktop"
+    if not desktop_src.is_file():
+        raise FileNotFoundError(f"Desktop entry not found: {desktop_src}")
+    shutil.copy2(desktop_src, target / desktop_src.name)
+
+    # Install plugin module directory
+    module_src = source_dir / _PLUGIN_NAME
+    if not module_src.is_dir():
+        raise FileNotFoundError(f"Plugin module directory not found: {module_src}")
+    module_dst = target / _PLUGIN_NAME
+    if module_dst.exists():
+        shutil.rmtree(module_dst)
+    shutil.copytree(module_src, module_dst)
+
+    if os.name != "nt":
+        for py_file in module_dst.rglob("*.py"):
+            py_file.chmod(0o755)
+
+    return target
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Install DCC MCP Krita pykrita extension")
+    parser.add_argument("--destination", type=Path, help="Override pykrita directory")
+    result = install(parser.parse_args().destination)
+    print(f"Installed DCC MCP Krita extension to {result}")

dcc_mcp_krita-0.2.0/src/dcc_mcp_krita/server.py

@@ -0,0 +1,62 @@
+"""Standalone KRITA MCP server lifecycle."""
+
+from __future__ import annotations
+
+import os
+import signal
+import sys
+import threading
+from pathlib import Path
+from typing import Optional
+
+from dcc_mcp_core import DccServerOptions
+from dcc_mcp_core.server_base import DccServerBase
+
+from .__version__ import __version__
+
+DEFAULT_PORT = 8767
+_server: Optional["KritaMcpServer"] = None
+
+
+class KritaMcpServer(DccServerBase):
+    """Krita adapter using its Python plug-in bridge."""
+
+    def __init__(self, port: int = DEFAULT_PORT) -> None:
+        os.environ.setdefault("DCC_MCP_PYTHON_EXECUTABLE", sys.executable)
+        options = DccServerOptions.from_env(
+            "krita",
+            Path(__file__).resolve().parent / "skills",
+            port=port,
+            server_name="dcc-mcp-krita",
+            server_version=__version__,
+        )
+        super().__init__(options=options)
+
+
+def start_server(port: Optional[int] = None) -> KritaMcpServer:
+    global _server
+    if _server is None or not _server.is_running:
+        selected_port = port or int(os.environ.get("DCC_MCP_KRITA_PORT", DEFAULT_PORT))
+        _server = KritaMcpServer(selected_port)
+        _server.register_builtin_actions()
+        _server.start()
+    return _server
+
+
+def stop_server() -> None:
+    global _server
+    if _server is not None:
+        _server.stop()
+        _server = None
+
+
+def main() -> None:
+    stopped = threading.Event()
+    signal.signal(signal.SIGINT, lambda *_: stopped.set())
+    if hasattr(signal, "SIGTERM"):
+        signal.signal(signal.SIGTERM, lambda *_: stopped.set())
+    start_server()
+    try:
+        stopped.wait()
+    finally:
+        stop_server()

dcc_mcp_krita-0.2.0/src/dcc_mcp_krita/skills/krita-session/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: krita-session
+description: >-
+  Inspect the connected Krita session through the DCC-MCP Python plug-in
+  bridge. Use for session health, open images, and active image metadata.
+license: MIT
+compatibility: "Krita.0+; dcc-mcp-core 0.19+"
+allowed-tools: "python"
+metadata:
+  dcc-mcp:
+    dcc: krita
+    layer: domain
+    version: "0.1.0"
+    search-hint: "KRITA image editor session document active image layers"
+    tags: "krita,image-editing,session"
+    tools: tools.yaml
+    depends: "dcc-diagnostics"
+---
+
+# KRITA Session
+
+Install and run the bundled Krita plug-in before using this skill. Calls use a
+loopback JSON-lines bridge and never execute arbitrary KRITA/Python source.

dcc_mcp_krita-0.2.0/src/dcc_mcp_krita/skills/krita-session/metadata/depends.md

@@ -0,0 +1 @@
+- dcc-diagnostics

dcc_mcp_krita-0.2.0/src/dcc_mcp_krita/skills/krita-session/scripts/get_active_image.py

@@ -0,0 +1,15 @@
+from dcc_mcp_core.skill import run_main, skill_entry, skill_success
+
+from dcc_mcp_krita.bridge import get_bridge
+
+
+@skill_entry
+def main(**_kwargs):
+    return skill_success(
+        "Active KRITA image inspected.",
+        image=get_bridge().call("krita.get_active_image"),
+    )
+
+
+if __name__ == "__main__":
+    run_main(main)

dcc_mcp_krita-0.2.0/src/dcc_mcp_krita/skills/krita-session/scripts/get_status.py

@@ -0,0 +1,12 @@
+from dcc_mcp_core.skill import run_main, skill_entry, skill_success
+
+from dcc_mcp_krita.bridge import get_bridge
+
+
+@skill_entry
+def main(**_kwargs):
+    return skill_success("KRITA bridge is ready.", **get_bridge().call("krita.get_status"))
+
+
+if __name__ == "__main__":
+    run_main(main)

dcc_mcp_krita-0.2.0/src/dcc_mcp_krita/skills/krita-session/scripts/list_images.py

@@ -0,0 +1,13 @@
+from dcc_mcp_core.skill import run_main, skill_entry, skill_success
+
+from dcc_mcp_krita.bridge import get_bridge
+
+
+@skill_entry
+def main(**_kwargs):
+    images = get_bridge().call("krita.list_images")
+    return skill_success(f"Found {len(images)} open image(s).", count=len(images), images=images)
+
+
+if __name__ == "__main__":
+    run_main(main)

dcc_mcp_krita-0.2.0/src/dcc_mcp_krita/skills/krita-session/tools.yaml

@@ -0,0 +1,34 @@
+tools:
+  - name: get_status
+    description: Check the Krita plug-in bridge and return KRITA version and bridge metadata.
+    input_schema: {type: object, properties: {}, additionalProperties: false}
+    output_schema: {type: object}
+    read_only: true
+    destructive: false
+    idempotent: true
+    execution: sync
+    affinity: any
+    timeout_hint_secs: 30
+    source_file: scripts/get_status.py
+  - name: list_images
+    description: List open KRITA images with dimensions and names. Read-only.
+    input_schema: {type: object, properties: {}, additionalProperties: false}
+    output_schema: {type: object}
+    read_only: true
+    destructive: false
+    idempotent: true
+    execution: sync
+    affinity: any
+    timeout_hint_secs: 30
+    source_file: scripts/list_images.py
+  - name: get_active_image
+    description: Return metadata for the active KRITA image. Read-only.
+    input_schema: {type: object, properties: {}, additionalProperties: false}
+    output_schema: {type: object}
+    read_only: true
+    destructive: false
+    idempotent: true
+    execution: sync
+    affinity: any
+    timeout_hint_secs: 30
+    source_file: scripts/get_active_image.py

dcc_mcp_krita-0.2.0/tests/live_gimp_smoke.py

@@ -0,0 +1,67 @@
+"""Exercise the real KRITA plug-in bridge and MCP tools."""
+
+from __future__ import annotations
+
+import json
+import time
+import urllib.request
+
+from dcc_mcp_krita.bridge import KritaBridge
+from dcc_mcp_krita.server import KritaMcpServer
+
+
+def post(url: str, method: str, params=None):
+    request = urllib.request.Request(
+        url,
+        data=json.dumps({"jsonrpc": "2.0", "id": 1, "method": method, "params": params}).encode(),
+        headers={
+            "Accept": "application/json, text/event-stream",
+            "Content-Type": "application/json",
+        },
+    )
+    with urllib.request.urlopen(request, timeout=30) as response:
+        return json.loads(response.read())
+
+
+def call(url: str, name: str, arguments=None):
+    response = post(url, "tools/call", {"name": name, "arguments": arguments or {}})
+    result = response.get("result", {})
+    if response.get("error") or result.get("isError"):
+        raise RuntimeError(json.dumps(response))
+    structured = result.get("structuredContent")
+    if structured is not None:
+        return structured
+    return json.loads(result["content"][0]["text"])
+
+
+def main() -> None:
+    bridge = KritaBridge.from_env()
+    deadline = time.monotonic() + 45
+    while time.monotonic() < deadline:
+        try:
+            status = bridge.call("krita.get_status")
+            break
+        except Exception:
+            time.sleep(0.5)
+    else:
+        raise RuntimeError("KRITA plug-in bridge did not become ready")
+
+    server = KritaMcpServer(port=0)
+    try:
+        server.register_builtin_actions()
+        server.start(install_atexit_hook=False)
+        url = server.mcp_url
+        call(url, "load_skill", {"skill_name": "krita-session"})
+        listed = post(url, "tools/list", {})["result"]["tools"]
+        names = {item["name"] for item in listed}
+        assert any(name.endswith("__get_status") for name in names)
+        assert call(url, next(name for name in names if name.endswith("__get_status")))["ready"]
+        images = call(url, next(name for name in names if name.endswith("__list_images")))
+        assert isinstance(images.get("images"), list)
+        print(json.dumps({"status": status, "images": images}))
+    finally:
+        server.stop()
+
+
+if __name__ == "__main__":
+    main()

dcc_mcp_krita-0.2.0/tests/test_bridge.py

@@ -0,0 +1,24 @@
+import json
+import socket
+import threading
+
+from dcc_mcp_krita.bridge import KritaBridge
+
+
+def test_bridge_sends_json_lines_request():
+    received = {}
+
+    def serve(listener):
+        connection, _ = listener.accept()
+        with connection:
+            received["request"] = json.loads(connection.makefile("r", encoding="utf-8").readline())
+            connection.sendall(b'{"jsonrpc":"2.0","id":1,"result":{"ready":true}}\n')
+
+    listener = socket.socket()
+    listener.bind(("127.0.0.1", 0))
+    listener.listen(1)
+    threading.Thread(target=serve, args=(listener,), daemon=True).start()
+    bridge = KritaBridge(port=listener.getsockname()[1])
+    assert bridge.call("krita.ping") == {"ready": True}
+    assert received["request"]["method"] == "krita.ping"
+    listener.close()

dcc_mcp_krita-0.2.0/tests/test_plugin_structure.py

@@ -0,0 +1,225 @@
+"""Tests for Krita plugin installation and module structure."""
+
+from __future__ import annotations
+
+import ast
+import os
+from pathlib import Path
+
+import pytest
+
+# ── Install tests ────────────────────────────────────────────────────────────
+
+
+class TestDefaultPykritaDir:
+    """Platform-specific pykrita directory resolution."""
+
+    @pytest.mark.skipif(os.name != "nt", reason="WindowsPath not available on Linux")
+    def test_windows_default(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(os, "name", "nt")
+        monkeypatch.setenv("APPDATA", "C:\\Users\\test\\AppData\\Roaming")
+        from dcc_mcp_krita.install import default_pykrita_dir
+
+        result = default_pykrita_dir()
+        assert result == Path("C:/Users/test/AppData/Roaming/krita/pykrita")
+
+    @pytest.mark.skipif(os.name != "nt", reason="WindowsPath not available on Linux")
+    def test_windows_fallback_home(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(os, "name", "nt")
+        monkeypatch.delenv("APPDATA", raising=False)
+        monkeypatch.setattr(Path, "home", lambda: Path("C:/Users/test"))
+        from dcc_mcp_krita.install import default_pykrita_dir
+
+        result = default_pykrita_dir()
+        assert result == Path("C:/Users/test/AppData/Roaming/krita/pykrita")
+
+    @pytest.mark.skipif(os.name == "nt", reason="PosixPath not available on Windows")
+    def test_linux_default(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(os, "name", "posix")
+        monkeypatch.setenv("XDG_DATA_HOME", "/home/test/.local/share")
+        from dcc_mcp_krita.install import default_pykrita_dir
+
+        result = default_pykrita_dir()
+        assert result == Path("/home/test/.local/share/krita/pykrita")
+
+    @pytest.mark.skipif(os.name == "nt", reason="PosixPath not available on Windows")
+    def test_linux_fallback_home(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(os, "name", "posix")
+        monkeypatch.delenv("XDG_DATA_HOME", raising=False)
+        monkeypatch.setattr(Path, "home", lambda: Path("/home/test"))
+        from dcc_mcp_krita.install import default_pykrita_dir
+
+        result = default_pykrita_dir()
+        assert result == Path("/home/test/.local/share/krita/pykrita")
+
+
+class TestInstall:
+    """Integration tests for the install process."""
+
+    def test_install_copies_desktop_and_module(self, tmp_path: Path) -> None:
+        """install() copies both the .desktop file and the module directory."""
+        from dcc_mcp_krita.install import install
+
+        install(tmp_path)
+        assert (tmp_path / "dcc_mcp_krita.desktop").is_file()
+        assert (tmp_path / "dcc_mcp_krita" / "__init__.py").is_file()
+
+    def test_install_desktop_content(self, tmp_path: Path) -> None:
+        """Desktop entry file contains the expected metadata."""
+        from dcc_mcp_krita.install import install
+
+        install(tmp_path)
+        content = (tmp_path / "dcc_mcp_krita.desktop").read_text(encoding="utf-8")
+        assert "DCC MCP" in content
+        assert "Krita/PythonPlugin" in content
+        assert "X-Krita-Version" in content
+
+    def test_install_module_is_valid_python(self, tmp_path: Path) -> None:
+        """The installed __init__.py is syntactically valid Python."""
+        from dcc_mcp_krita.install import install
+
+        install(tmp_path)
+        source = (tmp_path / "dcc_mcp_krita" / "__init__.py").read_text(encoding="utf-8")
+        ast.parse(source)  # raises SyntaxError on failure
+
+    def test_install_creates_target_if_missing(self, tmp_path: Path) -> None:
+        """install() creates the pykrita directory if it does not exist."""
+        from dcc_mcp_krita.install import install
+
+        target = tmp_path / "new" / "pykrita"
+        assert not target.exists()
+        install(target)
+        assert target.is_dir()
+        assert (target / "dcc_mcp_krita.desktop").is_file()
+
+    def test_install_overwrites_existing_module(self, tmp_path: Path) -> None:
+        """Re-installing replaces the existing module directory."""
+        from dcc_mcp_krita.install import install
+
+        install(tmp_path)
+        # Second install — should not raise
+        install(tmp_path)
+        # Module should still be present after second install
+        assert (tmp_path / "dcc_mcp_krita" / "__init__.py").is_file()
+
+
+# ── Plugin module validation ─────────────────────────────────────────────────
+
+
+class TestPluginModule:
+    """Validate the plugin module structure."""
+
+    def test_plugin_init_exists(self) -> None:
+        """The __init__.py exists in the source tree."""
+        repo_root = Path(__file__).resolve().parents[1]
+        init_path = repo_root / "bridge" / "krita-plugin" / "dcc_mcp_krita" / "__init__.py"
+        assert init_path.is_file(), f"Missing: {init_path}"
+
+    def test_plugin_desktop_exists(self) -> None:
+        """The .desktop file exists in the source tree."""
+        repo_root = Path(__file__).resolve().parents[1]
+        desktop_path = repo_root / "bridge" / "krita-plugin" / "dcc_mcp_krita.desktop"
+        assert desktop_path.is_file(), f"Missing: {desktop_path}"
+
+    def test_plugin_init_is_valid_python(self) -> None:
+        """The __init__.py parses as valid Python 3.9+."""
+        repo_root = Path(__file__).resolve().parents[1]
+        init_path = repo_root / "bridge" / "krita-plugin" / "dcc_mcp_krita" / "__init__.py"
+        source = init_path.read_text(encoding="utf-8")
+        ast.parse(source)
+
+    def test_plugin_init_contains_menu_actions(self) -> None:
+        """The plugin module defines the three unified menu action functions."""
+        repo_root = Path(__file__).resolve().parents[1]
+        init_path = repo_root / "bridge" / "krita-plugin" / "dcc_mcp_krita" / "__init__.py"
+        source = init_path.read_text(encoding="utf-8")
+        assert "_copy_instance_id" in source
+        assert "_show_server_info" in source
+        assert "_show_about" in source
+
+    def test_plugin_init_contains_clipboard_helper(self) -> None:
+        """The plugin module defines the clipboard helper."""
+        repo_root = Path(__file__).resolve().parents[1]
+        init_path = repo_root / "bridge" / "krita-plugin" / "dcc_mcp_krita" / "__init__.py"
+        source = init_path.read_text(encoding="utf-8")
+        assert "_set_clipboard_text" in source
+        assert "QApplication.clipboard" in source or "clipboard()" in source
+
+    def test_plugin_init_references_project_url(self) -> None:
+        """The About dialog references the correct GitHub URL."""
+        repo_root = Path(__file__).resolve().parents[1]
+        init_path = repo_root / "bridge" / "krita-plugin" / "dcc_mcp_krita" / "__init__.py"
+        source = init_path.read_text(encoding="utf-8")
+        assert "github.com/dcc-mcp/dcc-mcp-krita" in source
+
+    def test_old_single_file_removed(self) -> None:
+        """The old dcc_mcp_krita.py single-file plugin has been removed."""
+        repo_root = Path(__file__).resolve().parents[1]
+        old_path = repo_root / "bridge" / "krita-plugin" / "dcc_mcp_krita.py"
+        assert not old_path.exists(), (
+            "Old single-file bridge plugin still exists — should be replaced by the "
+            "dcc_mcp_krita/ directory structure"
+        )
+
+
+# ── Version consistency ──────────────────────────────────────────────────────
+
+
+class TestVersionConsistency:
+    """Ensure version strings stay aligned."""
+
+    def test_pyproject_version_matches_init(self) -> None:
+        """pyproject.toml version matches src/dcc_mcp_krita/__version__.py."""
+        repo_root = Path(__file__).resolve().parents[1]
+        import tomllib
+
+        pyproject = tomllib.loads(
+            (repo_root / "pyproject.toml").read_text(encoding="utf-8")
+        )
+        pyproject_version = pyproject["project"]["version"]
+
+        # Read __version__.py
+        version_path = repo_root / "src" / "dcc_mcp_krita" / "__version__.py"
+        version_ns: dict = {}
+        exec(version_path.read_text(encoding="utf-8"), version_ns)
+        assert pyproject_version == version_ns["__version__"]
+
+    def test_pyproject_version_matches_plugin_init(self) -> None:
+        """pyproject.toml version matches the hard-coded VERSION in the plugin."""
+        repo_root = Path(__file__).resolve().parents[1]
+        import tomllib
+
+        pyproject = tomllib.loads(
+            (repo_root / "pyproject.toml").read_text(encoding="utf-8")
+        )
+        pyproject_version = pyproject["project"]["version"]
+
+        init_path = repo_root / "bridge" / "krita-plugin" / "dcc_mcp_krita" / "__init__.py"
+        source = init_path.read_text(encoding="utf-8")
+        assert f'VERSION: str = "{pyproject_version}"' in source
+
+
+# ── Python version compliance ────────────────────────────────────────────────
+
+
+class TestPythonCompliance:
+    """Ensure the plugin code is compatible with the project's minimum Python."""
+
+    def test_union_type_syntax(self) -> None:
+        """Verify that `X | Y` union syntax is valid (requires Python 3.10+, but
+        we have ``from __future__ import annotations`` so it's parseable on 3.9+).
+        """
+        # On Python 3.9, `int | None` would be a TypeError at runtime without
+        # ``from __future__ import annotations``. Test that the plugin uses the
+        # future import and parses cleanly.
+        repo_root = Path(__file__).resolve().parents[1]
+        init_path = repo_root / "bridge" / "krita-plugin" / "dcc_mcp_krita" / "__init__.py"
+        source = init_path.read_text(encoding="utf-8")
+        tree = ast.parse(source)
+        # The file must have the future import as its first import
+        assert any(
+            isinstance(node, ast.ImportFrom)
+            and node.module == "__future__"
+            and any(alias.name == "annotations" for alias in node.names)
+            for node in ast.iter_child_nodes(tree)
+        ), "Plugin __init__.py must have `from __future__ import annotations`"

dcc_mcp_krita-0.2.0/tools/lint_skills.py

@@ -0,0 +1,8 @@
+from pathlib import Path
+
+from dcc_mcp_core import validate_skill
+
+skills_root = Path(__file__).parents[1] / "src" / "dcc_mcp_krita" / "skills"
+reports = [validate_skill(str(path)) for path in skills_root.iterdir() if path.is_dir()]
+assert all(report.is_clean for report in reports), [report.issues for report in reports]
+print(f"validated {len(reports)} bundled skills")