@capagents/forgeqe 0.0.0-stage → 1.0.1

package/py/forgeqe_engine/cli.py

@@ -0,0 +1,188 @@
+"""
+Engine process protocol, used by the Bun CLI:
+
+  stdin  line 1   run request JSON
+  stdin  later    "stop" aborts the run
+  stdout          one JSON event per line (log, memory, step, result, usage, done);
+                  steps replayed from page memory carry "source": "memory"
+  stderr          engine logs
+
+  python -m forgeqe_engine run
+  python -m forgeqe_engine login   (stdin: {url, logins}, then "save")
+  python -m forgeqe_engine doctor
+  python -m forgeqe_engine token   (stdin: an llms.json profile with auth: entra; prints {token, expires_on})
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import sys
+import threading
+from typing import Any, Dict, TextIO
+
+
+def _event_stream() -> TextIO:
+    """Keep a private handle on stdout for events and point fd 1 at stderr, so library prints cannot corrupt the protocol."""
+    out = os.fdopen(os.dup(1), "w", buffering=1, encoding="utf-8")
+    os.dup2(2, 1)
+    sys.stdout = sys.stderr
+    return out
+
+
+NO_TELEMETRY = {
+    "ANONYMIZED_TELEMETRY": "false",
+    "BROWSER_USE_CLOUD_SYNC": "false",
+    "BROWSER_USE_CALCULATE_COST": "false",
+    "OTEL_SDK_DISABLED": "true",
+    "DO_NOT_TRACK": "1",
+}
+
+
+ENGINE_PREFIX = "FORGEQE_ENGINE_"
+
+
+def _engine_settings() -> None:
+    """FORGEQE_ENGINE_<NAME> sets engine setting <NAME>, which the engine and its library read as BROWSER_USE_<NAME>."""
+    for key, value in list(os.environ.items()):
+        if key.startswith(ENGINE_PREFIX) and len(key) > len(ENGINE_PREFIX):
+            os.environ["BROWSER_USE_" + key[len(ENGINE_PREFIX):]] = value
+
+
+def _configure_env() -> None:
+    _engine_settings()
+    os.environ.update(NO_TELEMETRY)
+    os.environ.setdefault("BROWSER_USE_LOGGING_LEVEL", "info")
+    logging.basicConfig(stream=sys.stderr, level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")
+
+
+def _doctor(out: TextIO) -> int:
+    info: Dict[str, Any] = {"python": sys.version.split()[0]}
+    try:
+        from importlib.metadata import version
+
+        info["browser_use"] = version("browser-use")
+    except Exception as e:
+        info["browser_use_error"] = str(e)
+        out.write(json.dumps(info) + "\n")
+        return 1
+    try:
+        info["azure_identity"] = version("azure-identity")
+    except Exception:
+        pass
+    try:
+        from .service import local_browser_launch_kwargs
+
+        kw = local_browser_launch_kwargs(headless=True)
+    except Exception as e:
+        info["engine_error"] = f"{type(e).__name__}: {e}"
+        out.write(json.dumps(info) + "\n")
+        return 1
+    info["channel"] = kw.get("channel")
+    info["executable_path"] = kw.get("executable_path") or ""
+    out.write(json.dumps(info) + "\n")
+    return 0
+
+
+def _run(out: TextIO) -> int:
+    from .service import RunRequest, run_with_events
+
+    line = sys.stdin.readline()
+    if not line.strip():
+        out.write(json.dumps({"type": "done", "result": {"success": False, "error": "No run request on stdin."}}) + "\n")
+        return 2
+    req = RunRequest.from_dict(json.loads(line))
+    lock = threading.Lock()
+
+    def emit(event: Dict[str, Any]) -> None:
+        with lock:
+            out.write(json.dumps(event, ensure_ascii=False, default=str) + "\n")
+            out.flush()
+
+    async def main() -> int:
+        loop = asyncio.get_running_loop()
+        cancel = asyncio.Event()
+
+        def watch_stdin() -> None:
+            for cmd in sys.stdin:
+                if cmd.strip().lower() == "stop":
+                    loop.call_soon_threadsafe(cancel.set)
+                    return
+            loop.call_soon_threadsafe(cancel.set)
+
+        threading.Thread(target=watch_stdin, daemon=True).start()
+        result = await run_with_events(req, emit, cancel)
+        return 0 if result.get("success") else 1
+
+    return asyncio.run(main())
+
+
+def _login(out: TextIO) -> int:
+    """stdin line 1: {url, logins: [login]}; then "save" saves the session, "stop" or EOF cancels."""
+    from .logins import interactive_login
+
+    line = sys.stdin.readline()
+    payload = json.loads(line) if line.strip() else {}
+
+    def emit(event: Dict[str, Any]) -> None:
+        out.write(json.dumps(event, ensure_ascii=False, default=str) + "\n")
+        out.flush()
+
+    async def main() -> int:
+        loop = asyncio.get_running_loop()
+        finished = asyncio.Event()
+
+        def watch_stdin() -> None:
+            for cmd in sys.stdin:
+                if cmd.strip().lower() == "save":
+                    loop.call_soon_threadsafe(finished.set)
+                    return
+                if cmd.strip().lower() == "stop":
+                    break
+            payload["cancelled"] = True
+            loop.call_soon_threadsafe(finished.set)
+
+        threading.Thread(target=watch_stdin, daemon=True).start()
+        try:
+            result = await interactive_login(payload, emit, finished)
+        except Exception as e:
+            result = {"success": False, "error": str(e)}
+        emit({"type": "done", "result": result})
+        return 0 if result.get("success") else 1
+
+    return asyncio.run(main())
+
+
+def _token(out: TextIO) -> int:
+    """stdin: an llms.json profile with auth: entra. Prints {token, expires_on} for its scope, or {error}."""
+    from .llm import entra_credential, entra_scope
+
+    line = sys.stdin.readline()
+    cfg = json.loads(line) if line.strip() else {}
+    try:
+        t = entra_credential(cfg).get_token(entra_scope(cfg))
+        out.write(json.dumps({"token": t.token, "expires_on": t.expires_on}) + "\n")
+        return 0
+    except Exception as e:
+        # The credential chain's message names every source it tried and why each failed; keep its first lines.
+        msg = " ".join(str(e).split("\n")[:6]).strip()
+        out.write(json.dumps({"error": f"{type(e).__name__}: {msg}"[:1500]}) + "\n")
+        return 1
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = list(sys.argv[1:] if argv is None else argv)
+    out = _event_stream()
+    _configure_env()
+    cmd = args[0] if args else "run"
+    if cmd == "doctor":
+        return _doctor(out)
+    if cmd == "run":
+        return _run(out)
+    if cmd == "login":
+        return _login(out)
+    if cmd == "token":
+        return _token(out)
+    out.write(json.dumps({"type": "done", "result": {"success": False, "error": f"Unknown command {cmd}"}}) + "\n")
+    return 2