dcc-mcp-gimp 0.2.0__tar.gz

dcc_mcp_gimp-0.2.0/.gitignore

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

dcc_mcp_gimp-0.2.0/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+## [0.2.0](https://github.com/dcc-mcp/dcc-mcp-gimp/compare/v0.1.0...v0.2.0) (2026-07-24)
+
+
+### Features
+
+* add GIMP MCP adapter ([4fcda51](https://github.com/dcc-mcp/dcc-mcp-gimp/commit/4fcda51b29d551e59175a81fa4fafcea5d2e8252))
+
+
+### Bug Fixes
+
+* keep persistent GIMP bridge process alive ([441aa0c](https://github.com/dcc-mcp/dcc-mcp-gimp/commit/441aa0c8d7a8c2bf3178457e931ec2835115061c))
+* match GIMP plugin folder to module name ([63799cb](https://github.com/dcc-mcp/dcc-mcp-gimp/commit/63799cbf1c60e53c7c56367b01b54d6290af76fb))
+* use GIMP persistent procedure callback signature ([9489a4f](https://github.com/dcc-mcp/dcc-mcp-gimp/commit/9489a4f452b5d0bd947a3108b761ba26b0256aff))
+* verify GIMP AppImage checksum ([573314b](https://github.com/dcc-mcp/dcc-mcp-gimp/commit/573314bc3bf1daf6e1e10ea722d03f66927a2eaa))
+
+## 0.1.0
+
+- Initial GIMP 3 session bridge and MCP adapter.

dcc_mcp_gimp-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_gimp-0.2.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: dcc-mcp-gimp
+Version: 0.2.0
+Summary: GIMP 3 adapter for the DCC Model Context Protocol
+Project-URL: Homepage, https://github.com/dcc-mcp/dcc-mcp-gimp
+Project-URL: Repository, https://github.com/dcc-mcp/dcc-mcp-gimp
+Project-URL: Issues, https://github.com/dcc-mcp/dcc-mcp-gimp/issues
+Author-email: loonghao <hal.long@outlook.com>
+License: MIT
+License-File: LICENSE
+Keywords: automation,dcc,gimp,image-editing,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-gimp
+
+GIMP 3 adapter for the DCC Model Context Protocol ecosystem.
+
+The adapter uses a small GIMP 3 Python plug-in and a loopback JSON-lines bridge.
+The MCP server runs in the normal Python environment; GIMP API calls stay inside
+the plug-in process. It does not expose arbitrary Python or Script-Fu execution.
+
+## Install
+
+```bash
+pip install dcc-mcp-gimp
+dcc-mcp-gimp-install
+```
+
+Restart GIMP, run **Filters → Development → DCC-MCP GIMP Bridge**, then start:
+
+```bash
+dcc-mcp-gimp
+```
+
+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_GIMP_BRIDGE_PORT` before
+starting both processes.
+
+## Current tools
+
+- Check GIMP 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 GIMP 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/*
+```
+
+GIMP 3 plug-in API reference: https://developer.gimp.org/api/3.0/

dcc_mcp_gimp-0.2.0/README.md

@@ -0,0 +1,46 @@
+# dcc-mcp-gimp
+
+GIMP 3 adapter for the DCC Model Context Protocol ecosystem.
+
+The adapter uses a small GIMP 3 Python plug-in and a loopback JSON-lines bridge.
+The MCP server runs in the normal Python environment; GIMP API calls stay inside
+the plug-in process. It does not expose arbitrary Python or Script-Fu execution.
+
+## Install
+
+```bash
+pip install dcc-mcp-gimp
+dcc-mcp-gimp-install
+```
+
+Restart GIMP, run **Filters → Development → DCC-MCP GIMP Bridge**, then start:
+
+```bash
+dcc-mcp-gimp
+```
+
+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_GIMP_BRIDGE_PORT` before
+starting both processes.
+
+## Current tools
+
+- Check GIMP 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 GIMP 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/*
+```
+
+GIMP 3 plug-in API reference: https://developer.gimp.org/api/3.0/

dcc_mcp_gimp-0.2.0/bridge/gimp-plugin/dcc_mcp_gimp.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+"""GIMP 3 Python plug-in exposing a loopback JSON-lines bridge."""
+
+import json
+import os
+import socketserver
+import sys
+import threading
+
+import gi
+
+gi.require_version("Gimp", "3.0")
+from gi.repository import Gimp, GLib
+
+
+PORT = int(os.environ.get("DCC_MCP_GIMP_BRIDGE_PORT", "3848"))
+
+
+def _image_info(image):
+    return {
+        "id": int(image.get_id()),
+        "name": image.get_name(),
+        "width": image.get_width(),
+        "height": image.get_height(),
+    }
+
+
+def _dispatch_main(method):
+    if method == "gimp.get_status":
+        return {"ready": True, "gimp_version": Gimp.version(), "bridge_port": PORT}
+    if method == "gimp.list_images":
+        return [_image_info(image) for image in Gimp.get_images()]
+    if method == "gimp.get_active_image":
+        image = Gimp.get_images()[0] if Gimp.get_images() else None
+        return _image_info(image) if image else None
+    if method == "gimp.ping":
+        return {"ready": True}
+    raise ValueError(f"Unsupported GIMP bridge method: {method}")
+
+
+def _dispatch(method):
+    result = {}
+    completed = threading.Event()
+
+    def run_on_main():
+        try:
+            result["value"] = _dispatch_main(method)
+        except Exception as exc:
+            result["error"] = exc
+        finally:
+            completed.set()
+        return GLib.SOURCE_REMOVE
+
+    GLib.idle_add(run_on_main)
+    if not completed.wait(10):
+        raise TimeoutError("GIMP main thread did not answer within 10 seconds")
+    if "error" in result:
+        raise result["error"]
+    return result.get("value")
+
+
+class _Handler(socketserver.StreamRequestHandler):
+    def handle(self):
+        line = self.rfile.readline().decode("utf-8")
+        if not line:
+            return
+        request = json.loads(line)
+        try:
+            result = _dispatch(request["method"])
+            response = {"jsonrpc": "2.0", "id": request.get("id"), "result": result}
+        except Exception as exc:  # GIMP procedure errors must reach the MCP caller.
+            response = {"jsonrpc": "2.0", "id": request.get("id"), "error": str(exc)}
+        self.wfile.write((json.dumps(response) + "\n").encode("utf-8"))
+
+
+class _Server(socketserver.ThreadingTCPServer):
+    allow_reuse_address = True
+    daemon_threads = True
+
+
+class DccMcpGimp(Gimp.PlugIn):
+    def do_query_procedures(self):
+        return ["python-fu-dcc-mcp-gimp-bridge"]
+
+    def do_create_procedure(self, name):
+        procedure = Gimp.Procedure.new(
+            self, name, Gimp.PDBProcType.PERSISTENT, self._run, self, None
+        )
+        procedure.set_documentation(
+            "Start the DCC-MCP GIMP bridge",
+            "Starts a loopback bridge for dcc-mcp-gimp.",
+            "dcc-mcp-gimp",
+        )
+        return procedure
+
+    @staticmethod
+    def _run(procedure, run_mode, config, plugin):
+        server = _Server(("127.0.0.1", PORT), _Handler)
+        threading.Thread(target=server.serve_forever, daemon=True).start()
+        procedure.persistent_ready()
+        plugin.persistent_enable()
+        GLib.MainLoop().run()
+        return procedure.new_return_values(Gimp.PDBStatusType.SUCCESS, None)
+
+
+Gimp.main(DccMcpGimp.__gtype__, sys.argv)

dcc_mcp_gimp-0.2.0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["hatchling>=1.26"]
+build-backend = "hatchling.build"
+
+[project]
+name = "dcc-mcp-gimp"
+version = "0.2.0"
+description = "GIMP 3 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 = ["gimp", "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-gimp"
+Repository = "https://github.com/dcc-mcp/dcc-mcp-gimp"
+Issues = "https://github.com/dcc-mcp/dcc-mcp-gimp/issues"
+
+[project.scripts]
+dcc-mcp-gimp = "dcc_mcp_gimp.server:main"
+dcc-mcp-gimp-install = "dcc_mcp_gimp.install:main"
+
+[project.entry-points."dcc_mcp.adapters"]
+gimp = "dcc_mcp_gimp:GimpMcpServer"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/dcc_mcp_gimp"]
+artifacts = ["src/dcc_mcp_gimp/skills/**"]
+
+[tool.hatch.build.targets.wheel.force-include]
+"bridge/gimp-plugin/dcc_mcp_gimp.py" = "dcc_mcp_gimp/gimp_plugin/dcc_mcp_gimp.py"
+
+[tool.hatch.build.targets.sdist]
+include = ["src/dcc_mcp_gimp", "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_gimp-0.2.0/src/dcc_mcp_gimp/__init__.py

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

dcc_mcp_gimp-0.2.0/src/dcc_mcp_gimp/__version__.py

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

dcc_mcp_gimp-0.2.0/src/dcc_mcp_gimp/bridge.py

@@ -0,0 +1,51 @@
+"""Small JSON-lines client for the GIMP 3 plug-in bridge."""
+
+from __future__ import annotations
+
+import json
+import os
+import socket
+from typing import Any
+
+
+class GimpBridgeError(RuntimeError):
+    """Raised when the GIMP plug-in bridge is unavailable or rejects a call."""
+
+
+class GimpBridge:
+    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) -> "GimpBridge":
+        return cls(
+            host=os.environ.get("DCC_MCP_GIMP_BRIDGE_HOST", "127.0.0.1"),
+            port=int(os.environ.get("DCC_MCP_GIMP_BRIDGE_PORT", "3848")),
+            timeout=float(os.environ.get("DCC_MCP_GIMP_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 GimpBridgeError(
+                f"GIMP bridge unavailable at {self.host}:{self.port}; "
+                "install and run the GIMP 3 plug-in"
+            ) from exc
+        if not response:
+            raise GimpBridgeError("GIMP bridge closed the connection without a response")
+        payload = json.loads(response)
+        if "error" in payload:
+            raise GimpBridgeError(str(payload["error"]))
+        return payload.get("result")
+
+
+def get_bridge() -> GimpBridge:
+    return GimpBridge.from_env()

dcc_mcp_gimp-0.2.0/src/dcc_mcp_gimp/install.py

@@ -0,0 +1,35 @@
+"""Install the GIMP 3 Python plug-in into a user plug-in directory."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import shutil
+from pathlib import Path
+
+
+def default_plugin_dir() -> Path:
+    if os.name == "nt":
+        root = Path(os.environ.get("APPDATA", Path.home() / "AppData/Roaming"))
+        return root / "GIMP/3.0/plug-ins"
+    return Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config")) / "GIMP/3.0/plug-ins"
+
+
+def install(destination: Path | None = None) -> Path:
+    target = (destination or default_plugin_dir()).expanduser().resolve() / "dcc_mcp_gimp"
+    target.mkdir(parents=True, exist_ok=True)
+    source = Path(__file__).resolve().parent / "gimp_plugin" / "dcc_mcp_gimp.py"
+    if not source.is_file():
+        source = Path(__file__).resolve().parents[2] / "bridge" / "gimp-plugin" / "dcc_mcp_gimp.py"
+    if not source.is_file():
+        raise FileNotFoundError(f"Bundled GIMP plug-in not found: {source}")
+    shutil.copy2(source, target / source.name)
+    if os.name != "nt":
+        (target / source.name).chmod(0o755)
+    return target
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--destination", type=Path)
+    print(install(parser.parse_args().destination))

dcc_mcp_gimp-0.2.0/src/dcc_mcp_gimp/server.py

@@ -0,0 +1,62 @@
+"""Standalone GIMP 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["GimpMcpServer"] = None
+
+
+class GimpMcpServer(DccServerBase):
+    """GIMP 3 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(
+            "gimp",
+            Path(__file__).resolve().parent / "skills",
+            port=port,
+            server_name="dcc-mcp-gimp",
+            server_version=__version__,
+        )
+        super().__init__(options=options)
+
+
+def start_server(port: Optional[int] = None) -> GimpMcpServer:
+    global _server
+    if _server is None or not _server.is_running:
+        selected_port = port or int(os.environ.get("DCC_MCP_GIMP_PORT", DEFAULT_PORT))
+        _server = GimpMcpServer(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_gimp-0.2.0/src/dcc_mcp_gimp/skills/gimp-session/SKILL.md

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

dcc_mcp_gimp-0.2.0/src/dcc_mcp_gimp/skills/gimp-session/metadata/depends.md

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

dcc_mcp_gimp-0.2.0/src/dcc_mcp_gimp/skills/gimp-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_gimp.bridge import get_bridge
+
+
+@skill_entry
+def main(**_kwargs):
+    return skill_success(
+        "Active GIMP image inspected.",
+        image=get_bridge().call("gimp.get_active_image"),
+    )
+
+
+if __name__ == "__main__":
+    run_main(main)

dcc_mcp_gimp-0.2.0/src/dcc_mcp_gimp/skills/gimp-session/scripts/get_status.py

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

dcc_mcp_gimp-0.2.0/src/dcc_mcp_gimp/skills/gimp-session/scripts/list_images.py

@@ -0,0 +1,13 @@
+from dcc_mcp_core.skill import run_main, skill_entry, skill_success
+
+from dcc_mcp_gimp.bridge import get_bridge
+
+
+@skill_entry
+def main(**_kwargs):
+    images = get_bridge().call("gimp.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_gimp-0.2.0/src/dcc_mcp_gimp/skills/gimp-session/tools.yaml

@@ -0,0 +1,34 @@
+tools:
+  - name: get_status
+    description: Check the GIMP 3 plug-in bridge and return GIMP 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 GIMP 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 GIMP 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_gimp-0.2.0/tests/live_gimp_smoke.py

@@ -0,0 +1,67 @@
+"""Exercise the real GIMP plug-in bridge and MCP tools."""
+
+from __future__ import annotations
+
+import json
+import time
+import urllib.request
+
+from dcc_mcp_gimp.bridge import GimpBridge
+from dcc_mcp_gimp.server import GimpMcpServer
+
+
+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 = GimpBridge.from_env()
+    deadline = time.monotonic() + 45
+    while time.monotonic() < deadline:
+        try:
+            status = bridge.call("gimp.get_status")
+            break
+        except Exception:
+            time.sleep(0.5)
+    else:
+        raise RuntimeError("GIMP plug-in bridge did not become ready")
+
+    server = GimpMcpServer(port=0)
+    try:
+        server.register_builtin_actions()
+        server.start(install_atexit_hook=False)
+        url = server.mcp_url
+        call(url, "load_skill", {"skill_name": "gimp-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_gimp-0.2.0/tests/test_bridge.py

@@ -0,0 +1,24 @@
+import json
+import socket
+import threading
+
+from dcc_mcp_gimp.bridge import GimpBridge
+
+
+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 = GimpBridge(port=listener.getsockname()[1])
+    assert bridge.call("gimp.ping") == {"ready": True}
+    assert received["request"]["method"] == "gimp.ping"
+    listener.close()

dcc_mcp_gimp-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_gimp" / "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")