@team-agent/installer 0.1.0

package/src/team_agent/rust_core.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+import json
+import re
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any
+
+from team_agent.paths import repo_root
+
+
+def core_binary() -> Path | None:
+    configured = shutil.which("team-agent-core")
+    if configured:
+        return Path(configured)
+    local = repo_root() / "crates" / "team-agent-core" / "target" / "debug" / "team-agent-core"
+    if local.exists():
+        return local
+    return None
+
+
+def call_core(command: str, payload: dict[str, Any] | str | None = None) -> dict[str, Any]:
+    binary = core_binary()
+    if not binary:
+        return {"ok": False, "error": "team-agent-core binary not found", "fallback": True}
+    raw = json.dumps(payload, ensure_ascii=False) if isinstance(payload, dict) else (payload or "")
+    proc = subprocess.run(
+        [str(binary), command, "--json"],
+        input=raw,
+        text=True,
+        capture_output=True,
+        timeout=10,
+        check=False,
+    )
+    try:
+        result = json.loads(proc.stdout or "{}")
+    except json.JSONDecodeError:
+        result = {"ok": False, "error": proc.stdout.strip() or proc.stderr.strip()}
+    if proc.returncode != 0:
+        result.setdefault("ok", False)
+        result.setdefault("error", proc.stderr.strip() or "team-agent-core failed")
+    result["engine"] = "rust" if result.get("ok") else "rust_failed"
+    return result
+
+
+def render_message(payload: dict[str, Any]) -> dict[str, Any]:
+    result = call_core("render-message", payload)
+    if result.get("ok"):
+        return result
+    sender = payload.get("from") or payload.get("sender") or "unknown"
+    task_id = payload.get("task_id")
+    content = payload.get("content") or ""
+    token = payload.get("message_id") or "missing"
+    header = f"Team Agent message from {sender}"
+    if task_id:
+        header += f" for {task_id}"
+    return {
+        "ok": True,
+        "text": f"{header}:\n\n{content}\n\n[team-agent-token:{token}]",
+        "token": token,
+        "engine": "python_fallback",
+        "fallback_reason": result.get("error"),
+    }
+
+
+def redact_text(text: str) -> dict[str, Any]:
+    result = call_core("redact", {"text": text})
+    if result.get("ok"):
+        return result
+    redacted = []
+    for chunk in text.split():
+        lower = chunk.lower()
+        if (
+            "api_key" in lower
+            or "apikey" in lower
+            or "token=" in lower
+            or "secret" in lower
+            or lower == "bearer"
+            or chunk.startswith("sk-")
+            or _looks_base64_secret(chunk)
+        ):
+            redacted.append("[REDACTED]")
+        else:
+            redacted.append(chunk)
+    return {"ok": True, "text": " ".join(redacted), "engine": "python_fallback", "fallback_reason": result.get("error")}
+
+
+def validate_profile_metadata(profile: dict[str, Any]) -> dict[str, Any]:
+    result = call_core("validate-profile", profile)
+    if result.get("ok") or result.get("errors"):
+        return result
+    errors: list[str] = []
+    if profile.get("auth_mode") not in {"subscription", "official_api", "compatible_api"}:
+        errors.append("auth_mode must be subscription, official_api, or compatible_api")
+    for field in ["provider", "model", "profile"]:
+        if not profile.get(field):
+            errors.append(f"{field} must not be empty")
+        if contains_inline_secret(str(profile.get(field) or "")):
+            errors.append("profile metadata contains a probable inline secret")
+    return {"ok": not errors, "errors": errors, "engine": "python_fallback", "fallback_reason": result.get("error")}
+
+
+def list_targets() -> dict[str, Any]:
+    result = call_core("list-targets")
+    if result.get("ok"):
+        return result
+    proc = subprocess.run(
+        [
+            "tmux",
+            "list-panes",
+            "-a",
+            "-F",
+            "#{pane_id}\t#{session_name}\t#{window_index}\t#{window_name}\t#{pane_index}\t#{pane_tty}\t#{pane_current_command}\t#{pane_active}",
+        ],
+        text=True,
+        capture_output=True,
+        timeout=5,
+        check=False,
+    )
+    if proc.returncode != 0:
+        return {"ok": False, "error": proc.stderr.strip() or "tmux list-panes failed", "engine": "python_fallback"}
+    targets = []
+    for line in proc.stdout.splitlines():
+        parts = line.split("\t")
+        if len(parts) != 8:
+            continue
+        target = {
+            "pane_id": parts[0],
+            "session_name": parts[1],
+            "window_index": parts[2],
+            "window_name": parts[3],
+            "pane_index": parts[4],
+            "pane_tty": parts[5],
+            "pane_current_command": parts[6],
+            "pane_active": parts[7] == "1",
+        }
+        target["fingerprint"] = f"{target['session_name']}|{target['window_index']}|{target['pane_index']}|{target['pane_tty']}"
+        targets.append(target)
+    return {"ok": True, "targets": targets, "engine": "python_fallback", "fallback_reason": result.get("error")}
+
+
+def contains_inline_secret(value: str) -> bool:
+    lower = value.lower()
+    return (
+        "api_key" in lower
+        or "apikey" in lower
+        or "token" in lower
+        or "secret" in lower
+        or value.startswith("sk-")
+        or _looks_base64_secret(value)
+    )
+
+
+def _looks_base64_secret(value: str) -> bool:
+    return len(value) >= 32 and re.fullmatch(r"[A-Za-z0-9+/=_-]+", value) is not None

package/src/team_agent/simple_yaml.py

@@ -0,0 +1,236 @@
+from __future__ import annotations
+
+import ast
+import json
+from typing import Any
+
+
+def loads(text: str) -> Any:
+    stripped = text.lstrip()
+    if stripped.startswith("{") or stripped.startswith("["):
+        return json.loads(text)
+    lines = text.splitlines()
+    value, index = _parse_block(lines, 0, 0)
+    while index < len(lines) and not _content(lines[index]):
+        index += 1
+    if index != len(lines):
+        raise ValueError(f"unexpected content at line {index + 1}: {lines[index]}")
+    return value
+
+
+def dumps(value: Any, indent: int = 0) -> str:
+    lines = _dump(value, indent)
+    return "\n".join(lines) + "\n"
+
+
+def _parse_block(lines: list[str], index: int, indent: int) -> tuple[Any, int]:
+    index = _skip_blank(lines, index)
+    if index >= len(lines):
+        return None, index
+    current_indent = _indent(lines[index])
+    if current_indent < indent:
+        return None, index
+    if _stripped(lines[index]).startswith("- "):
+        return _parse_list(lines, index, current_indent)
+    return _parse_dict(lines, index, current_indent)
+
+
+def _parse_dict(lines: list[str], index: int, indent: int) -> tuple[dict[str, Any], int]:
+    obj: dict[str, Any] = {}
+    while index < len(lines):
+        if not _content(lines[index]):
+            index += 1
+            continue
+        line_indent = _indent(lines[index])
+        if line_indent < indent:
+            break
+        if line_indent > indent:
+            raise ValueError(f"unexpected indentation at line {index + 1}: {lines[index]}")
+        stripped = _stripped(lines[index])
+        if stripped.startswith("- "):
+            break
+        key, raw = _split_key_value(stripped, index)
+        if raw == "|":
+            value, index = _parse_block_scalar(lines, index + 1, indent + 2)
+        elif raw == "":
+            value, index = _parse_block(lines, index + 1, indent + 2)
+        else:
+            value = _parse_scalar(raw)
+            index += 1
+        obj[key] = value
+    return obj, index
+
+
+def _parse_list(lines: list[str], index: int, indent: int) -> tuple[list[Any], int]:
+    items: list[Any] = []
+    while index < len(lines):
+        if not _content(lines[index]):
+            index += 1
+            continue
+        line_indent = _indent(lines[index])
+        if line_indent < indent:
+            break
+        if line_indent != indent:
+            raise ValueError(f"unexpected list indentation at line {index + 1}: {lines[index]}")
+        stripped = _stripped(lines[index])
+        if not stripped.startswith("- "):
+            break
+        item_text = stripped[2:].strip()
+        if item_text == "":
+            value, index = _parse_block(lines, index + 1, indent + 2)
+            items.append(value)
+            continue
+        if _looks_like_key_value(item_text):
+            key, raw = _split_key_value(item_text, index)
+            item: dict[str, Any] = {}
+            if raw == "|":
+                value, next_index = _parse_block_scalar(lines, index + 1, indent + 2)
+            elif raw == "":
+                value, next_index = _parse_block(lines, index + 1, indent + 2)
+            else:
+                value = _parse_scalar(raw)
+                next_index = index + 1
+            item[key] = value
+            if next_index < len(lines) and _indent(lines[next_index]) == indent + 2:
+                extra, next_index = _parse_dict(lines, next_index, indent + 2)
+                item.update(extra)
+            items.append(item)
+            index = next_index
+        else:
+            items.append(_parse_scalar(item_text))
+            index += 1
+    return items, index
+
+
+def _parse_block_scalar(lines: list[str], index: int, indent: int) -> tuple[str, int]:
+    block: list[str] = []
+    while index < len(lines):
+        if not lines[index].strip():
+            block.append("")
+            index += 1
+            continue
+        line_indent = _indent(lines[index])
+        if line_indent < indent:
+            break
+        block.append(lines[index][indent:])
+        index += 1
+    return "\n".join(block).rstrip() + "\n", index
+
+
+def _parse_scalar(raw: str) -> Any:
+    if raw in {"null", "Null", "NULL", "~"}:
+        return None
+    if raw in {"true", "True", "TRUE"}:
+        return True
+    if raw in {"false", "False", "FALSE"}:
+        return False
+    try:
+        return int(raw)
+    except ValueError:
+        pass
+    if raw.startswith("[") and raw.endswith("]"):
+        try:
+            return ast.literal_eval(raw)
+        except (SyntaxError, ValueError):
+            return raw
+    if raw == "{}":
+        return {}
+    if (raw.startswith('"') and raw.endswith('"')) or (raw.startswith("'") and raw.endswith("'")):
+        try:
+            return ast.literal_eval(raw)
+        except (SyntaxError, ValueError):
+            return raw[1:-1]
+    return raw
+
+
+def _dump(value: Any, indent: int) -> list[str]:
+    pad = " " * indent
+    if isinstance(value, dict):
+        lines: list[str] = []
+        for key, item in value.items():
+            if item == []:
+                lines.append(f"{pad}{key}: []")
+            elif item == {}:
+                lines.append(f"{pad}{key}: {{}}")
+            elif isinstance(item, (dict, list)):
+                lines.append(f"{pad}{key}:")
+                lines.extend(_dump(item, indent + 2))
+            elif isinstance(item, str) and "\n" in item:
+                lines.append(f"{pad}{key}: |")
+                for block_line in item.rstrip("\n").splitlines():
+                    lines.append(f"{pad}  {block_line}")
+            else:
+                lines.append(f"{pad}{key}: {_format_scalar(item)}")
+        return lines
+    if isinstance(value, list):
+        lines = []
+        for item in value:
+            if isinstance(item, dict):
+                if not item:
+                    lines.append(f"{pad}- {{}}")
+                    continue
+                first = True
+                for key, child in item.items():
+                    prefix = "- " if first else "  "
+                    if child == []:
+                        lines.append(f"{pad}{prefix}{key}: []")
+                    elif child == {}:
+                        lines.append(f"{pad}{prefix}{key}: {{}}")
+                    elif isinstance(child, (dict, list)):
+                        lines.append(f"{pad}{prefix}{key}:")
+                        lines.extend(_dump(child, indent + 4))
+                    else:
+                        lines.append(f"{pad}{prefix}{key}: {_format_scalar(child)}")
+                    first = False
+            elif isinstance(item, list):
+                lines.append(f"{pad}-")
+                lines.extend(_dump(item, indent + 2))
+            else:
+                lines.append(f"{pad}- {_format_scalar(item)}")
+        return lines
+    return [f"{pad}{_format_scalar(value)}"]
+
+
+def _format_scalar(value: Any) -> str:
+    if value is None:
+        return "null"
+    if value is True:
+        return "true"
+    if value is False:
+        return "false"
+    if isinstance(value, int):
+        return str(value)
+    return json.dumps(str(value), ensure_ascii=False)
+
+
+def _split_key_value(stripped: str, index: int) -> tuple[str, str]:
+    if ":" not in stripped:
+        raise ValueError(f"expected key: value at line {index + 1}")
+    key, raw = stripped.split(":", 1)
+    return key.strip(), raw.strip()
+
+
+def _looks_like_key_value(text: str) -> bool:
+    if ":" not in text:
+        return False
+    key = text.split(":", 1)[0]
+    return bool(key) and all(ch.isalnum() or ch in "_-" for ch in key)
+
+
+def _content(line: str) -> bool:
+    stripped = line.strip()
+    return bool(stripped) and not stripped.startswith("#")
+
+
+def _skip_blank(lines: list[str], index: int) -> int:
+    while index < len(lines) and not _content(lines[index]):
+        index += 1
+    return index
+
+
+def _indent(line: str) -> int:
+    return len(line) - len(line.lstrip(" "))
+
+
+def _stripped(line: str) -> str:
+    return line.strip()