autodev-cli 1.4.150 → 1.4.152

package/media/gimp/gimp_mcp_server.py

@@ -1,267 +1,366 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-#
-# gimp_mcp_server.py — AutoDev auto-start GIMP 3.x MCP bridge
-#
-# Derived from libreearth/gimp-mcp @49c46dd (GPL-3.0); modified by AutoDev to
-# auto-start as a GIMP 3.x PERSISTENT extension. The upstream plugin registered a
-# manual "<Image>/Filters/Development/ → Start MCP Server" ImageProcedure that the
-# user had to click; this variant registers a PERSISTENT extension so GIMP starts
-# the socket server automatically on launch — no menu click, no open image needed.
-#
-# The socket / command-marshalling logic (start_server, handle_client,
-# execute_command, GLib.idle_add onto GIMP's main thread) is kept from upstream.
-# ONLY the registration + run() model changed to PERSISTENT + defensive ordering.
-#
-# ---------------------------------------------------------------------------
-# GIMP 3.x plugin layout (REQUIRED): this file must live at
-#   <gimp-config>/<ver>/plug-ins/gimp_mcp_server/gimp_mcp_server.py
-# i.e. inside a sub-folder whose name == this file's basename. A loose .py is
-# IGNORED by GIMP 3.x. On Linux/macOS it must ALSO be executable (chmod 0o755).
 # ---------------------------------------------------------------------------
+# gimp_mcp_server.py — vendored, USER-VERIFIED GIMP 3.2 MCP bridge (plug-in).
 #
-# Copyright (C) 2023 libreearth (upstream, GPL-3.0)
-# Modifications Copyright (C) 2025 AutoDev
-#
-# This program is free software: you can redistribute it and/or modify it under
-# the terms of the GNU General Public License as published by the Free Software
-# Foundation, either version 3 of the License, or (at your option) any later
-# version.
+# Derived from libreearth/gimp-mcp (GPL-3.0; see media/gimp/LICENSE) and fixed by
+# the user / AutoDev for GIMP 3.2 (Store / MSIX). Verified working on real GIMP
+# 3.2.44: a menu-triggered PLUGIN (Tools -> MCP / Filters -> Development -> Start
+# MCP Server) that listens on 127.0.0.1:9876 and drives GIMP. Keep the "GIMP MCP
+# Server" window open — GLib.MainLoop() holds the out-of-process plug-in alive.
 #
-# This program is distributed in the hope that it will be useful, but WITHOUT ANY
-# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-# PARTICULAR PURPOSE. See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program. If not, see <https://www.gnu.org/licenses/>. A copy is vendored
-# next to this file as LICENSE.
+# This is the user's verified file; the body below is kept byte-for-byte. The
+# lines in THIS block are a provenance comment only — do not edit the code below.
+# ---------------------------------------------------------------------------
 
-import os
-import sys
-import json
-import socket
-import threading
-import traceback
-import datetime
+# GIMP MCP Server Plugin (GIMP 3.2)
+# Listens on localhost:9876 so the libreearth gimp-mcp client can drive GIMP.
 
 import gi
 gi.require_version('Gimp', '3.0')
 from gi.repository import Gimp
 from gi.repository import GLib
+from gi.repository import Gio
+from gi.repository import GObject
+
+import io
+import json
+import os
+import socket
+import sys
+import threading
+import traceback
 
+HOST = '127.0.0.1'
+PORT = 9876
+# Store GIMP redirects GLib config dir into the MSIX LocalCache. Also write
+# to the real roaming profile so the log is findable.
+_LOG_PATHS = [
+    os.path.join(GLib.get_user_config_dir(), 'GIMP', '3.2', 'gimp_mcp_server.log'),
+    os.path.join(os.environ.get('APPDATA', ''), 'GIMP', '3.2', 'gimp_mcp_server.log'),
+]
 
-# ---------------------------------------------------------------------------
-# Logging — an auto-start extension has NO console, so every diagnostic goes to
-# a log file the user can read. We resolve it next to this plug-in first (always
-# writable if the plug-in loaded at all), falling back to the GIMP config dir.
-# Nothing here may raise: a logging failure must never stop GIMP from launching.
-# ---------------------------------------------------------------------------
-def _log_path():
-    try:
-        here = os.path.dirname(os.path.abspath(__file__))
-        return os.path.join(here, 'gimp-mcp-server.log')
-    except Exception:
+_server_lock = threading.Lock()
+_server_started = False
+_exec_globals = None
+_main_loop = None
+
+
+def _log(msg):
+    line = msg.rstrip() + '\n'
+    for path in _LOG_PATHS:
+        if not path:
+            continue
         try:
-            return os.path.join(GLib.get_user_config_dir(), 'gimp-mcp-server.log')
+            os.makedirs(os.path.dirname(path), exist_ok=True)
+            with open(path, 'a', encoding='utf-8') as fh:
+                fh.write(line)
         except Exception:
-            return os.path.join(os.path.expanduser('~'), 'gimp-mcp-server.log')
+            pass
+    print(msg, flush=True)
 
 
-_LOG_FILE = _log_path()
+def N_(message):
+    return message
 
 
-def log(msg):
-    """Best-effort append to the log file AND stderr. Never raises."""
-    line = '[%s] %s' % (datetime.datetime.now().isoformat(timespec='seconds'), msg)
-    try:
-        with open(_LOG_FILE, 'a', encoding='utf-8') as fh:
-            fh.write(line + '\n')
-    except Exception:
-        pass
+def _(message):
+    return GLib.dgettext(None, message)
+
+
+def _serialize(obj):
+    if obj is None or isinstance(obj, (str, int, float, bool)):
+        return obj
+    if isinstance(obj, (list, tuple)):
+        return [_serialize(item) for item in obj]
+    if isinstance(obj, dict):
+        return {str(k): _serialize(v) for k, v in obj.items()}
+    data = {'type': obj.__class__.__name__}
+    if hasattr(obj, 'get_id'):
+        try:
+            data['id'] = int(obj.get_id())
+        except Exception:
+            pass
+    elif hasattr(obj, 'ID'):
+        data['id'] = obj.ID
+    if hasattr(obj, 'get_name'):
+        try:
+            data['name'] = obj.get_name()
+        except Exception:
+            pass
+    if 'id' not in data and len(data) == 1:
+        return str(obj)
+    return data
+
+
+def _resolve_api(api_path):
+    parts = [p for p in str(api_path).split('.') if p]
+    if parts and parts[0] == 'Gimp':
+        parts = parts[1:]
+    elif len(parts) >= 3 and parts[0] == 'gi' and parts[1] == 'repository' and parts[2] == 'Gimp':
+        parts = parts[3:]
+
+    aliases = {
+        'list_images': 'get_images',
+        'list_fonts': 'get_fonts',
+        'fonts_get_list': 'get_fonts',
+    }
+
+    if not parts:
+        return Gimp
+
+    obj = Gimp
+    for part in parts:
+        part = aliases.get(part, part)
+        obj = getattr(obj, part)
+    return obj
+
+
+def _exec_namespace():
+    global _exec_globals
+    if _exec_globals is None:
+        ns = {
+            '__builtins__': __builtins__,
+            '__name__': '__main__',
+            'Gimp': Gimp,
+            'GLib': GLib,
+            'Gio': Gio,
+            'GObject': GObject,
+            'sys': sys,
+            'os': os,
+            'json': json,
+        }
+        try:
+            gi.require_version('Gegl', '0.4')
+            from gi.repository import Gegl
+            ns['Gegl'] = Gegl
+        except Exception as exc:
+            _log(f'Gegl import failed: {exc}')
+        try:
+            gi.require_version('Babl', '0.1')
+            from gi.repository import Babl
+            ns['Babl'] = Babl
+        except Exception:
+            pass
+        _exec_globals = ns
+    return _exec_globals
+
+
+def _extract_code(args, kwargs):
+    if kwargs.get('code'):
+        return str(kwargs['code'])
+    if not args:
+        return ''
+    if len(args) >= 2 and args[0] in ('exec', 'eval', 'pyGObject-console'):
+        payload = args[1]
+        if isinstance(payload, (list, tuple)):
+            return '\n'.join(str(item) for item in payload)
+        return str(payload)
+    if isinstance(args[0], (list, tuple)):
+        return '\n'.join(str(item) for item in args[0])
+    return str(args[0])
+
+
+def _run_python(code):
+    ns = _exec_namespace()
+    stdout = io.StringIO()
+    old_stdout = sys.stdout
+    sys.stdout = stdout
     try:
-        sys.stderr.write(line + '\n')
-    except Exception:
-        pass
+        exec(code, ns)
+    finally:
+        sys.stdout = old_stdout
+    printed = stdout.getvalue()
+    result = ns.get('_result')
+    if result is not None:
+        return {'printed': printed, 'result': _serialize(result)}
+    return {'printed': printed, 'result': None}
 
 
 class MCPPlugin(Gimp.PlugIn):
-    # ── Registration ──────────────────────────────────────────────────────
+    def do_set_i18n(self, name):
+        return False
+
     def do_query_procedures(self):
-        return ["plug-in-mcp-server-autostart"]
+        return ['plug-in-mcp-server']
 
     def do_create_procedure(self, name):
-        # PERSISTENT + no args + no menu = GIMP auto-starts this extension at
-        # launch. Adding ANY argument, a menu label, or a menu path would turn
-        # it back into a user-invoked plug-in and disable auto-start.
         procedure = Gimp.Procedure.new(
-            self, name, Gimp.PDBProcType.PERSISTENT, self.run, None,
+            self, name, Gimp.PDBProcType.PLUGIN, self.run, None
         )
-        try:
-            procedure.set_documentation(
-                "AutoDev MCP server (auto-start)",
-                "Auto-starts a localhost:9876 socket bridge so external MCP "
-                "clients can drive GIMP. Derived from libreearth/gimp-mcp "
-                "(GPL-3.0), modified by AutoDev to run as a PERSISTENT extension.",
-                name,
-            )
-            procedure.set_attribution("AutoDev", "AutoDev (GPL-3.0)", "2025")
-        except Exception as e:
-            # Attribution/doc setters are cosmetic — never let a binding
-            # mismatch here prevent the procedure from registering.
-            log("do_create_procedure: non-fatal setter error: %s" % e)
+        procedure.set_menu_label(_('Start MCP Server'))
+        procedure.set_documentation(
+            _('Starts an MCP server to control GIMP externally'),
+            _('Listens on 127.0.0.1:9876 for the GIMP MCP client'),
+            name,
+        )
+        procedure.set_attribution('GIMP MCP', 'GIMP MCP', '2026')
+        procedure.set_sensitivity_mask(Gimp.ProcedureSensitivityMask.ALWAYS)
+        procedure.add_enum_argument(
+            'run-mode',
+            _('Run mode'),
+            _('The run mode'),
+            Gimp.RunMode,
+            Gimp.RunMode.INTERACTIVE,
+            GObject.ParamFlags.READWRITE,
+        )
+        procedure.add_menu_path('<Image>/Tools/MCP')
+        procedure.add_menu_path('<Image>/Filters/Development/')
         return procedure
 
-    # ── Extension entry point ─────────────────────────────────────────────
-    def run(self, procedure, config, run_data):
-        """PERSISTENT extension entry point.
-
-        DEFENSIVE ORDER (the brick-risk part): call persistent_ready() FIRST.
-        Its ABSENCE is what hangs GIMP at startup, so it must run before
-        anything that could throw. Everything after it is wrapped so a bind
-        failure logs + degrades instead of taking GIMP core down with it.
-        """
-        # 1) Hand control back to GIMP core IMMEDIATELY so the UI keeps loading.
-        try:
-            procedure.persistent_ready()
-            log("persistent_ready() OK — extension is live")
-        except Exception as e:
-            # A binding mismatch on this exact call is the known lock-up cause;
-            # log it (do NOT re-raise) so GIMP still finishes launching.
-            log("persistent_ready() FAILED (non-fatal): %s\n%s"
-                % (e, traceback.format_exc()))
-
-        # 2) Start the socket server on a daemon thread. A bind failure (port in
-        #    use, sandbox denial) MUST NOT crash the process or block launch.
+    def run(self, procedure, config, data):
+        global _main_loop
+        started, message = self.ensure_server()
+        _log(message)
         try:
-            t = threading.Thread(target=self.start_server, daemon=True)
-            t.start()
-            log("MCP server thread started (listening on localhost:9876)")
-        except Exception as e:
-            log("failed to start MCP server thread (non-fatal): %s\n%s"
-                % (e, traceback.format_exc()))
-
-        # 3) Keep this extension process alive for the whole GIMP session so the
-        #    socket stays open and idle_add callbacks can marshal onto core.
+            Gimp.message(message)
+        except Exception:
+            pass
+        if not started:
+            return procedure.new_return_values(Gimp.PDBStatusType.EXECUTION_ERROR, GLib.Error(message))
+
+        # GIMP 3 launches Python plug-ins out of process. Returning from run()
+        # would exit that process and kill the socket thread. Stay alive and
+        # dispatch GLib.idle_add work (API calls) on this main loop.
+        # A visible window is required: otherwise "Start MCP Server" looks like
+        # it did not open anything.
         try:
-            GLib.MainLoop().run()
-        except Exception as e:
-            log("main loop exited (non-fatal): %s" % e)
+            self._show_status_window(message)
+        except Exception as exc:
+            _log(f'Status window failed: {exc}\n{traceback.format_exc()}')
 
-        # 4) Standard PERSISTENT success return.
+        _main_loop = GLib.MainLoop()
+        _log('Entering GLib.MainLoop to keep MCP server process alive')
+        try:
+            _main_loop.run()
+        except Exception as exc:
+            _log(f'MainLoop exited: {exc}')
         return procedure.new_return_values(Gimp.PDBStatusType.SUCCESS, GLib.Error())
 
-    # ── Socket server (kept from upstream) ────────────────────────────────
+    def _show_status_window(self, message):
+        gi.require_version('Gtk', '3.0')
+        gi.require_version('GimpUi', '3.0')
+        from gi.repository import Gtk
+        from gi.repository import GimpUi
+
+        GimpUi.init('gimp_mcp_server.py')
+        window = Gtk.Window(title='GIMP MCP Server')
+        window.set_default_size(420, 160)
+        window.set_keep_above(True)
+        box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=8)
+        box.set_border_width(16)
+        label = Gtk.Label(label=message + '\n\nLeave this window open while Grok talks to GIMP.')
+        label.set_line_wrap(True)
+        box.pack_start(label, True, True, 0)
+        button = Gtk.Button(label='Stop server')
+        button.connect('clicked', lambda *_: window.destroy())
+        box.pack_start(button, False, False, 0)
+        window.add(box)
+        window.connect('destroy', self._on_status_closed)
+        window.show_all()
+        window.present()
+        _log('Status window opened')
+
+    def _on_status_closed(self, *_args):
+        global _main_loop
+        _log('Status window closed; stopping MCP server')
+        if _main_loop is not None:
+            _main_loop.quit()
+
+    def ensure_server(self):
+        global _server_started
+        with _server_lock:
+            if _server_started:
+                return True, f'MCP Server already listening on {HOST}:{PORT}'
+            try:
+                thread = threading.Thread(target=self.start_server, daemon=True)
+                thread.start()
+                _server_started = True
+                return True, f'MCP Server started on {HOST}:{PORT}'
+            except Exception as exc:
+                return False, f'Failed to start MCP Server: {exc}'
+
     def start_server(self):
-        host = 'localhost'
-        port = 9876
-        sock = None
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
         try:
-            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-            sock.bind((host, port))
-            sock.listen(1)
-            log("server listening on %s:%d" % (host, port))
-        except Exception as e:
-            # Bind/listen failed (e.g. port already taken by Blender's MCP or a
-            # second GIMP). Log + bail out of the thread; GIMP keeps running.
-            log("bind/listen failed (non-fatal): %s\n%s" % (e, traceback.format_exc()))
-            try:
-                if sock is not None:
-                    sock.close()
-            except Exception:
-                pass
+            sock.bind((HOST, PORT))
+            sock.listen(8)
+            _log(f'Server listening on {HOST}:{PORT}')
+        except Exception as exc:
+            _log(f'Bind/listen failed: {exc}')
             return
 
         while True:
             try:
                 client, addr = sock.accept()
-                log("client connected: %s" % (addr,))
-                threading.Thread(
-                    target=self.handle_client, args=(client,), daemon=True,
-                ).start()
-            except Exception as e:
-                log("accept error: %s" % e)
+                _log(f'Connected to {addr}')
+                threading.Thread(target=self.handle_client, args=(client,), daemon=True).start()
+            except Exception as exc:
+                _log(f'Server accept error: {exc}')
                 break
-        try:
-            sock.close()
-        except Exception:
-            pass
+        sock.close()
 
     def handle_client(self, client):
         buffer = b''
-        while True:
-            try:
-                data = client.recv(1024)
-                if not data:
+        try:
+            client.settimeout(120)
+            while True:
+                chunk = client.recv(65536)
+                if not chunk:
                     break
-                buffer += data
-                try:
-                    command = json.loads(buffer.decode('utf-8'))
-                    buffer = b''
-                    # Marshal onto GIMP's main thread — the PDB is not thread-safe.
+                buffer += chunk
+                while buffer:
+                    try:
+                        command = json.loads(buffer.decode('utf-8'))
+                        buffer = b''
+                    except json.JSONDecodeError:
+                        break
                     GLib.idle_add(self.execute_command, command, client)
-                except json.JSONDecodeError:
-                    # Partial frame — keep buffering until it parses.
-                    continue
-            except Exception as e:
-                log("client error: %s" % e)
-                break
-        try:
-            client.close()
-        except Exception:
-            pass
+        except Exception as exc:
+            _log(f'Client error: {exc}')
+        finally:
+            try:
+                client.close()
+            except Exception:
+                pass
 
     def execute_command(self, command, client):
-        """Runs on GIMP's main thread via idle_add. Guarded so a bad command or
-        a wrong binding logs + returns an error frame rather than hanging."""
-        response = {}
+        cmd_type = command.get('type')
+        params = command.get('params', {}) or {}
         try:
-            cmd_type = command.get("type")
-            params = command.get("params", {})
-
-            if cmd_type == "call_api":
-                api_path = params["api_path"]
-                args = params.get("args", [])
-                kwargs = params.get("kwargs", {})
-
-                module = Gimp
-                for part in api_path.split("."):
-                    module = getattr(module, part)
-
-                result = module(*args, **kwargs)
-
-                if hasattr(result, "ID"):
-                    result = {"id": result.ID}
-                elif isinstance(result, list):
-                    result = [self.serialize_gimp_object(item) for item in result]
+            if cmd_type == 'ping':
+                response = {'status': 'success', 'result': 'pong'}
+            elif cmd_type == 'exec':
+                code = _extract_code(params.get('args', []), params.get('kwargs', {}))
+                if not code:
+                    code = str(params.get('code', ''))
+                response = {'status': 'success', 'result': _run_python(code)}
+            elif cmd_type == 'call_api':
+                api_path = params.get('api_path', '')
+                args = params.get('args', []) or []
+                kwargs = params.get('kwargs', {}) or {}
+                if api_path in ('exec', 'eval', '__exec__'):
+                    response = {'status': 'success', 'result': _run_python(_extract_code(args, kwargs))}
                 else:
-                    result = str(result)
-
-                response = {"status": "success", "result": result}
+                    method = _resolve_api(api_path)
+                    result = method(*args, **kwargs)
+                    response = {'status': 'success', 'result': _serialize(result)}
             else:
-                response = {"status": "error", "message": "Unknown command: %s" % cmd_type}
-        except Exception as e:
-            response = {"status": "error", "message": str(e),
-                        "traceback": traceback.format_exc()}
+                response = {'status': 'error', 'message': f'Unknown command: {cmd_type}'}
+        except Exception as exc:
+            response = {
+                'status': 'error',
+                'message': str(exc),
+                'traceback': traceback.format_exc(),
+            }
+            _log(f'Command error: {response["message"]}\n{response["traceback"]}')
 
         try:
-            client.sendall(json.dumps(response).encode('utf-8'))
-        except Exception as e:
-            log("failed to send response: %s" % e)
-        return False  # one-shot idle callback
-
-    def serialize_gimp_object(self, obj):
-        try:
-            if hasattr(obj, "ID"):
-                return {"id": obj.ID, "type": obj.__class__.__name__}
-        except Exception:
-            pass
-        return str(obj)
+            payload = json.dumps(response).encode('utf-8')
+            client.sendall(payload)
+        except Exception as exc:
+            _log(f'Response send failed: {exc}')
+        return False
 
 
-try:
-    Gimp.main(MCPPlugin.__gtype__, sys.argv)
-except Exception as _e:
-    # If GIMP's main dispatch itself fails, log it — never let the plug-in
-    # process take the launch down with an unhandled traceback.
-    log("Gimp.main failed: %s\n%s" % (_e, traceback.format_exc()))
+Gimp.main(MCPPlugin.__gtype__, sys.argv)