codex-flow 2.1.13__py3-none-any.whl

codex_flow/data/scripts/localization.py

@@ -0,0 +1,192 @@
+#!/usr/bin/env python3
+"""Shared language resolution and policy persistence for codex-flow."""
+
+from __future__ import annotations
+
+import argparse
+import locale
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+SUPPORTED_LANGUAGES = {"auto", "zh", "en"}
+
+
+def configure_stdio() -> None:
+    """Use UTF-8 for user-facing output on legacy Windows consoles/pipes."""
+    for name in ("stdout", "stderr"):
+        stream = getattr(sys, name, None)
+        if stream is None or not hasattr(stream, "reconfigure"):
+            continue
+        try:
+            stream.reconfigure(encoding="utf-8", errors="replace")
+        except (OSError, ValueError):
+            pass
+
+
+configure_stdio()
+
+
+def normalize_language(value: str | None, *, allow_auto: bool = True) -> str:
+    raw = (value or "").strip().lower().replace("_", "-")
+    if allow_auto and raw in ("", "auto", "system", "default"):
+        return "auto"
+    if raw == "zh" or raw.startswith("zh-") or raw.startswith("chinese"):
+        return "zh"
+    if raw == "en" or raw.startswith("en-") or raw.startswith("english"):
+        return "en"
+    raise ValueError("language must be auto, zh, or en")
+
+
+def _language_from_text(value: str | None) -> str | None:
+    if not value:
+        return None
+    lowered = value.strip().lower().replace("_", "-")
+    if lowered.startswith("zh") or "chinese" in lowered:
+        return "zh"
+    if lowered.startswith("en") or "english" in lowered:
+        return "en"
+    return None
+
+
+def detect_system_language() -> str:
+    if sys.platform == "darwin":
+        try:
+            result = subprocess.run(
+                ["defaults", "read", "-g", "AppleLanguages"],
+                check=False,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.DEVNULL,
+                text=True,
+                timeout=1.0,
+            )
+            match = re.search(r'"([^"\n]+)"', result.stdout or "")
+            detected = _language_from_text(match.group(1) if match else result.stdout)
+            if detected:
+                return detected
+        except (OSError, subprocess.SubprocessError):
+            pass
+
+    env_candidates = (
+        os.environ.get("LC_ALL"),
+        os.environ.get("LC_MESSAGES"),
+        os.environ.get("LANGUAGE"),
+        os.environ.get("LANG"),
+    )
+    for candidate in env_candidates:
+        detected = _language_from_text(candidate)
+        if detected:
+            return detected
+
+    try:
+        current = locale.getlocale()[0]
+    except (ValueError, TypeError):
+        current = None
+    detected = _language_from_text(current)
+    return detected or "en"
+
+
+def policy_path() -> Path:
+    codex_home = Path(os.environ.get("CODEX_HOME", Path.home() / ".codex"))
+    return codex_home / "codex-flow.toml"
+
+
+def configured_language(path: Path | None = None) -> str:
+    path = path or policy_path()
+    try:
+        text = path.read_text(encoding="utf-8")
+    except OSError:
+        return "auto"
+    section = re.search(r"(?ms)^\[ui\]\s*\n(.*?)(?=^\[[^\n]+\]\s*$|\Z)", text)
+    if not section:
+        return "auto"
+    match = re.search(r'(?m)^\s*language\s*=\s*"?([^"\s#]+)"?', section.group(1))
+    if not match:
+        return "auto"
+    try:
+        return normalize_language(match.group(1))
+    except ValueError:
+        return "auto"
+
+
+def resolve_language(path: Path | None = None) -> str:
+    override = os.environ.get("CODEX_FLOW_LANGUAGE")
+    if override:
+        try:
+            value = normalize_language(override)
+        except ValueError:
+            value = "auto"
+    else:
+        value = configured_language(path)
+    return detect_system_language() if value == "auto" else value
+
+
+def set_configured_language(value: str, path: Path | None = None) -> str:
+    normalized = normalize_language(value)
+    path = path or policy_path()
+    try:
+        text = path.read_text(encoding="utf-8")
+    except OSError:
+        text = ""
+
+    section_re = re.compile(r"(?ms)^\[ui\]\s*\n(.*?)(?=^\[[^\n]+\]\s*$|\Z)")
+    match = section_re.search(text)
+    line = f'language = "{normalized}"'
+    if match:
+        body = match.group(1)
+        key_re = re.compile(r"(?m)^\s*language\s*=.*$")
+        if key_re.search(body):
+            body = key_re.sub(line, body)
+        else:
+            if body and not body.endswith("\n"):
+                body += "\n"
+            body += line + "\n"
+        text = text[: match.start(1)] + body + text[match.end(1) :]
+    else:
+        if text and not text.endswith("\n"):
+            text += "\n"
+        if text and not text.endswith("\n\n"):
+            text += "\n"
+        text += f"[ui]\n{line}\n"
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(text, encoding="utf-8")
+    return normalized
+
+
+def tr(english: str, chinese: str, *, lang: str | None = None) -> str:
+    selected = lang or resolve_language()
+    return chinese if selected == "zh" else english
+
+
+def _main() -> int:
+    parser = argparse.ArgumentParser(add_help=False)
+    parser.add_argument("--policy", type=Path, default=None)
+    parser.add_argument("--resolved", action="store_true")
+    parser.add_argument("--configured", action="store_true")
+    parser.add_argument("--system", action="store_true")
+    parser.add_argument("--normalize")
+    parser.add_argument("--set")
+    args = parser.parse_args()
+
+    try:
+        if args.normalize is not None:
+            print(normalize_language(args.normalize))
+        elif args.set is not None:
+            print(set_configured_language(args.set, args.policy))
+        elif args.configured:
+            print(configured_language(args.policy))
+        elif args.system:
+            print(detect_system_language())
+        else:
+            print(resolve_language(args.policy))
+    except ValueError as exc:
+        print(str(exc), file=sys.stderr)
+        return 2
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(_main())

codex_flow/data/scripts/manage-hooks.py

@@ -0,0 +1,448 @@
+#!/usr/bin/env python3
+"""Install/remove FlowPilot lifecycle hooks and inspect Codex hook trust state.
+
+Trust detection intentionally mirrors Codex's current hook identity rules:
+- one persisted state key per event/group/handler
+- normalized command-hook config before hashing
+- canonical JSON + SHA-256 with the ``sha256:`` prefix
+
+The detector is read-only. It never grants trust on the user's behalf.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import re
+from pathlib import Path
+from typing import Any
+
+EVENTS = ("UserPromptSubmit", "SubagentStart", "SubagentStop", "Stop")
+MARKER = "codex-flow/telemetry.py"
+DEFAULT_TIMEOUT_SEC = 600
+SESSION_END_DEFAULT_TIMEOUT_SEC = 1
+SESSION_END_MAX_TIMEOUT_SEC = 3
+DEFAULT_ADDITIONAL_CONTEXT_LIMIT = 2500
+ADDITIONAL_CONTEXT_EVENTS = {
+    "PreToolUse",
+    "PostToolUse",
+    "SessionStart",
+    "UserPromptSubmit",
+    "SubagentStart",
+}
+EVENT_KEY_LABELS = {
+    "PreToolUse": "pre_tool_use",
+    "PermissionRequest": "permission_request",
+    "PostToolUse": "post_tool_use",
+    "PreCompact": "pre_compact",
+    "PostCompact": "post_compact",
+    "SessionStart": "session_start",
+    "SessionEnd": "session_end",
+    "UserPromptSubmit": "user_prompt_submit",
+    "SubagentStart": "subagent_start",
+    "SubagentStop": "subagent_stop",
+    "Stop": "stop",
+    "Interrupt": "interrupt",
+}
+
+
+def load(path: Path) -> dict[str, Any]:
+    if not path.exists():
+        return {"hooks": {}}
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:
+        raise SystemExit(f"invalid hooks JSON in {path}: {exc}")
+    if not isinstance(value, dict):
+        raise SystemExit(f"invalid hooks JSON in {path}: root must be an object")
+    value.setdefault("hooks", {})
+    if not isinstance(value["hooks"], dict):
+        raise SystemExit(f"invalid hooks JSON in {path}: hooks must be an object")
+    return value
+
+
+def is_managed_hook(hook: Any) -> bool:
+    if not isinstance(hook, dict):
+        return False
+    command = hook.get("command")
+    return isinstance(command, str) and MARKER in command.replace("\\", "/")
+
+
+def is_managed_entry(entry: Any) -> bool:
+    if not isinstance(entry, dict):
+        return False
+    hooks = entry.get("hooks", [])
+    return isinstance(hooks, list) and any(is_managed_hook(hook) for hook in hooks)
+
+
+def remove_managed(data: dict[str, Any]) -> None:
+    hooks = data.get("hooks", {})
+    if not isinstance(hooks, dict):
+        return
+    for event in list(hooks):
+        entries = hooks[event]
+        if not isinstance(entries, list):
+            continue
+        kept = []
+        for entry in entries:
+            # Keep malformed entries and entries with malformed `hooks` values
+            # unchanged; only a valid hook list is safe to filter.
+            if not isinstance(entry, dict) or not isinstance(entry.get("hooks"), list):
+                kept.append(entry)
+                continue
+
+            entry_hooks = entry["hooks"]
+            filtered_hooks = [hook for hook in entry_hooks if not is_managed_hook(hook)]
+            if len(filtered_hooks) == len(entry_hooks):
+                kept.append(entry)
+            elif filtered_hooks:
+                entry["hooks"] = filtered_hooks
+                kept.append(entry)
+        if kept:
+            hooks[event] = kept
+        else:
+            hooks.pop(event, None)
+
+
+def command_for(script: Path) -> str:
+    # Codex command hooks use a shell command string. Double quotes cover the
+    # normal user-home path cases on Unix and Windows.
+    escaped = str(script).replace('"', '\\"')
+    return f'python3 "{escaped}"'
+
+
+def install(path: Path, script: Path) -> None:
+    data = load(path)
+    remove_managed(data)
+    command = command_for(script)
+    for event in EVENTS:
+        data["hooks"].setdefault(event, []).append(
+            {
+                "hooks": [
+                    {
+                        "type": "command",
+                        "command": command,
+                        "timeout": 15,
+                        "statusMessage": "FlowPilot telemetry",
+                    }
+                ]
+            }
+        )
+    write(path, data)
+
+
+def uninstall(path: Path) -> None:
+    if not path.exists():
+        return
+    data = load(path)
+    remove_managed(data)
+    write(path, data)
+
+
+def write(path: Path, data: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_name(path.name + ".codex-flow.tmp")
+    tmp.write_text(json.dumps(data, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    os.replace(tmp, path)
+
+
+def check(path: Path) -> int:
+    if not path.exists():
+        return 1
+    data = load(path)
+    hooks = data.get("hooks", {})
+    for event in EVENTS:
+        entries = hooks.get(event, [])
+        if not isinstance(entries, list) or not any(is_managed_entry(entry) for entry in entries):
+            return 1
+    return 0
+
+
+def _absolute_display_path(path: Path) -> str:
+    # Codex builds hook keys from an absolute source path. Do not resolve
+    # symlinks here: the config-layer path is made absolute, not canonicalized.
+    return os.path.abspath(os.path.expanduser(str(path)))
+
+
+def _event_key_label(event: str) -> str:
+    return EVENT_KEY_LABELS.get(event, re.sub(r"(?<!^)(?=[A-Z])", "_", event).lower())
+
+
+def _normalized_timeout(event: str, value: Any) -> int:
+    try:
+        timeout = int(value) if value is not None else None
+    except (TypeError, ValueError):
+        timeout = None
+    if event in {"SessionEnd", "Interrupt"}:
+        timeout = SESSION_END_DEFAULT_TIMEOUT_SEC if timeout is None else timeout
+        return max(1, min(timeout, SESSION_END_MAX_TIMEOUT_SEC))
+    timeout = DEFAULT_TIMEOUT_SEC if timeout is None else timeout
+    return max(1, timeout)
+
+
+def _canonical_hash(value: dict[str, Any]) -> str:
+    serialized = json.dumps(
+        value,
+        ensure_ascii=False,
+        sort_keys=True,
+        separators=(",", ":"),
+    ).encode("utf-8")
+    return "sha256:" + hashlib.sha256(serialized).hexdigest()
+
+
+def _normalized_command_identity(
+    event: str,
+    matcher: Any,
+    handler: dict[str, Any],
+) -> dict[str, Any]:
+    command = handler.get("command")
+    if os.name == "nt" and isinstance(handler.get("commandWindows"), str):
+        command = handler["commandWindows"]
+    if not isinstance(command, str):
+        command = ""
+
+    normalized_handler: dict[str, Any] = {
+        "type": "command",
+        "command": command,
+        "timeout": _normalized_timeout(event, handler.get("timeout")),
+        "async": bool(handler.get("async", False)),
+    }
+    status_message = handler.get("statusMessage")
+    if isinstance(status_message, str):
+        normalized_handler["statusMessage"] = status_message
+
+    if event in ADDITIONAL_CONTEXT_EVENTS:
+        limit = handler.get("additionalContextLimit")
+        if isinstance(limit, int) and not isinstance(limit, bool) and limit != DEFAULT_ADDITIONAL_CONTEXT_LIMIT:
+            normalized_handler["additionalContextLimit"] = limit
+
+    identity: dict[str, Any] = {
+        "event_name": _event_key_label(event),
+        "hooks": [normalized_handler],
+    }
+    if isinstance(matcher, str):
+        identity["matcher"] = matcher
+    return identity
+
+
+def _managed_hook_entries(path: Path) -> list[dict[str, Any]]:
+    data = load(path)
+    hooks = data.get("hooks", {})
+    if not isinstance(hooks, dict):
+        return []
+    source = _absolute_display_path(path)
+    result: list[dict[str, Any]] = []
+    for event, groups in hooks.items():
+        if not isinstance(event, str) or not isinstance(groups, list):
+            continue
+        for group_index, group in enumerate(groups):
+            if not isinstance(group, dict):
+                continue
+            matcher = group.get("matcher")
+            handlers = group.get("hooks", [])
+            if not isinstance(handlers, list):
+                continue
+            for handler_index, handler in enumerate(handlers):
+                if not is_managed_hook(handler):
+                    continue
+                assert isinstance(handler, dict)
+                key = f"{source}:{_event_key_label(event)}:{group_index}:{handler_index}"
+                current_hash = _canonical_hash(_normalized_command_identity(event, matcher, handler))
+                result.append(
+                    {
+                        "event": event,
+                        "group_index": group_index,
+                        "handler_index": handler_index,
+                        "key": key,
+                        "current_hash": current_hash,
+                    }
+                )
+    return result
+
+
+def _fallback_hook_states(text: str) -> dict[str, dict[str, Any]]:
+    """Minimal parser for hook trust state when stdlib tomllib is unavailable."""
+    states: dict[str, dict[str, Any]] = {}
+    current: str | None = None
+    header = re.compile(r'^\s*\[hooks\.state\.(?P<key>.+)\]\s*$')
+    for raw_line in text.splitlines():
+        match = header.match(raw_line)
+        if match:
+            token = match.group("key").strip()
+            current = None
+            if len(token) >= 2 and token[0] == token[-1] == "'":
+                current = token[1:-1]
+            elif len(token) >= 2 and token[0] == token[-1] == '"':
+                try:
+                    current = json.loads(token)
+                except json.JSONDecodeError:
+                    current = token[1:-1].replace('\\"', '"').replace("\\\\", "\\")
+            if current is not None:
+                states.setdefault(current, {})
+            continue
+        if current is None:
+            continue
+        trusted = re.match(r'^\s*trusted_hash\s*=\s*"([^"]+)"\s*(?:#.*)?$', raw_line)
+        if trusted:
+            states[current]["trusted_hash"] = trusted.group(1)
+            continue
+        enabled = re.match(r"^\s*enabled\s*=\s*(true|false)\s*(?:#.*)?$", raw_line, re.IGNORECASE)
+        if enabled:
+            states[current]["enabled"] = enabled.group(1).lower() == "true"
+    return states
+
+
+def _load_hook_states(config: Path) -> tuple[dict[str, dict[str, Any]], str | None]:
+    if not config.exists():
+        return {}, None
+    try:
+        text = config.read_text(encoding="utf-8-sig")
+    except OSError as exc:
+        return {}, str(exc)
+    try:
+        import tomllib  # Python 3.11+
+    except ImportError:
+        return _fallback_hook_states(text), None
+    try:
+        parsed = tomllib.loads(text)
+    except Exception as exc:  # invalid config should not crash install/update
+        fallback = _fallback_hook_states(text)
+        return fallback, None if fallback else str(exc)
+    hooks = parsed.get("hooks", {}) if isinstance(parsed, dict) else {}
+    state = hooks.get("state", {}) if isinstance(hooks, dict) else {}
+    if not isinstance(state, dict):
+        return {}, None
+    result: dict[str, dict[str, Any]] = {}
+    for key, value in state.items():
+        if isinstance(key, str) and isinstance(value, dict):
+            result[key] = value
+    return result, None
+
+
+def trust_report(path: Path, config: Path) -> dict[str, Any]:
+    if not path.exists():
+        return {
+            "status": "missing",
+            "ready": False,
+            "authorization_required": False,
+            "total": 0,
+            "trusted": 0,
+            "untrusted": 0,
+            "modified": 0,
+            "disabled": 0,
+            "entries": [],
+            "error": None,
+        }
+
+    entries = _managed_hook_entries(path)
+    if not entries:
+        return {
+            "status": "missing",
+            "ready": False,
+            "authorization_required": False,
+            "total": 0,
+            "trusted": 0,
+            "untrusted": 0,
+            "modified": 0,
+            "disabled": 0,
+            "entries": [],
+            "error": None,
+        }
+
+    states, state_error = _load_hook_states(config)
+    counts = {"trusted": 0, "untrusted": 0, "modified": 0, "disabled": 0}
+    for entry in entries:
+        state = states.get(entry["key"], {})
+        enabled = state.get("enabled") is not False
+        trusted_hash = state.get("trusted_hash") if isinstance(state.get("trusted_hash"), str) else None
+        if not enabled:
+            status = "disabled"
+        elif trusted_hash == entry["current_hash"]:
+            status = "trusted"
+        elif trusted_hash:
+            status = "modified"
+        else:
+            status = "untrusted"
+        counts[status] += 1
+        entry["status"] = status
+        entry["enabled"] = enabled
+        entry["trusted_hash"] = trusted_hash
+
+    if state_error:
+        aggregate = "unknown"
+    elif counts["disabled"]:
+        aggregate = "disabled"
+    elif counts["modified"]:
+        aggregate = "modified"
+    elif counts["untrusted"]:
+        aggregate = "untrusted"
+    else:
+        aggregate = "trusted"
+
+    return {
+        "status": aggregate,
+        "ready": aggregate == "trusted",
+        "authorization_required": bool(counts["untrusted"] or counts["modified"]),
+        "total": len(entries),
+        **counts,
+        "entries": entries,
+        "error": state_error,
+        "hooks_path": _absolute_display_path(path),
+        "config_path": _absolute_display_path(config),
+    }
+
+
+def _print_trust_report(report: dict[str, Any]) -> None:
+    status = report.get("status", "unknown")
+    total = int(report.get("total", 0) or 0)
+    trusted = int(report.get("trusted", 0) or 0)
+    if status == "trusted":
+        print(f"FlowPilot hook trust: trusted ({trusted}/{total})")
+    elif status == "modified":
+        print("FlowPilot hook trust: changed since approval; review required with /hooks")
+    elif status == "untrusted":
+        print("FlowPilot hook trust: approval required; review with /hooks")
+    elif status == "disabled":
+        print("FlowPilot hook trust: one or more managed hooks are disabled in Codex")
+    elif status == "missing":
+        print("FlowPilot hook trust: managed hooks are not installed")
+    else:
+        detail = report.get("error") or "trust state could not be verified"
+        print(f"FlowPilot hook trust: unknown ({detail})")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("action", choices=("install", "uninstall", "check", "status"))
+    parser.add_argument("--hooks", required=True, type=Path)
+    parser.add_argument("--script", type=Path)
+    parser.add_argument("--config", type=Path)
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args()
+    if args.action == "install":
+        if args.script is None:
+            parser.error("--script is required for install")
+        install(args.hooks, args.script)
+        return 0
+    if args.action == "uninstall":
+        uninstall(args.hooks)
+        return 0
+    if args.action == "check":
+        return check(args.hooks)
+
+    config = args.config or args.hooks.parent / "config.toml"
+    report = trust_report(args.hooks, config)
+    if args.json:
+        print(json.dumps(report, ensure_ascii=False, indent=2, sort_keys=True))
+    else:
+        _print_trust_report(report)
+    if report["ready"]:
+        return 0
+    if report["status"] == "missing":
+        return 1
+    return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())