meshcode 2.11.166__tar.gz → 2.11.168__tar.gz

{meshcode-2.11.166 → meshcode-2.11.168}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.166
+Version: 2.11.168
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT

{meshcode-2.11.166 → meshcode-2.11.168}/meshcode/__init__.py

@@ -1,5 +1,5 @@
 """MeshCode — Real-time communication between AI agents."""
-__version__ = "2.11.166"
+__version__ = "2.11.168"
 
 # Exception hierarchy — eagerly imported (lightweight, no deps)
 from meshcode.exceptions import (  # noqa: F401

{meshcode-2.11.166 → meshcode-2.11.168}/meshcode/comms_v4.py

@@ -3603,6 +3603,36 @@ if __name__ == "__main__":
         autonomous_env = (os.environ.get("MESHCODE_AUTONOMOUS", "").strip().lower()
                           in ("1", "true", "yes", "on"))
         autonomous = bool(flags.get("autonomous")) or autonomous_env
+        # SELF-BUMP-BEFORE-SPAWN (task 36fe573d ext, Samuel 2026-07-02): a human typing
+        # `meshcode run` must land on the LATEST meshcode WITHOUT ever updating by hand —
+        # "meshcode se debe actualizar solo, its the whole point". The CC-autoupdate +
+        # settings.json model-pin-strip fixes live in newer meshcode; a user stuck on an
+        # old CLI (e.g. 2.11.144) would never receive them (chicken-egg). hostd already
+        # runs `meshcode self-upgrade` as a launch pre-step, but a DIRECT human
+        # `meshcode run/go` went straight to spawn and skipped it — this closes that gap.
+        #
+        # Reuses the deferral-safe blocking updater (self_update.check_and_maybe_update_blocking,
+        # force=False): version-check-first + idempotent ("already latest" -> no-op), NEVER
+        # raises (offline/PyPI-fail -> stays on installed), DEFERS when a live agent serve
+        # shares this env (never clobbers a running MCP — the class#2-clobber guard), and
+        # honors the MESHCODE_NO_UPDATE=1 / --no-update opt-out. On a REAL upgrade the OLD
+        # code is already imported in-process, so we RE-EXEC the same argv under the fresh
+        # interpreter/site so THIS spawn runs the new launcher (versioned-env spawn-latest +
+        # CC-autoupdate + pin-strip). The _MESHCODE_SELF_BUMPED sentinel makes the re-exec
+        # one-shot (no loop; the post-exec run is already latest anyway). Skipped on --dry-run.
+        if not dry_run and not os.environ.get("_MESHCODE_SELF_BUMPED"):
+            try:
+                import importlib as _il
+                _su = _il.import_module("meshcode.self_update")
+                _bumped = _su.check_and_maybe_update_blocking(verbose=True, force=False)
+                if _bumped:
+                    print(f"[meshcode] re-exec under meshcode {_bumped} (self-bump) ...",
+                          file=sys.stderr)
+                    os.environ["_MESHCODE_SELF_BUMPED"] = str(_bumped)
+                    os.execv(sys.executable,
+                             [sys.executable, "-m", "meshcode"] + sys.argv[1:])
+            except Exception as _sbe:
+                print(f"[meshcode] self-bump skipped: {_sbe}", file=sys.stderr)
         import importlib
         _run = importlib.import_module("meshcode.run_agent").run
         sys.exit(_run(agent, project=proj_override, editor_override=editor_override, permission_override=perm_override, dry_run=dry_run, autonomous=autonomous, repo_path=repo_override))

{meshcode-2.11.166 → meshcode-2.11.168}/meshcode/run_agent.py

@@ -932,6 +932,44 @@ def _preflight_hb_enabled() -> bool:
     return os.environ.get("MESHCODE_HOSTD_SPAWN") != "1"
 
 
+def _terminal_mirror_enabled() -> bool:
+    """M1 (d1720f2a): whether to wrap the editor under the terminal-mirror PTY
+    runner so the agent's REAL terminal streams to the owner dashboard
+    (mc_terminal_frame_push, mig 674). POSIX-only; Windows has no pty.fork().
+    Instant fleet-wide kill-switch: MESHCODE_TERMINAL_MIRROR=0."""
+    if sys.platform == "win32":
+        return False
+    v = (os.environ.get("MESHCODE_TERMINAL_MIRROR", "1") or "").strip().lower()
+    return v not in ("0", "false", "no", "off")
+
+
+def _maybe_exec_under_terminal_mirror(cmd, agent: str, project: str) -> None:
+    """If the terminal mirror is enabled, REPLACE this process with the PTY
+    runner that execs `cmd` and tees its terminal to the dashboard. Returns
+    normally (no-op) when disabled/unavailable so the caller's plain os.execvp
+    runs unchanged. FAIL-OPEN: the mirror must NEVER break or block a launch
+    (storm RC e4eda167) — any error here just returns and the editor launches
+    directly. The runner self-resolves api_key (keychain) + project_id
+    (mc_resolve_project); we only hand it the non-secret agent/project names."""
+    try:
+        if not _terminal_mirror_enabled():
+            return
+        runner = os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                              "terminal_mirror_runner.py")
+        if not os.path.exists(runner):
+            return
+        os.environ.setdefault("MESHCODE_AGENT", agent)
+        os.environ.setdefault("MESHCODE_PROJECT", project)
+        sys.stdout.flush()
+        sys.stderr.flush()
+        os.execvp(sys.executable, [sys.executable, runner, "--", *cmd])
+    except Exception as e:  # noqa: BLE001 — fall through to the caller's execvp
+        print(f"[meshcode]   terminal-mirror wrap skipped: {e}", file=sys.stderr)
+        return
+
+
+
+
 def _report_launch_failure(agent: str, project: str, reason: str, detail: str,
                            status: str = "offline") -> None:
     """Editor spawn failed AFTER the pre-flight heartbeat already marked the
@@ -1680,7 +1718,28 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
             _settings_model = None
             _sp = ws / ".claude" / "settings.json"
             if _sp.exists():
-                _settings_model = (json.loads(_sp.read_text(encoding="utf-8")) or {}).get("model")
+                _sj = json.loads(_sp.read_text(encoding="utf-8")) or {}
+                _settings_model = _sj.get("model")
+                # DASHBOARD-MODEL-WINS (task 36fe573d, Samuel 2026-07-02): older meshcode
+                # versions auto-pinned "model": PLATFORM_DEFAULT_MODEL into every workspace
+                # settings.json. That legacy pin short-circuits the mc_agent_model_pref RPC
+                # below, so the dashboard model dropdown (Fable 5, etc.) NEVER takes effect.
+                # Current _meshcode_settings_dict() no longer writes it, but existing
+                # workspaces keep the stale key forever (_heal_settings_hooks only touches
+                # hooks). Strip it here ONLY when it equals the platform default (i.e. the
+                # auto-written value) so a human-chosen NON-default model is preserved.
+                # Net effect: dashboard pref becomes authoritative; if there is no pref,
+                # PLATFORM_DEFAULT_MODEL is re-applied a few lines below -> same model, no
+                # regression. Idempotent: after the first launch the key is gone.
+                if _settings_model == PLATFORM_DEFAULT_MODEL:
+                    _sj.pop("model", None)
+                    try:
+                        _sp.write_text(json.dumps(_sj, indent=2) + "\n", encoding="utf-8")
+                    except Exception:
+                        pass
+                    _settings_model = None
+                    print("[meshcode]   Stripped legacy settings.json model pin "
+                          "-> dashboard model_pref is now authoritative", file=sys.stderr)
             if not _settings_model:
                 _mcp_cfg = json.loads(mcp_json_path.read_text(encoding="utf-8"))
                 _env = (next(iter((_mcp_cfg.get("mcpServers") or {}).values()), {}) or {}).get("env", {}) or {}
@@ -1906,7 +1965,13 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
                 _rc = 0
             sys.exit(_rc)
         else:
-            # Unix: replace this process with the editor
+            # Unix: replace this process with the editor.
+            # M1 (d1720f2a): when the terminal mirror is enabled, first exec a
+            # thin PTY wrapper that tees the editor's REAL terminal to the owner
+            # dashboard (mc_terminal_frame_push, mig 674). FAIL-OPEN — if the
+            # wrap is disabled or fails for any reason this returns and the
+            # original execvp below runs unchanged (launch is never blocked).
+            _maybe_exec_under_terminal_mirror(cmd, agent, resolved_project)
             os.execvp(cmd[0], cmd)
     except FileNotFoundError:
         print(f"[meshcode] ERROR: '{editor}' not found in PATH", file=sys.stderr)

meshcode-2.11.168/meshcode/terminal_mirror_runner.py

@@ -0,0 +1,478 @@
+#!/usr/bin/env python3
+"""terminal_mirror_runner.py — PRODUCT integration of the terminal mirror (task M1 d1720f2a).
+
+Wraps the agent's editor (Claude Code TUI) under a PTY so EVERY hostd/manually
+launched agent streams its REAL terminal to the owner's dashboard via the
+existing SECDEF RPC `mc_terminal_frame_push` (mig 674). This is the missing
+link: the PoC relay (terminal_mirror_relay.py, task eacea0d8) + the DB channel
+both shipped, but nothing ever invoked the relay on the real launch path, so
+0 frames were pushed in 7 days and every user saw an empty "Live terminal".
+
+WHAT IT DOES
+  - pty.fork(): the child execs the editor command and owns the slave PTY as
+    its controlling tty (a TUI like Claude Code renders correctly).
+  - The parent is a transparent relay: it tees the child's output to the real
+    terminal (so the human sees exactly what they see today) AND into a
+    coalesced ring buffer that is redacted then pushed as frames.
+  - LOCAL interactivity is preserved: the human's keystrokes (stdin) are
+    forwarded to the child, and window-resize (SIGWINCH) is propagated to the
+    PTY so the TUI reflows. This is NOT the M2 remote-write path — it only
+    keeps today's local typing working.
+
+SECURITY (Samuel hard rule, commander msg 210f541a — same posture as the PoC)
+  - Redaction happens HERE, before any network egress (primary filter); the RPC
+    re-scrubs server-side via _mc_scrub_terminal (defense-in-depth, mig 674).
+  - FAIL-CLOSED redaction: if redaction raises, the frame is replaced with an
+    error marker — un-redacted bytes are NEVER egressed.
+  - Transport = owner-scoped: frames land in mc_terminal_frames (RLS owner-read)
+    and reach ONLY the project owner's JWT. Never anon/public, never cross-mesh.
+  - The agent api_key is the credential (verified inside the SECDEF RPC); it is
+    resolved locally from the keychain and string-redacted from every frame.
+  - READ-ONLY w.r.t. the dashboard: there is NO path here for a remote party to
+    inject input into the child. (That is M2 780b6b0f, owner-gated + audited,
+    shipped separately after commander security sign-off.)
+
+RELIABILITY — FAIL-OPEN (critical, given the storm RC e4eda167)
+  - The mirror must NEVER break or slow an agent launch. On ANY setup failure
+    (no tty, missing identity, import error, pty failure) the runner falls back
+    to a transparent `os.execvp` of the editor — identical to today's behavior.
+  - Pushes are async on a bounded drop-oldest queue, so a slow/offline network
+    can never stall the TUI.
+  - Diagnostics go to a logfile (~/.meshcode/logs/), never to the tty (which
+    would both corrupt the TUI and get captured back into frames).
+
+ENABLE / KILL-SWITCH
+  MESHCODE_TERMINAL_MIRROR=0  -> disable (instant fleet-wide kill, no re-release).
+  Default = on (POSIX only). Windows has no pty.fork(); it always passes through.
+
+USAGE (invoked by run_agent.py; not meant to be called by hand)
+  MESHCODE_AGENT=<name> MESHCODE_PROJECT=<mesh> \\
+    python3 terminal_mirror_runner.py -- <editor> [args...]
+"""
+from __future__ import annotations
+
+import os
+import sys
+import re
+import json
+import time
+import errno
+import struct
+import select
+import signal
+import threading
+import queue as _queue
+
+# --- tunables (env-overridable) ------------------------------------------------
+FLUSH_MS = int(os.environ.get("MIRROR_FLUSH_MS", "1000"))          # coalesce window (~1-2s per task)
+MAX_FRAME_BYTES = int(os.environ.get("MIRROR_MAX_FRAME_BYTES", "16384"))  # force-flush cap
+READ_CHUNK = 65536
+QUEUE_MAX = 64                                                     # bounded; drop-oldest on overflow
+INPUT_POLL_MS = int(os.environ.get("MIRROR_INPUT_POLL_MS", "500")) # M2 remote-stdin poll cadence
+
+
+def _enabled() -> bool:
+    if sys.platform == "win32":
+        return False
+    v = os.environ.get("MESHCODE_TERMINAL_MIRROR", "1").strip().lower()
+    return v not in ("0", "false", "no", "off")
+
+
+def _input_pull_enabled() -> bool:
+    """M2 remote-stdin WRITE path (task 780b6b0f). DEFAULT OFF — this is the
+    owner-types-into-the-agent's-terminal seam, which is effectively code-exec on
+    the agent box, so it stays dark until the commander's post-canary FE-exposure
+    GO. The DB owner-only ACL (mig 687) already gates WHO may enqueue input; this
+    flag gates whether THIS runner drains+applies it at all. Opt-IN only."""
+    if sys.platform == "win32":
+        return False
+    v = os.environ.get("MESHCODE_TERMINAL_INPUT", "0").strip().lower()
+    return v in ("1", "true", "yes", "on")
+
+
+def _log(msg: str) -> None:
+    """Best-effort diagnostics to a file — NEVER to the tty (would corrupt the
+    TUI and get mirrored back into frames)."""
+    try:
+        d = os.path.expanduser("~/.meshcode/logs")
+        os.makedirs(d, exist_ok=True)
+        agent = os.environ.get("MESHCODE_AGENT", "agent")
+        with open(os.path.join(d, f"terminal_mirror_{agent}.log"), "a", encoding="utf-8") as fh:
+            fh.write(f"{time.strftime('%Y-%m-%dT%H:%M:%S')} {msg}\n")
+    except Exception:
+        pass
+
+
+# --- redaction: EXACT mirror of the PoC chain (_mc_scrub_pii THEN _mc_scrub_terminal,
+#     migs 674/674b/674c). The runner is the PRIMARY pre-egress filter, so it must be at
+#     least as strong as the DB net. Same order as the SQL. -------------------------------
+_PATTERNS = [
+    # ---- _mc_scrub_pii layer (runs first in the DB) ----
+    (re.compile(r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}"), "<id>"),
+    (re.compile(r"/Users/[^/\s]+/[^\s]*"), "<path>"),
+    (re.compile(r"/home/[^/\s]+/[^\s]*"), "<path>"),
+    (re.compile(r"(?i)bearer\s+\S+"), "bearer <token>"),
+    # ---- _mc_scrub_terminal layer ----
+    (re.compile(r"-----BEGIN[A-Z ]*PRIVATE KEY-----[\s\S]*?-----END[A-Z ]*PRIVATE KEY-----"), "<redacted:pem>"),
+    (re.compile(r"ya29\.[0-9A-Za-z_-]{10,}"), "<redacted:google_oauth>"),
+    (re.compile(r"xox[baprs]-[0-9A-Za-z-]{10,}"), "<redacted:slack>"),
+    (re.compile(r"([a-zA-Z][a-zA-Z0-9+.-]*://)[^/\s:@]+:[^/\s@]+@"), r"\1<redacted>@"),
+    (re.compile(r"sk-[A-Za-z0-9_-]{20,}"), "<redacted:key>"),
+    (re.compile(r"eyJ[A-Za-z0-9._-]{20,}"), "<redacted:jwt>"),
+    (re.compile(r"sb_secret_[A-Za-z0-9_-]{10,}"), "<redacted:sb_secret>"),
+    (re.compile(r"sbp_[A-Za-z0-9]{20,}"), "<redacted:sbp_pat>"),
+    (re.compile(r"(ghp|gho|ghu|ghs|ghr|github_pat)_[A-Za-z0-9_]{20,}"), "<redacted:github>"),
+    (re.compile(r"pypi-[A-Za-z0-9_-]{20,}"), "<redacted:pypi>"),
+    (re.compile(r"AKIA[0-9A-Z]{16}"), "<redacted:aws>"),
+    (re.compile(r"mc_[A-Za-z0-9]{20,}"), "<redacted:mc_key>"),
+    (re.compile(r"(?i)\b((?:MESHCODE|SUPABASE|AWS|GOOGLE|ANTHROPIC|OPENAI|RESEND)_[A-Z0-9_]+)(\s*[=:]\s*)\S+"),
+     r"\1\2<redacted>"),
+    (re.compile(r"(?i)\b([A-Za-z0-9_]*(?:KEY|TOKEN|SECRET|PAT|PASSWORD|PASSWD))(\s*[=:]\s*)\S+"),
+     r"\1\2<redacted>"),
+    (re.compile(r"(?i)(password|passwd|secret|api[_-]?key|token)(\s*[=:]\s*)\S+"), r"\1\2<redacted>"),
+]
+
+
+def _make_redactor(api_key: str):
+    def redact(s: str) -> str:
+        for pat, repl in _PATTERNS:
+            s = pat.sub(repl, s)
+        if api_key and len(api_key) > 6:
+            s = s.replace(api_key, "<redacted:self_key>")
+        return s
+    return redact
+
+
+# --- identity / supabase resolution (self-sufficient; fail-open) ---------------
+def _resolve_context():
+    """Return (supabase_url, anon, api_key, project_id, agent) or None on any
+    failure (-> caller passes through to a plain exec)."""
+    agent = os.environ.get("MESHCODE_AGENT") or ""
+    project = os.environ.get("MESHCODE_PROJECT") or ""
+    if not agent or not project:
+        return None
+    try:
+        from meshcode.setup_clients import _load_supabase_env
+        import meshcode.secrets as _secrets
+        import urllib.request as _u
+        sb = _load_supabase_env()
+        url = sb["SUPABASE_URL"].rstrip("/")
+        anon = sb["SUPABASE_KEY"]
+        profile = os.environ.get("MESHCODE_KEYCHAIN_PROFILE") or "default"
+        api_key = os.environ.get("MESHCODE_API_KEY") or _secrets.get_api_key(profile=profile)
+        if not api_key:
+            return None
+        req = _u.Request(
+            f"{url}/rest/v1/rpc/mc_resolve_project",
+            data=json.dumps({"p_api_key": api_key, "p_project_name": project}).encode(),
+            method="POST",
+            headers={"apikey": anon, "Authorization": f"Bearer {anon}",
+                     "Content-Type": "application/json", "Content-Profile": "meshcode"},
+        )
+        with _u.urlopen(req, timeout=6) as resp:
+            proj = json.loads(resp.read().decode() or "null") or {}
+        project_id = proj.get("project_id")
+        if not project_id:
+            return None
+        return (url, anon, api_key, project_id, agent)
+    except Exception as e:  # noqa: BLE001
+        _log(f"context resolve failed (passthrough): {type(e).__name__}: {e}")
+        return None
+
+
+# --- winsize plumbing ----------------------------------------------------------
+def _get_winsize(fd: int):
+    try:
+        import fcntl, termios
+        data = fcntl.ioctl(fd, termios.TIOCGWINSZ, b"\x00" * 8)
+        rows, cols, xp, yp = struct.unpack("HHHH", data)
+        return rows, cols, xp, yp
+    except Exception:
+        return (24, 80, 0, 0)
+
+
+def _set_winsize(master_fd: int, dims) -> None:
+    try:
+        import fcntl, termios
+        fcntl.ioctl(master_fd, termios.TIOCSWINSZ, struct.pack("HHHH", *dims))
+    except Exception:
+        pass
+
+
+# --- async, bounded, drop-oldest frame sender ----------------------------------
+def _start_sender(url, anon, api_key, project_id, agent, redactor):
+    q: "_queue.Queue" = _queue.Queue(maxsize=QUEUE_MAX)
+    import urllib.request as _u
+
+    def _push(seq: int, chunk: str):
+        try:
+            body = json.dumps({
+                "p_api_key": api_key, "p_project_id": project_id,
+                "p_agent": agent, "p_seq": seq, "p_chunk": chunk,
+            }).encode("utf-8")
+            req = _u.Request(
+                f"{url}/rest/v1/rpc/mc_terminal_frame_push", data=body, method="POST",
+                headers={"Content-Type": "application/json",
+                         "apikey": anon, "Authorization": f"Bearer {anon}"},
+            )
+            with _u.urlopen(req, timeout=10) as r:
+                r.read()
+        except Exception as e:  # noqa: BLE001
+            _log(f"push seq={seq} err: {type(e).__name__}: {e}")
+
+    def _worker():
+        while True:
+            item = q.get()
+            if item is None:
+                return
+            seq, chunk = item
+            _push(seq, chunk)
+
+    t = threading.Thread(target=_worker, name="mirror-sender", daemon=True)
+    t.start()
+
+    def enqueue(seq: int, raw: str):
+        try:
+            clean = redactor(raw)
+        except Exception as e:  # noqa: BLE001 — FAIL-CLOSED: never egress raw bytes
+            clean = f"<redaction-error: {type(e).__name__}; frame dropped>"
+        try:
+            q.put_nowait((seq, clean))
+        except _queue.Full:
+            # drop-oldest: a mirror may shed intermediate frames; the TUI repaints fully.
+            try:
+                q.get_nowait()
+                q.put_nowait((seq, clean))
+            except Exception:
+                pass
+
+    def stop():
+        try:
+            q.put_nowait(None)
+        except Exception:
+            pass
+        t.join(timeout=2.0)
+
+    return enqueue, stop
+
+
+# --- M2 remote-stdin puller (gated OFF by default; task 780b6b0f) --------------
+def _start_input_puller(url, anon, api_key, project_id, agent, master_fd):
+    """Periodically drain the owner-authored stdin channel and apply it to the
+    child's PTY master fd (== type into the agent's real terminal).
+
+    SECURITY POSTURE (why this is safe to STAGE but stays OFF):
+      * GATE 1 (this runner): _input_pull_enabled() default OFF — no drain, no
+        write, unless an operator explicitly opts in. Caller already checked it.
+      * GATE 2 (DB, mig 687): mc_terminal_input_pull is api-key gated and a SCOPED
+        agent key can drain ONLY its own agent's queue; the writer side
+        (mc_terminal_input_push) is OWNER-ONLY (members excluded). So even with
+        this seam live, only the project owner can author bytes that land here.
+      * CONSUME-ONCE: the RPC DELETEs as it returns; bytes are applied LITERALLY
+        (NOT redacted — the owner may be pasting a real token into a prompt) and
+        never persisted by the runner.
+      * FAIL-OPEN: any pull/parse/write error is logged and swallowed; the seam
+        can never break or stall the TUI (runs on its own daemon thread; the tee
+        loop is untouched).
+    Returns a stop() callable.
+    """
+    import urllib.request as _u
+    stop_evt = threading.Event()
+
+    def _pull_once():
+        body = json.dumps({
+            "p_api_key": api_key, "p_project_id": project_id, "p_agent": agent,
+        }).encode("utf-8")
+        req = _u.Request(
+            f"{url}/rest/v1/rpc/mc_terminal_input_pull", data=body, method="POST",
+            headers={"Content-Type": "application/json",
+                     "apikey": anon, "Authorization": f"Bearer {anon}"},
+        )
+        with _u.urlopen(req, timeout=10) as r:
+            res = json.loads(r.read().decode() or "null") or {}
+        if not res.get("ok"):
+            return
+        for item in (res.get("inputs") or []):
+            data = item.get("data")
+            if not data:
+                continue
+            try:
+                os.write(master_fd, data.encode("utf-8"))  # LITERAL bytes -> child stdin
+            except OSError as e:
+                _log(f"input apply err: {type(e).__name__}: {e}")
+
+    def _worker():
+        interval = INPUT_POLL_MS / 1000.0
+        while not stop_evt.wait(interval):
+            try:
+                _pull_once()
+            except Exception as e:  # noqa: BLE001 — FAIL-OPEN: never break the TUI
+                _log(f"input pull err (continuing): {type(e).__name__}: {e}")
+
+    t = threading.Thread(target=_worker, name="mirror-input-puller", daemon=True)
+    t.start()
+
+    def stop():
+        stop_evt.set()
+        t.join(timeout=2.0)
+
+    return stop
+
+
+def _passthrough_exec(cmd):
+    """Transparent fallback — identical to run_agent.py's original Unix path."""
+    os.execvp(cmd[0], cmd)
+
+
+def main(argv) -> int:
+    if "--" in argv:
+        cmd = argv[argv.index("--") + 1:]
+    else:
+        cmd = argv[1:]
+    if not cmd:
+        sys.stderr.write("[mirror] no command to run\n")
+        return 2
+
+    if not _enabled():
+        _passthrough_exec(cmd)
+        return 127  # unreachable if execvp succeeds
+
+    ctx = _resolve_context()
+    if ctx is None:
+        _passthrough_exec(cmd)
+        return 127
+    url, anon, api_key, project_id, agent = ctx
+
+    import pty
+    try:
+        pid, master = pty.fork()
+    except Exception as e:  # noqa: BLE001 — pty unavailable -> never break the launch
+        _log(f"pty.fork failed (passthrough): {type(e).__name__}: {e}")
+        _passthrough_exec(cmd)
+        return 127
+
+    if pid == 0:  # child: becomes the editor; owns the slave PTY as controlling tty
+        try:
+            os.execvp(cmd[0], cmd)
+        except Exception:
+            os._exit(127)
+
+    # ---- parent: transparent relay ----
+    redactor = _make_redactor(api_key)
+    enqueue, stop_sender = _start_sender(url, anon, api_key, project_id, agent, redactor)
+
+    # M2 remote-stdin seam — DARK by default. Only spun up when explicitly opted
+    # in (MESHCODE_TERMINAL_INPUT=1); otherwise no drain thread exists at all.
+    stop_input_puller = None
+    if _input_pull_enabled():
+        try:
+            stop_input_puller = _start_input_puller(url, anon, api_key, project_id, agent, master)
+            _log("M2 remote-stdin puller ENABLED")
+        except Exception as e:  # noqa: BLE001 — never break launch on the optional seam
+            _log(f"input puller start failed (continuing read-only): {type(e).__name__}: {e}")
+            stop_input_puller = None
+
+    out_fd = 1
+    in_fd = 0
+    # propagate the real terminal size to the PTY so the TUI renders correctly
+    _set_winsize(master, _get_winsize(out_fd))
+
+    def _on_winch(signum, frame):
+        _set_winsize(master, _get_winsize(out_fd))
+    try:
+        signal.signal(signal.SIGWINCH, _on_winch)
+    except Exception:
+        pass
+
+    saved_attrs = None
+    try:
+        import termios, tty
+        if os.isatty(in_fd):
+            saved_attrs = termios.tcgetattr(in_fd)
+            tty.setraw(in_fd)
+    except Exception:
+        saved_attrs = None
+
+    # seq seeded from epoch-ms => monotonic per agent ACROSS restarts (next run's
+    # seed > all prior frames), satisfying the per-(project,agent) ordering contract.
+    seq = int(time.time() * 1000)
+    buf = bytearray()
+    last_flush = time.monotonic()
+
+    def flush():
+        nonlocal seq, buf, last_flush
+        if buf:
+            enqueue(seq, bytes(buf).decode("utf-8", "replace"))
+            seq += 1
+            buf = bytearray()
+        last_flush = time.monotonic()
+
+    watch = [master, in_fd] if os.isatty(in_fd) else [master]
+    try:
+        while True:
+            timeout = FLUSH_MS / 1000.0
+            try:
+                r, _, _ = select.select(watch, [], [], timeout)
+            except (select.error, OSError) as e:
+                if getattr(e, "errno", None) == errno.EINTR:
+                    continue  # interrupted by SIGWINCH — re-arm
+                raise
+            if master in r:
+                try:
+                    data = os.read(master, READ_CHUNK)
+                except OSError:
+                    data = b""
+                if not data:
+                    break  # child exited / PTY closed
+                buf += data
+                try:
+                    os.write(out_fd, data)  # tee: the human's terminal is unaffected
+                except OSError:
+                    pass
+                if len(buf) >= MAX_FRAME_BYTES:
+                    flush()
+            # LOCAL stdin forwarding — preserves today's interactivity (NOT the
+            # gated M2 remote-write path).
+            if in_fd in r:
+                try:
+                    inp = os.read(in_fd, READ_CHUNK)
+                except OSError:
+                    inp = b""
+                if inp:
+                    try:
+                        os.write(master, inp)
+                    except OSError:
+                        pass
+            if (time.monotonic() - last_flush) * 1000 >= FLUSH_MS:
+                flush()
+        flush()
+    finally:
+        if saved_attrs is not None:
+            try:
+                import termios
+                termios.tcsetattr(in_fd, termios.TCSADRAIN, saved_attrs)
+            except Exception:
+                pass
+        if stop_input_puller is not None:
+            try:
+                stop_input_puller()
+            except Exception:
+                pass
+        stop_sender()
+
+    # propagate the child's exit status as our own
+    status = 0
+    try:
+        _, status = os.waitpid(pid, 0)
+    except Exception:
+        pass
+    if os.WIFSIGNALED(status):
+        return 128 + os.WTERMSIG(status)
+    return os.WEXITSTATUS(status)
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main(sys.argv))
+    except KeyboardInterrupt:
+        sys.exit(130)

{meshcode-2.11.166 → meshcode-2.11.168}/meshcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.166
+Version: 2.11.168
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT

{meshcode-2.11.166 → meshcode-2.11.168}/meshcode.egg-info/SOURCES.txt

@@ -32,6 +32,7 @@ meshcode/secrets.py
 meshcode/self_update.py
 meshcode/setup_clients.py
 meshcode/supervisor.py
+meshcode/terminal_mirror_runner.py
 meshcode/up.py
 meshcode/upload.py
 meshcode.egg-info/PKG-INFO

{meshcode-2.11.166 → meshcode-2.11.168}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "meshcode"
-version = "2.11.166"
+version = "2.11.168"
 description = "Real-time communication between AI agents — Supabase-backed CLI"
 readme = "README.md"
 license = {text = "MIT"}