@team-agent/installer 0.1.11 → 0.2.0

package/src/team_agent/messaging/tmux_io.py

@@ -0,0 +1,337 @@
+from __future__ import annotations
+
+from team_agent.messaging.deps import (
+    TMUX_PASTE_BYTES_PER_SECOND,
+    TMUX_PASTE_MAX_READY_TIMEOUT,
+    TMUX_PASTE_MIN_READY_TIMEOUT,
+    TMUX_STDIN_BUFFER_THRESHOLD,
+    TMUX_SUBMIT_BYTES_PER_SECOND,
+    TMUX_SUBMIT_MAX_SETTLE_TIMEOUT,
+    TMUX_SUBMIT_MIN_SETTLE_TIMEOUT,
+    _capture_tmux_pane_text,
+    _tmux_load_buffer_stdin as _runtime_tmux_load_buffer_stdin,
+    _submit_worker_prompt,
+    _wait_for_message_ready,
+    re,
+    run_cmd,
+    subprocess,
+    time,
+)
+
+from pathlib import Path
+from typing import Any
+
+def _tmux_inject_text(
+    target: str,
+    text: str,
+    submit_key: str,
+    buffer_name: str,
+    attempts: int = 3,
+    provider: str = "fake",
+) -> dict[str, Any]:
+    token_match = re.search(r"\[team-agent-token:([^\]]+)\]", text)
+    token = token_match.group(1) if token_match else ""
+    attempt_log: list[dict[str, Any]] = []
+    last_verification = "not_checked"
+    ready_timeout = _tmux_paste_ready_timeout(text)
+    submit_settle_timeout = _tmux_submit_settle_timeout(text)
+    text_bytes = _tmux_text_size(text)
+    for attempt in range(1, max(attempts, 1) + 1):
+        prepared = _prepare_tmux_pane_for_input(target)
+        if not prepared["ok"]:
+            attempt_log.append({"attempt": attempt, "visible": False, "verification": prepared["verification"]})
+            return {
+                "ok": False,
+                "stage": prepared["stage"],
+                "error": prepared.get("error"),
+                "attempts": attempt_log,
+                "verification": prepared["verification"],
+            }
+        baseline = _capture_tmux_pane_text(target)
+        if not baseline["ok"]:
+            return {
+                "ok": False,
+                "stage": "pre-paste-capture",
+                "error": baseline.get("error"),
+                "attempts": attempt_log,
+                "verification": "pre_paste_capture_failed",
+            }
+        baseline_capture = baseline["capture"]
+        buffered = _tmux_set_buffer_text(buffer_name, text)
+        if not buffered["ok"]:
+            return {"ok": False, "stage": buffered["stage"], "error": buffered.get("error"), "attempts": attempt_log}
+        proc = run_cmd(["tmux", "paste-buffer", "-t", target, "-b", buffer_name, "-p"], timeout=10)
+        deleted = _tmux_delete_buffer(buffer_name)
+        if proc.returncode != 0:
+            return {
+                "ok": False,
+                "stage": "paste-buffer",
+                "error": proc.stderr.strip(),
+                "attempts": attempt_log,
+                "buffer_deleted": deleted.get("ok"),
+                "buffer_delete_error": deleted.get("error"),
+            }
+        time.sleep(0.25)
+        if token:
+            visible, verification, capture_text = _wait_for_message_ready(
+                target,
+                token,
+                ready_timeout,
+                expected_text=text,
+                baseline_capture=baseline_capture,
+            )
+        else:
+            visible, verification, capture_text = True, "no_token", ""
+        last_verification = verification
+        attempt_entry = {
+            "attempt": attempt,
+            "visible": visible,
+            "verification": verification,
+            "buffer_method": buffered.get("method"),
+            "buffer_name": buffer_name,
+            "buffer_deleted": deleted.get("ok"),
+            "text_bytes": buffered.get("text_bytes"),
+            "ready_timeout_sec": ready_timeout,
+        }
+        if deleted.get("error"):
+            attempt_entry["buffer_delete_error"] = deleted.get("error")
+        if prepared.get("recovered_from_mode"):
+            attempt_entry["recovered_from_mode"] = True
+        attempt_log.append(attempt_entry)
+        if not visible:
+            time.sleep(0.2)
+            continue
+        submit = _submit_worker_prompt(
+            target,
+            capture_text,
+            submit_key=submit_key,
+            settle_timeout=submit_settle_timeout,
+        )
+        if not submit["ok"]:
+            return {
+                "ok": False,
+                "stage": submit.get("stage", "submit"),
+                "error": submit.get("error"),
+                "attempts": attempt_log,
+                "verification": verification,
+                "submit_verification": submit.get("verification"),
+                "submit_attempts": submit.get("attempts"),
+            }
+        submit_verification = _leader_submit_verification(submit.get("verification"), verification, submit_key)
+        turn_visible, turn_verification, turn_capture = _wait_for_leader_new_turn(
+            target,
+            text,
+            token,
+            provider=provider,
+            timeout=2.0,
+        )
+        if not turn_visible:
+            return {
+                "ok": False,
+                "stage": "turn-boundary-verification",
+                "error": f"leader turn boundary not verified: {turn_verification}",
+                "attempts": attempt_log,
+                "verification": verification,
+                "submit_verification": submit_verification,
+                "turn_verification": turn_verification,
+                "submit_attempts": submit.get("attempts"),
+            }
+        return {
+            "ok": True,
+            "stage": "submitted",
+            "visible": True,
+            "submitted": True,
+            "verification": verification,
+            "submit_verification": submit_verification,
+            "turn_verification": turn_verification,
+            "attempts": attempt_log,
+            "submit_attempts": submit.get("attempts"),
+        }
+    return {
+        "ok": False,
+        "stage": "visible-check",
+        "error": f"visible token not found after {max(attempts, 1)} attempts: {last_verification}",
+        "attempts": attempt_log,
+        "verification": last_verification,
+    }
+
+
+def _leader_submit_verification(submit_verification: str | None, verification: str, submit_key: str) -> str | None:
+    if submit_verification != "enter_sent_without_placeholder_check":
+        return submit_verification
+    if verification == "capture_contains_token":
+        return f"{submit_key}_sent_after_visible_token"
+    if verification == "capture_contains_message_fragment":
+        return f"{submit_key}_sent_after_visible_fragment"
+    return submit_verification
+
+
+def _wait_for_leader_new_turn(
+    target: str,
+    expected_text: str,
+    token: str,
+    provider: str,
+    timeout: float,
+) -> tuple[bool, str, str]:
+    deadline = time.monotonic() + max(timeout, 0.0)
+    last = "not_checked"
+    last_capture = ""
+    while True:
+        capture = _capture_tmux_pane_text(target)
+        if capture["ok"]:
+            capture_text = capture["capture"]
+            last_capture = capture_text
+            if _capture_has_leader_new_turn(capture_text, expected_text, token, provider):
+                return True, "leader_new_turn_boundary_verified", capture_text
+            last = "leader_new_turn_boundary_missing"
+        else:
+            last = f"capture_failed: {capture.get('error')}"
+        if time.monotonic() >= deadline:
+            return False, last, last_capture
+        time.sleep(0.1)
+
+
+def _capture_has_leader_new_turn(capture_text: str, expected_text: str, token: str, provider: str) -> bool:
+    if provider == "fake":
+        return True
+    lines = capture_text.splitlines()
+    marker_indexes = [index for index, line in enumerate(lines) if re.match(r"^\s*[❯›>]\s*", line)]
+    for index in marker_indexes:
+        window = "\n".join(lines[index : index + 12])
+        if token and token in window:
+            return True
+        if _leader_turn_contains_message_fragment(window, expected_text):
+            return True
+    return False
+
+
+def _leader_turn_contains_message_fragment(capture_text: str, expected_text: str) -> bool:
+    haystack = re.sub(r"\s+", "", capture_text)
+    for line in expected_text.splitlines():
+        compact = re.sub(r"\s+", "", re.sub(r"\[team-agent-token:[^\]]+\]", "", line))
+        if len(compact) >= 18 and compact in haystack:
+            return True
+    return False
+
+
+def _tmux_text_size(text: str) -> int:
+    return len(text.encode("utf-8"))
+
+
+def _tmux_paste_ready_timeout(text: str) -> float:
+    size = _tmux_text_size(text)
+    return min(
+        TMUX_PASTE_MAX_READY_TIMEOUT,
+        max(TMUX_PASTE_MIN_READY_TIMEOUT, size / TMUX_PASTE_BYTES_PER_SECOND),
+    )
+
+
+def _tmux_submit_settle_timeout(text: str) -> float:
+    size = _tmux_text_size(text)
+    return min(
+        TMUX_SUBMIT_MAX_SETTLE_TIMEOUT,
+        max(TMUX_SUBMIT_MIN_SETTLE_TIMEOUT, size / TMUX_SUBMIT_BYTES_PER_SECOND),
+    )
+
+
+def _tmux_set_buffer_text(buffer_name: str, text: str) -> dict[str, Any]:
+    size = _tmux_text_size(text)
+    if size >= TMUX_STDIN_BUFFER_THRESHOLD:
+        proc = _runtime_tmux_load_buffer_stdin(buffer_name, text)
+        return {
+            "ok": proc.returncode == 0,
+            "stage": "load-buffer",
+            "method": "stdin_load_buffer",
+            "text_bytes": size,
+            "error": proc.stderr.strip() if proc.returncode != 0 else None,
+        }
+    proc = run_cmd(["tmux", "set-buffer", "-b", buffer_name, text], timeout=10)
+    return {
+        "ok": proc.returncode == 0,
+        "stage": "set-buffer",
+        "method": "set_buffer_arg",
+        "text_bytes": size,
+        "error": proc.stderr.strip() if proc.returncode != 0 else None,
+    }
+
+
+def _tmux_delete_buffer(buffer_name: str) -> dict[str, Any]:
+    proc = run_cmd(["tmux", "delete-buffer", "-b", buffer_name], timeout=10)
+    return {
+        "ok": proc.returncode == 0,
+        "stage": "delete-buffer",
+        "error": proc.stderr.strip() if proc.returncode != 0 else None,
+    }
+
+
+def _tmux_load_buffer_stdin(buffer_name: str, text: str) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        ["tmux", "load-buffer", "-b", buffer_name, "-"],
+        input=text,
+        text=True,
+        capture_output=True,
+        timeout=10,
+        check=False,
+    )
+
+
+def _prepare_tmux_pane_for_input(target: str) -> dict[str, Any]:
+    mode = run_cmd(["tmux", "display-message", "-p", "-t", target, "#{pane_in_mode}"], timeout=5)
+    if mode.returncode != 0:
+        return {
+            "ok": False,
+            "stage": "pane-mode-check",
+            "verification": "pane_mode_check_failed",
+            "error": mode.stderr.strip() or "tmux pane mode check failed",
+        }
+    if mode.stdout.strip() != "1":
+        return {"ok": True, "verification": "pane_input_ready"}
+    cancel = run_cmd(["tmux", "send-keys", "-t", target, "-X", "cancel"], timeout=10)
+    if cancel.returncode != 0:
+        return {
+            "ok": False,
+            "stage": "pane-mode-cancel",
+            "verification": "pane_mode_cancel_failed",
+            "error": cancel.stderr.strip() or "tmux copy-mode cancel failed",
+        }
+    deadline = time.monotonic() + 1.5
+    while True:
+        check = run_cmd(["tmux", "display-message", "-p", "-t", target, "#{pane_in_mode}"], timeout=5)
+        if check.returncode != 0:
+            return {
+                "ok": False,
+                "stage": "pane-mode-check",
+                "verification": "pane_mode_recheck_failed",
+                "error": check.stderr.strip() or "tmux pane mode recheck failed",
+            }
+        if check.stdout.strip() != "1":
+            return {"ok": True, "verification": "pane_input_ready_after_mode_cancel", "recovered_from_mode": True}
+        if time.monotonic() >= deadline:
+            return {
+                "ok": False,
+                "stage": "pane-mode-cancel",
+                "verification": "pane_mode_still_active_after_cancel",
+                "error": "tmux pane stayed in copy-mode after cancel",
+            }
+        time.sleep(0.1)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

package/src/team_agent/messaging/tmux_prompt.py

@@ -0,0 +1,229 @@
+from __future__ import annotations
+
+from team_agent.messaging.deps import (
+    DELIVERY_CAPTURE_LINES,
+    PASTED_CONTENT_PROMPT_RE,
+    TMUX_SUBMIT_MIN_SETTLE_TIMEOUT,
+    re,
+    run_cmd,
+    time,
+)
+
+from pathlib import Path
+from typing import Any
+
+def _enable_codex_fast_mode(session_name: str, window_name: str) -> dict[str, Any]:
+    target = f"{session_name}:{window_name}"
+    proc = run_cmd(["tmux", "send-keys", "-t", target, "/fast", "Enter"], timeout=10)
+    if proc.returncode != 0:
+        return {"ok": False, "error": proc.stderr.strip() or "tmux send-keys failed"}
+    return {"ok": True, "target": target}
+
+
+def _wait_for_visible_token(target: str, token: str, timeout: float) -> tuple[bool, str]:
+    deadline = time.monotonic() + max(timeout, 0.0)
+    last = "not_checked"
+    while True:
+        capture = _capture_tmux_pane_text(target)
+        if capture["ok"]:
+            if token in capture["capture"] or f"[team-agent-token:{token}]" in capture["capture"]:
+                return True, "capture_contains_token"
+            last = "capture_missing_token"
+        else:
+            last = f"capture_failed: {capture.get('error')}"
+        if time.monotonic() >= deadline:
+            return False, last
+        time.sleep(0.1)
+
+
+def _capture_tmux_pane_text(target: str) -> dict[str, Any]:
+    capture = run_cmd(["tmux", "capture-pane", "-p", "-S", f"-{DELIVERY_CAPTURE_LINES}", "-t", target], timeout=5)
+    if capture.returncode != 0:
+        return {"ok": False, "capture": "", "error": capture.stderr.strip() or "tmux capture-pane failed"}
+    return {"ok": True, "capture": capture.stdout}
+
+
+def _wait_for_message_ready(
+    target: str,
+    message_id: str,
+    timeout: float,
+    expected_text: str = "",
+    allow_pasted_prompt: bool = True,
+    baseline_capture: str = "",
+) -> tuple[bool, str, str]:
+    deadline = time.monotonic() + max(timeout, 0.0)
+    last = "not_checked"
+    last_capture = ""
+    baseline_had_pasted_prompt = _capture_has_pasted_content_prompt(baseline_capture)
+    while True:
+        capture = _capture_tmux_pane_text(target)
+        if capture["ok"]:
+            capture_text = capture["capture"]
+            last_capture = capture_text
+            if message_id in capture_text or f"[team-agent-token:{message_id}]" in capture_text:
+                return True, "capture_contains_token", capture_text
+            if expected_text and _capture_contains_message_fragment(capture_text, expected_text):
+                return True, "capture_contains_message_fragment", capture_text
+            if allow_pasted_prompt and _capture_has_pasted_content_prompt(capture_text) and not baseline_had_pasted_prompt:
+                return True, "capture_contains_new_pasted_content_prompt", capture_text
+            last = "capture_missing_token"
+        else:
+            last = f"capture_failed: {capture.get('error')}"
+        if time.monotonic() >= deadline:
+            return False, last, last_capture
+        time.sleep(0.1)
+
+
+def _wait_for_worker_message_ready(target: str, message_id: str, timeout: float, expected_text: str = "") -> tuple[bool, str, str]:
+    return _wait_for_message_ready(target, message_id, timeout, expected_text=expected_text)
+
+
+def _capture_has_pasted_content_prompt(text: str) -> bool:
+    lines = [line.rstrip() for line in text.splitlines() if line.strip()]
+    if not lines:
+        return False
+    tail = [line.strip() for line in lines[-12:]]
+    tail_text = " ".join(tail)
+    if not PASTED_CONTENT_PROMPT_RE.search(tail_text):
+        return False
+    prompt_markers = ("›", "❯", ">")
+    if PASTED_CONTENT_PROMPT_RE.search(tail[-1]):
+        return True
+    if tail[-1].endswith(("chars]", "line]", "lines]")):
+        return True
+    if any(line.startswith(prompt_markers) for line in tail):
+        return True
+    if re.search(r"\b(codex|claude)\s*[>›❯]", tail_text, re.IGNORECASE):
+        return True
+    return False
+
+
+def _capture_contains_message_fragment(capture_text: str, expected_text: str) -> bool:
+    haystack = _compact_visible_text(capture_text)
+    if not haystack:
+        return False
+    fragments = _message_fragment_candidates(expected_text)
+    if not fragments:
+        return False
+    return any(fragment in haystack for fragment in fragments)
+
+
+def _message_fragment_candidates(text: str) -> list[str]:
+    sanitized = re.sub(r"\[team-agent-token:[^\]]+\]", "", text)
+    fragments: list[str] = []
+    for line in _message_content_lines(sanitized):
+        compact = _compact_visible_text(line)
+        if not _is_strong_message_fragment(compact):
+            continue
+        if len(compact) <= 72:
+            fragments.append(compact)
+            continue
+        midpoint = len(compact) // 2
+        fragments.extend(
+            [
+                compact[:36],
+                compact[max(0, midpoint - 18) : midpoint + 18],
+                compact[-36:],
+            ]
+        )
+    unique: list[str] = []
+    seen: set[str] = set()
+    for fragment in fragments:
+        if fragment in seen:
+            continue
+        seen.add(fragment)
+        unique.append(fragment)
+    return unique
+
+
+def _message_content_lines(text: str) -> list[str]:
+    lines = text.splitlines()
+    if lines and lines[0].strip().startswith("Team Agent message from "):
+        lines = lines[1:]
+    return [line for line in lines if line.strip()]
+
+
+def _is_strong_message_fragment(compact: str) -> bool:
+    if not compact:
+        return False
+    generic_prefixes = (
+        "TeamAgentmessagefrom",
+        "TeamAgentpeermessagefrom",
+        "TeamAgentstoredthisresult",
+        "TeamAgenthascollectedthisresult",
+        "Nomanualpolling",
+    )
+    if compact.startswith(generic_prefixes):
+        return False
+    if re.fullmatch(r"[-:：>›❯]+", compact):
+        return False
+    if re.search(r"(msg|res)_[0-9A-Fa-f]{8,}", compact):
+        return True
+    cjk_count = len(re.findall(r"[\u4e00-\u9fff]", compact))
+    if cjk_count >= 4 and len(compact) >= 6:
+        return True
+    return len(compact) >= 18
+
+
+def _compact_visible_text(text: str) -> str:
+    return re.sub(r"\s+", "", text)
+
+
+def _submit_worker_prompt(
+    target: str,
+    before_capture: str,
+    submit_key: str = "Enter",
+    attempts: int = 3,
+    settle_timeout: float = TMUX_SUBMIT_MIN_SETTLE_TIMEOUT,
+) -> dict[str, Any]:
+    verify_pasted_prompt = _capture_has_pasted_content_prompt(before_capture)
+    attempt_log: list[dict[str, Any]] = []
+    for attempt in range(1, max(attempts, 1) + 1):
+        proc = run_cmd(["tmux", "send-keys", "-t", target, submit_key], timeout=10)
+        if proc.returncode != 0:
+            return {
+                "ok": False,
+                "stage": "send-keys",
+                "verification": "send_keys_failed",
+                "error": proc.stderr.strip(),
+                "attempts": attempt_log,
+            }
+        if not verify_pasted_prompt:
+            return {
+                "ok": True,
+                "stage": "submitted",
+                "verification": "enter_sent_without_placeholder_check",
+                "attempts": attempt_log + [{"attempt": attempt, "submitted": True, "verification": "not_required"}],
+            }
+        cleared, verification = _wait_for_pasted_prompt_cleared(target, settle_timeout)
+        attempt_log.append({"attempt": attempt, "submitted": True, "verification": verification})
+        if cleared:
+            return {
+                "ok": True,
+                "stage": "submitted",
+                "verification": "pasted_content_prompt_absent_after_submit",
+                "attempts": attempt_log,
+            }
+    return {
+        "ok": False,
+        "stage": "submit-verification",
+        "verification": "pasted_content_prompt_still_present_after_retries",
+        "error": "pasted content prompt still present after Enter retries",
+        "attempts": attempt_log,
+    }
+
+
+def _wait_for_pasted_prompt_cleared(target: str, timeout: float) -> tuple[bool, str]:
+    polls = max(1, int(max(timeout, 0.0) / 0.1) + 1)
+    last = "pasted_content_prompt_still_present"
+    for poll in range(polls):
+        capture = run_cmd(["tmux", "capture-pane", "-p", "-S", f"-{DELIVERY_CAPTURE_LINES}", "-t", target], timeout=5)
+        if capture.returncode != 0:
+            last = "capture_failed"
+        elif not _capture_has_pasted_content_prompt(capture.stdout):
+            return True, "pasted_content_prompt_absent"
+        else:
+            last = "pasted_content_prompt_still_present"
+        if poll < polls - 1:
+            time.sleep(0.1)
+    return False, last