meltygui 0.1.0__py3-none-any.whl

meltygui/chat/codex_settings.py

@@ -0,0 +1,100 @@
+"""Codex catalog capabilities and saved thread settings, shared with the UI."""
+import json
+from pathlib import Path
+
+from meltygui.chat.chat_proxy import epoch_seconds
+
+
+def model_service_tiers(row):
+    if "serviceTiers" in row:
+        return tuple(tier for tier in row["serviceTiers"] if tier.get("id"))
+    return tuple({"id": tier, "name": "Fast" if tier in ("fast", "priority") else tier}
+                 for tier in row.get("additionalSpeedTiers", []))
+
+
+def fast_service_tier(proxy, model):
+    return next((tier["id"] for tier in getattr(proxy, "model_service_tiers", {}).get(model, ())
+                 if tier["id"] in ("priority", "fast") or tier.get("name", "").lower() == "fast"), None)
+
+
+def effective_settings(chat, defaults, default_model=None):
+    saved = chat.get("codex_settings", {})
+    saved_at = chat.get("codex_settings_at", 0)
+    metadata = chat.metadata
+    result = {}
+    for field, config_field in (("model", "model"), ("effort", "model_reasoning_effort"),
+                                ("service_tier", "service_tier")):
+        explicit = field in metadata and (field != "model" or metadata.get("model_explicit"))
+        if explicit and metadata.get(field + "_selected_at", 0) >= saved_at:
+            value = metadata[field]
+            if field != "service_tier" and value in (None, "", "default"):
+                value = defaults.get(config_field)
+            result[field] = value
+        elif field in saved:
+            result[field] = saved[field]
+        elif config_field in defaults and (field != "service_tier" or defaults[config_field] is not None):
+            result[field] = defaults[config_field]
+    result["model"] = result.get("model") or default_model
+    return result
+
+
+class ThreadSettingsReader:
+    """Worker-only incremental log reader; initial reads scan backwards."""
+    def __init__(self):
+        self.files = {}
+
+    @staticmethod
+    def parse(line):
+        if b'"thread_settings_applied"' not in line:
+            return None
+        try:
+            row = json.loads(line)
+        except (ValueError, UnicodeError):
+            return None
+        payload = row.get("payload") or {}
+        if row.get("type") != "event_msg" or payload.get("type") != "thread_settings_applied":
+            return None
+        values = payload.get("thread_settings") or {}
+        return {"codex_settings": {target: values[source] for source, target in
+                (("model", "model"), ("reasoning_effort", "effort"), ("service_tier", "service_tier"))
+                if source in values}, "codex_settings_at": epoch_seconds(row.get("timestamp"))}
+
+    def read(self, path):
+        if not path:
+            return {}
+        path = Path(path)
+        previous = self.files.get(path)
+        try:
+            stat = path.stat()
+            signature = (stat.st_ino, stat.st_size, stat.st_mtime_ns)
+            if previous and previous[0] == signature:
+                return previous[2]
+            with path.open("rb") as handle:
+                if previous and previous[0][0] == stat.st_ino and stat.st_size > previous[0][1]:
+                    offset, settings = previous[1:]
+                    handle.seek(offset)
+                    while line := handle.readline():
+                        if not line.endswith(b'\n'):
+                            break
+                        settings = self.parse(line) or settings
+                        offset = handle.tell()
+                else:
+                    offset, settings = stat.st_size, {}
+                    position, tail, first = stat.st_size, b"", True
+                    while position and not settings:
+                        count = min(position, 65536)
+                        position -= count
+                        handle.seek(position)
+                        parts = (handle.read(count) + tail).split(b"\n")
+                        tail = parts.pop(0) if position else b""
+                        if first and parts:
+                            offset -= len(parts.pop())  # exclude the partial trailing record
+                            first = False
+                        for line in reversed(parts):
+                            settings = self.parse(line) or {}
+                            if settings:
+                                break
+            self.files[path] = (signature, offset, settings)
+            return settings
+        except OSError:
+            return previous[2] if previous else {}

meltygui/chat/codex_transport.py

@@ -0,0 +1,60 @@
+"""Multiplexed, persistent version of the account-only stdio transport."""
+import json
+import queue
+import threading
+
+from meltygui.completion.providers.codex_accounts import AppServer
+
+
+class CodexTransport(AppServer):
+    def __init__(self, home, executable="", timeout=30, on_event=None):
+        self.pending = {}
+        self.write_lock = threading.Lock()
+        self.pending_lock = threading.Lock()
+        self.on_event = on_event or (lambda event: None)
+        super().__init__(home, executable, timeout)
+
+    def _send(self, message):
+        with self.write_lock:
+            super()._send(message)
+
+    def _read(self):
+        try:
+            for line in self.process.stdout:
+                message = json.loads(line)
+                if "method" in message:
+                    self.on_event(message)
+                else:
+                    with self.pending_lock:
+                        response = self.pending.get(message.get("id"))
+                    if response is not None:
+                        response.put(message)
+        except (ValueError, OSError) as error:
+            self.on_event({"method": "transport/error", "params": {"message": str(error)}})
+        finally:
+            with self.pending_lock:
+                for response in self.pending.values():
+                    response.put({"error": {"message": "Codex disconnected"}})
+            self.on_event({"method": "transport/error", "params": {"message": "Codex disconnected"}})
+
+    def request(self, method, params=None):
+        response = queue.Queue()
+        with self.pending_lock:
+            self.sequence += 1
+            identifier = self.sequence
+            self.pending[identifier] = response
+        try:
+            self._send({"method": method, "id": identifier, "params": params or {}})
+            try:
+                message = response.get(timeout=self.timeout)
+            except queue.Empty:
+                raise TimeoutError(f"Codex timed out: {method}") from None
+            if "error" in message:
+                raise RuntimeError(message["error"].get("message", "Codex request failed"))
+            return message.get("result") or {}
+        finally:
+            with self.pending_lock:
+                self.pending.pop(identifier, None)
+
+    def answer(self, request_id, result=None, error=None):
+        self._send({"id": request_id, **({"error": error} if error else {"result": result})})

meltygui/chat/command_parser.py

@@ -0,0 +1,204 @@
+"""Static command inspection. Never execute commands, import code, or read files."""
+import ast
+import posixpath
+import re
+import shlex
+
+
+def shell_body(command):
+    """Remove a literal shell -c wrapper, retaining the original script text."""
+    for _ in range(3):
+        try:
+            words = shlex.split(command)
+        except ValueError:
+            break
+        if len(words) >= 3 and posixpath.basename(words[0]) in ('bash', 'sh', 'zsh'):
+            flag = next((i for i, word in enumerate(words[1:], 1)
+                         if word.startswith('-') and 'c' in word), None)
+            if flag is not None and flag + 1 < len(words):
+                command = words[flag + 1]
+                continue
+        break
+    return command
+
+
+def parse_command(command, actions=(), scripts=None, cwd=""):
+    """Return literal file references and captured script bodies.
+
+    `access` is an operation requested by the command, not proof it succeeded.
+    Unknown variables, substitutions, imports and function calls stay unknown.
+    """
+    files = {}
+    scripts = scripts if scripts is not None else {}
+
+    def add(path, access='read', explicit=False):
+        if not isinstance(path, str) or not path or path.startswith('-'):
+            return
+        if any(char in path for char in '\n\r$*?{}|') or '://' in path:
+            return
+        if not explicit and not re.fullmatch(r'[\w./@ +\-]+\.[\w]+', path):
+            return
+        path = posixpath.normpath(posixpath.join(cwd, path))
+        old = files.get(path)
+        if old is None or access == 'write':
+            files[path] = access
+
+    def python(source):
+        try:
+            tree = ast.parse(source)
+        except (SyntaxError, ValueError):
+            return
+        env = {}
+
+        def resolve(node):
+            if isinstance(node, ast.Constant) and isinstance(node.value, str):
+                return node.value
+            if isinstance(node, ast.Name):
+                return env.get(node.id)
+            if isinstance(node, ast.BinOp):
+                left, right = resolve(node.left), resolve(node.right)
+                if left is not None and right is not None:
+                    if isinstance(node.op, ast.Div):
+                        return posixpath.join(left, right)
+                    if isinstance(node.op, ast.Add):
+                        return left + right
+            if isinstance(node, ast.Call):
+                name = getattr(node.func, 'id', getattr(node.func, 'attr', ''))
+                if name in ('Path', 'PurePath', 'PurePosixPath') and node.args:
+                    parts = [resolve(arg) for arg in node.args]
+                    if all(part is not None for part in parts):
+                        return posixpath.join(*parts)
+                if name == 'open' and node.args:
+                    return resolve(node.args[0])
+                if isinstance(node.func, ast.Attribute) and name == 'joinpath':
+                    base = resolve(node.func.value)
+                    parts = [resolve(arg) for arg in node.args]
+                    if base is not None and all(part is not None for part in parts):
+                        return posixpath.join(base, *parts)
+            return None
+
+        def visit(node):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+                return  # a definition is not evidence that its body ran
+            if isinstance(node, ast.Assign):
+                value = resolve(node.value)
+                for target in node.targets:
+                    if isinstance(target, ast.Name):
+                        env[target.id] = value
+            if isinstance(node, ast.With):
+                for item in node.items:
+                    if isinstance(item.optional_vars, ast.Name):
+                        env[item.optional_vars.id] = resolve(item.context_expr)
+            if isinstance(node, ast.For) and isinstance(node.target, ast.Name) and isinstance(node.iter, (ast.List, ast.Tuple)):
+                before = dict(env)
+                for value in node.iter.elts[:100]:
+                    env[node.target.id] = resolve(value)
+                    for child in node.body:
+                        visit(child)
+                env.clear()
+                env.update(before)
+                return
+            if isinstance(node, ast.Call):
+                name = getattr(node.func, 'id', getattr(node.func, 'attr', ''))
+                if name == 'open' and node.args:
+                    mode = resolve(node.args[1]) if len(node.args) > 1 else 'r'
+                    mode = next((resolve(kw.value) for kw in node.keywords if kw.arg == 'mode'), mode)
+                    add(resolve(node.args[0]), 'write' if mode and any(c in mode for c in 'wax+') else 'read', True)
+                if isinstance(node.func, ast.Attribute):
+                    path = resolve(node.func.value)
+                    if name in ('write_text', 'write_bytes', 'write', 'writelines', 'unlink', 'touch'):
+                        add(path, 'write', True)
+                    elif name in ('read_text', 'read_bytes', 'read', 'readlines'):
+                        add(path, 'read', True)
+                    elif name in ('rename', 'replace') and path is not None and node.args:
+                        add(path, 'write', True)
+                        add(resolve(node.args[0]), 'write', True)
+            for child in ast.iter_child_nodes(node):
+                visit(child)
+        visit(tree)
+
+    source = shell_body(str(command))
+    # Heredocs expose Python directly, or the body of a script written
+    # in one history item and run by a later item. Remember only the
+    # literal scripts; never consult the filesystem for an indirect script.
+    pattern = re.compile(r"^([^\n]*?)<<-?\s*(['\"]?)([A-Za-z_]\w*)\2([^\n]*)\n(.*?)^\3[ \t]*(?:\n|$)", re.M | re.S)
+    segments = []
+    last = 0
+    for match in pattern.finditer(source):
+        segments.append(source[last:match.start()])
+        head, body = match[1] + match[4], match[5]
+        try:
+            words = shlex.split(head)
+        except ValueError:
+            words = []
+        if any(re.fullmatch(r'python(?:\d+(?:\.\d+)?)?', posixpath.basename(w)) for w in words[:2]):
+            python(body)
+        else:
+            target = re.search(r'>\s*([^\s]+)', head)
+            if target:
+                path = target[1].strip("'\"")
+                add(path, 'write', True)
+                if path.endswith('.py'):
+                    scripts[posixpath.normpath(path)] = body
+            if 'apply_patch' in head:
+                for path in re.findall(r'^\*\*\* (?:Update|Add|Delete) File: (.+)$', body, re.M):
+                    add(path, 'write', True)
+        segments.append(head + '\n')
+        last = match.end()
+    segments.append(source[last:])
+    source_without_bodies = ''.join(segments)
+    try:
+        lexer = shlex.shlex(source_without_bodies, posix=True, punctuation_chars=';&|<>\n')
+        lexer.whitespace_split = True
+        lexer.whitespace = ' \t\r'
+        words = list(lexer)
+    except ValueError:
+        words = []
+    groups, group = [], []
+    for word in words + [';']:
+        if word and all(char in ';|&\n' for char in word):
+            if group:
+                groups.append(group)
+            group = []
+        else:
+            group.append(word)
+    for group in groups:
+        executable = posixpath.basename(group[0])
+        if re.fullmatch(r'python(?:\d+(?:\.\d+)?)?', executable):
+            if '-c' in group and group.index('-c') + 1 < len(group):
+                python(group[group.index('-c') + 1])
+            else:
+                for word in group[1:]:
+                    if word.endswith('.py'):
+                        add(word)
+                        captured = scripts.get(posixpath.normpath(word))
+                        if captured is not None:
+                            python(captured)
+        for index, word in enumerate(group):
+            if word in ('>', '>>') and index + 1 < len(group):
+                add(group[index + 1], 'write', True)
+            elif index > 0:
+                access = 'write' if executable in ('tee', 'touch', 'rm', 'mv') or executable == 'sed' and any(w.startswith('-i') for w in group) else 'read'
+                if executable in ('cp', 'install') and index == len(group) - 1:
+                    access = 'write'
+                add(word, access)
+    def add_action(path):
+        if not isinstance(path, str) or not path:
+            return
+        canonical = posixpath.normpath(posixpath.join(cwd, path))
+        if canonical in files:
+            return
+        # Providers might report only a suffix for a fully parsed operand.
+        # Resolve that suffix only when it identifies exactly one file.
+        matches = [known for known in files if known.endswith('/' + posixpath.normpath(path))]
+        if not posixpath.isabs(path) and len(matches) == 1:
+            return
+        add(path, 'read', True)
+
+    for action in actions or ():
+        if isinstance(action, dict):
+            if action.get('path'):
+                add_action(action['path'])
+            for path in action.get('paths') or []:
+                add_action(path)
+    return source, files

meltygui/chat/images.py

@@ -0,0 +1,227 @@
+"""Inline images for the chat transcript: decode off the render thread, upload
+on it, draw fitted, HDR intact.
+
+An `ImageReference` in a message names its picture one of three ways —
+``path`` (a file), ``data`` + ``media_type`` (a base64 payload, the Claude API
+shape, also accepted nested under ``source``), or ``url`` (a data URL) — and
+`image_key` reduces any of them to one cache key. `ImageCache.entry(ref)`
+returns the picture's state: it queues a decode the first time (a worker
+thread running meltygui's `image_load`, hdr-viewer's decoder: PQ PNGs and PQ
+ICC profiles come out as linear scRGB above 1.0, everything else as sRGB8),
+uploads the decoded pixels the first time the render thread asks (GL is
+current inside a window body only), and is drawn with `draw_image` through
+imgui's draw list — an RGB16F texture in meltygui's fp16 scene, so on an HDR
+desktop the highlights present as HDR with nothing more to do, and on an
+SDR desktop they clip at white like everything else meltygui draws.
+
+Textures are few and small compared to the payloads: the cache keeps
+``keep`` of them and drops the least recently drawn beyond that.
+"""
+import base64
+import hashlib
+import os
+import queue
+import threading
+import time
+import weakref
+
+from meltygui.chat.messages import ImageReference
+
+# The SDR reference white a PQ file is authored against (BT.2408: 203 nits);
+# dividing by it makes 1.0 = the file's SDR white = what meltygui maps to the
+# desktop's SDR white (the same mapping Chrome applies).
+PQ_SDR_WHITE = 203.0
+MEDIA_TYPES = {"image/png": ".png", "image/jpeg": ".jpg", "image/webp": ".webp", "image/gif": ".gif"}
+
+
+def _source(ref):
+    """(path, bytes-or-None) of an ImageReference, or (None, None) when it
+    carries nothing decodable. Data URLs and base64 payloads are decoded here."""
+    source = ref.get("source") if isinstance(ref.get("source"), dict) else ref
+    path = source.get("path") or ref.get("path") or source.get("savedPath")
+    if path and not str(source.get("data") or "").strip():
+        return str(path), None
+    data = source.get("data")
+    url = source.get("url") or ref.get("url") or ref.get("image_url")
+    if isinstance(url, dict):
+        url = url.get("url")
+    if not data and isinstance(url, str) and url.startswith("data:"):
+        data = url.split(",", 1)[1] if "," in url else ""
+    if isinstance(data, str) and data.strip():
+        try:
+            return None, base64.b64decode(data, validate=False)
+        except (ValueError, TypeError):
+            return None, None
+    if isinstance(url, str) and url and not url.startswith("data:") and os.path.exists(url):
+        return url, None
+    return None, None
+
+
+def image_key(ref):
+    """One stable key per picture, kept on the reference after the first call
+    (a payload is hashed once, never per frame). None: nothing to show."""
+    key = getattr(ref, "_image_key", False)
+    if key is not False:
+        return key
+    path, data = _source(ref)
+    if data is not None:
+        key = "data:" + hashlib.sha1(data).hexdigest()
+    elif path is not None:
+        try:
+            stat = os.stat(path)
+            key = f"path:{path}:{stat.st_mtime_ns}:{stat.st_size}"
+        except OSError:
+            key = "path:" + path
+    else:
+        key = None
+    try:
+        ref._image_key = key
+    except AttributeError:
+        pass
+    return key
+
+
+class Entry:
+    """One picture. ``status``: loading → ready | failed. ``size`` (w, h)
+    arrives with the decode (the layout can fit the row before the upload),
+    ``texture`` with the first draw. ``hdr``: the source was PQ."""
+
+    def __init__(self, key):
+        self.key = key
+        self.status = "loading"
+        self.size = None
+        self.texture = None
+        self.hdr = False
+        self.peak_nits = 0.0
+        self.error = None
+        self.decoded = None       # image_load.Loaded, until uploaded
+        self.last_drawn = time.monotonic()
+
+
+class ImageCache:
+    def __init__(self, keep=48, wake=None):
+        self.entries = {}
+        self.keep = keep
+        self.wake = wake             # called on the worker thread every decode: ask for a frame
+        self.jobs = queue.Queue()
+        self.worker = None
+        self.lock = threading.Lock()
+        self.views = weakref.WeakValueDictionary()
+        self.generation = 0          # bumped when a decode finishes, layouts keyed on it re-fit
+
+    def watch(self, draw_state):
+        if callable(getattr(draw_state, "invalidate_up", None)):
+            self.views[id(draw_state)] = draw_state
+
+    def decoded_changed(self):
+        self.generation += 1
+        for view in list(self.views.values()):
+            view.invalidate_up()
+        if self.wake is not None:
+            self.wake()
+
+    def entry(self, ref):
+        key = image_key(ref)
+        if key is None:
+            return None
+        entry = self.entries.get(key)
+        if entry is None:
+            entry = self.entries[key] = Entry(key)
+            self.jobs.put((entry, ref))
+            self._ensure_worker()
+        return entry
+
+    def _ensure_worker(self):
+        if self.worker is None or not self.worker.is_alive():
+            self.worker = threading.Thread(target=self._work, daemon=True, name="chat-images")
+            self.worker.start()
+
+    def _work(self):
+        while True:
+            try:
+                entry, ref = self.jobs.get(timeout=30)
+            except queue.Empty:
+                return
+            try:
+                import meltygui.image_load as image_load
+                path, data = _source(ref)
+                loaded = (image_load.load_bytes(data, PQ_SDR_WHITE) if data is not None
+                          else image_load.load(path, PQ_SDR_WHITE))
+                with self.lock:
+                    entry.decoded, entry.size = loaded, loaded.size
+                    entry.hdr, entry.peak_nits = loaded.hdr, loaded.peak_nits
+                    entry.status = "ready"
+            except Exception as error:
+                entry.error = f"{type(error).__name__}: {error}"
+                entry.status = "failed"
+            self.decoded_changed()
+
+    # -- render-only -------------------------------------------------------
+
+    def texture(self, entry):
+        """The GL texture of a decoded entry, uploaded on first use (call
+        inside a window body: GL is current there). None until decoded."""
+        if entry.texture is None and entry.decoded is not None:
+            with self.lock:
+                loaded, entry.decoded = entry.decoded, None
+            entry.texture = upload_texture(loaded)
+            self._evict()
+        entry.last_drawn = time.monotonic()
+        return entry.texture
+
+    def _evict(self):
+        uploaded = [e for e in self.entries.values() if e.texture is not None]
+        if len(uploaded) <= self.keep:
+            return
+        import OpenGL.GL as gl
+        for entry in sorted(uploaded, key=lambda e: e.last_drawn)[:len(uploaded) - self.keep]:
+            gl.glDeleteTextures(1, [entry.texture])
+            del self.entries[entry.key]
+
+
+def upload_texture(image):
+    """image_load.Loaded -> GL texture id, row 0 of the array at v = 0 (draw
+    with uv (0, 0) → (1, 1) for the top of the picture at the top). Linear
+    float goes up as RGB16F, an opaque 8-bit sRGB source as SRGB8 (the GPU
+    linearises it on sample)."""
+    import numpy as np
+    import OpenGL.GL as gl
+    w, h = image.size
+    tex = int(gl.glGenTextures(1))
+    previous = gl.glGetIntegerv(gl.GL_TEXTURE_BINDING_2D)
+    gl.glBindTexture(gl.GL_TEXTURE_2D, tex)
+    gl.glPixelStorei(gl.GL_UNPACK_ALIGNMENT, 1)
+    if image.srgb8 is not None:
+        gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_SRGB8, w, h, 0, gl.GL_RGB, gl.GL_UNSIGNED_BYTE,
+                        np.ascontiguousarray(image.srgb8))
+    else:
+        gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB16F, w, h, 0, gl.GL_RGB, gl.GL_FLOAT,
+                        np.ascontiguousarray(image.rgb, dtype=np.float32))
+    for p, v in ((gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR), (gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR),
+                 (gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_EDGE), (gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_EDGE)):
+        gl.glTexParameteri(gl.GL_TEXTURE_2D, p, v)
+    gl.glBindTexture(gl.GL_TEXTURE_2D, int(previous))
+    return tex
+
+
+def fitted_size(size, max_width, max_height):
+    """The picture's (w, h) inside the box, never upscaled."""
+    w, h = size
+    if w <= 0 or h <= 0:
+        return max_width, max_height
+    scale = min(1.0, max_width / w, max_height / h)
+    return max(1.0, w * scale), max(1.0, h * scale)
+
+
+def image_label(ref, entry=None):
+    """The caption under a picture: its name, size and HDR peak when known."""
+    name = ref.get("name") or ref.get("path") or ""
+    if isinstance(ref.get("source"), dict):
+        name = name or ref["source"].get("path") or ""
+    name = os.path.basename(str(name)) if name else ""
+    parts = [part for part in (name,) if part]
+    if entry is not None and entry.size:
+        parts.append("%d×%d" % entry.size)
+        if entry.hdr:
+            parts.append(f"HDR, peak {entry.peak_nits:.0f} nits")
+    return " · ".join(parts)