anywhere-cli 0.1.0__py3-none-any.whl

connector/codex/rpc.py

@@ -0,0 +1,260 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import shutil
+import sys
+import time
+from collections.abc import Awaitable, Callable
+from pathlib import Path
+from typing import Any
+
+from loguru import logger
+
+from connector.launch import launch_target
+
+
+NotificationHandler = Callable[[dict[str, Any]], Awaitable[None]]
+APP_SERVER_STREAM_LIMIT = 64 * 1024 * 1024
+
+
+class JsonRpcStdioClient:
+    """Line-delimited JSON-RPC client for `codex app-server --listen stdio://`."""
+
+    def __init__(self, command: list[str] | None = None) -> None:
+        self.command = command or _resolve_codex_command()
+        self.process: asyncio.subprocess.Process | None = None
+        self._next_id = 1
+        self._pending: dict[int | str, asyncio.Future[dict[str, Any]]] = {}
+        self._server_request_ids: set[int | str] = set()
+        self._notification_handler: NotificationHandler | None = None
+        self._initialized = False
+
+    async def start(self, handler: NotificationHandler) -> None:
+        if self.process and self._initialized:
+            self._notification_handler = handler
+            return
+
+        self._notification_handler = handler
+        if self.process is None:
+            logger.info("starting codex app-server command={}", self.command)
+            self.process = await asyncio.create_subprocess_exec(
+                *self.command,
+                stdin=asyncio.subprocess.PIPE,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                limit=APP_SERVER_STREAM_LIMIT,
+            )
+            self._track_reader(asyncio.create_task(self._read_stdout()), "stdout")
+            self._track_reader(asyncio.create_task(self._read_stderr()), "stderr")
+
+        await self.request(
+            "initialize",
+            {
+                "clientInfo": {
+                    "name": "agent-server-connector",
+                    "title": "Agent Server Connector",
+                    "version": "0.1.0",
+                },
+                "capabilities": {
+                    "experimentalApi": True,
+                    "requestAttestation": False,
+                },
+            },
+        )
+        await self.notify("initialized")
+        self._initialized = True
+
+    async def request(self, method: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        if not self.process or not self.process.stdin:
+            raise RuntimeError("Codex app-server is not started")
+
+        request_id = self._next_id
+        self._next_id += 1
+        loop = asyncio.get_running_loop()
+        future: asyncio.Future[dict[str, Any]] = loop.create_future()
+        self._pending[request_id] = future
+        payload: dict[str, Any] = {
+            "jsonrpc": "2.0",
+            "id": request_id,
+            "method": method,
+            "params": params or {},
+        }
+
+        started = time.perf_counter()
+        self.process.stdin.write((json.dumps(payload, ensure_ascii=False) + "\n").encode("utf-8"))
+        await self.process.stdin.drain()
+        try:
+            return await future
+        finally:
+            elapsed_ms = (time.perf_counter() - started) * 1000
+            logger.trace("codex rpc method={} id={} elapsed_ms={:.1f}", method, request_id, elapsed_ms)
+
+    async def notify(self, method: str, params: dict[str, Any] | None = None) -> None:
+        if not self.process or not self.process.stdin:
+            raise RuntimeError("Codex app-server is not started")
+
+        payload: dict[str, Any] = {"jsonrpc": "2.0", "method": method, "params": params or {}}
+        self.process.stdin.write((json.dumps(payload, ensure_ascii=False) + "\n").encode("utf-8"))
+        await self.process.stdin.drain()
+
+    async def respond(self, request_id: str | int, result: dict[str, Any] | None = None) -> None:
+        if not self.process or not self.process.stdin:
+            raise RuntimeError("Codex app-server is not started")
+
+        response_id = self._response_id_for(request_id)
+        payload: dict[str, Any] = {"jsonrpc": "2.0", "id": response_id, "result": result or {}}
+        self.process.stdin.write((json.dumps(payload, ensure_ascii=False) + "\n").encode("utf-8"))
+        await self.process.stdin.drain()
+
+    async def close(self) -> None:
+        if self.process is None:
+            return
+        self.process.terminate()
+        try:
+            await asyncio.wait_for(self.process.wait(), timeout=5)
+        except TimeoutError:
+            self.process.kill()
+            await self.process.wait()
+        finally:
+            self.process = None
+            self._initialized = False
+
+    async def _read_stdout(self) -> None:
+        assert self.process and self.process.stdout
+        while line := await self.process.stdout.readline():
+            try:
+                payload = json.loads(line)
+            except json.JSONDecodeError:
+                logger.warning("codex app-server emitted non-json stdout: {}", line.decode(errors="replace").strip())
+                continue
+
+            request_id = payload.get("id")
+            if request_id in self._pending and ("result" in payload or "error" in payload):
+                future = self._pending.pop(request_id)
+                self._settle_pending_future(future, payload)
+                continue
+
+            if request_id is not None and isinstance(payload.get("method"), str):
+                self._server_request_ids.add(request_id)
+
+            if self._notification_handler is not None:
+                await self._notification_handler(payload)
+
+    async def _read_stderr(self) -> None:
+        assert self.process and self.process.stderr
+        while line := await self.process.stderr.readline():
+            logger.trace("codex app-server stderr: {}", line.decode(errors="replace").rstrip())
+
+    def _track_reader(self, task: asyncio.Task[None], name: str) -> None:
+        def done(completed: asyncio.Task[None]) -> None:
+            try:
+                completed.result()
+            except asyncio.CancelledError:
+                return
+            except Exception:
+                logger.exception("codex app-server {} reader stopped unexpectedly", name)
+
+        task.add_done_callback(done)
+
+    def _settle_pending_future(self, future: asyncio.Future[dict[str, Any]], payload: dict[str, Any]) -> None:
+        if future.done():
+            logger.trace("codex rpc received response for completed request id={}", payload.get("id"))
+            return
+        if "error" in payload:
+            future.set_exception(RuntimeError(json.dumps(payload["error"], ensure_ascii=False)))
+        else:
+            future.set_result(payload.get("result") or {})
+
+    def _response_id_for(self, request_id: str | int) -> str | int:
+        if request_id in self._server_request_ids:
+            self._server_request_ids.remove(request_id)
+            return request_id
+        if isinstance(request_id, str):
+            try:
+                numeric_request_id = int(request_id)
+            except ValueError:
+                numeric_request_id = None
+            if numeric_request_id is not None and numeric_request_id in self._server_request_ids:
+                self._server_request_ids.remove(numeric_request_id)
+                logger.trace(
+                    "codex rpc coerced approval response id from string to number request_id={}",
+                    request_id,
+                )
+                return numeric_request_id
+        logger.warning("codex rpc responding to unknown server request id={}", request_id)
+        return request_id
+
+
+def _resolve_codex_bin() -> str:
+    for candidate in codex_candidate_paths():
+        if candidate["source"] == "custom":
+            return candidate["path"]
+        path = Path(candidate["path"])
+        if path.is_file():
+            return str(path)
+    return "codex"
+
+
+def _resolve_codex_command() -> list[str]:
+    path = _resolve_codex_bin()
+    return launch_target("cli", path).command(["app-server", "--listen", "stdio://"])
+
+
+def codex_candidate_paths() -> list[dict[str, str]]:
+    if sys.platform == "win32":
+        home = Path.home()
+        appdata = os.environ.get("APPDATA", str(home / "AppData" / "Roaming"))
+        candidates = [
+            {"source": "custom", "path": os.getenv("CODEX_BIN", "")},
+            *[
+                {"source": "nvm", "path": str(Path("C:/nvm4w/nodejs") / name)}
+                for name in ("codex.cmd", "codex.ps1", "codex.exe")
+            ],
+            {"source": "cli", "path": shutil.which("codex") or ""},
+            *[
+                {"source": "npm", "path": str(Path(appdata) / "npm" / name)}
+                for name in ("codex.cmd", "codex.ps1", "codex.exe")
+            ],
+            *[
+                {"source": "npm", "path": str(home / ".npm-global" / "bin" / name)}
+                for name in ("codex.cmd", "codex.ps1", "codex.exe")
+            ],
+            *[
+                {"source": "cli", "path": str(home / ".local" / "bin" / name)}
+                for name in ("codex.exe", "codex.cmd", "codex.ps1")
+            ],
+            *[
+                {"source": "scoop", "path": str(home / "scoop" / "shims" / name)}
+                for name in ("codex.exe", "codex.cmd", "codex.ps1")
+            ],
+        ]
+        seen: set[str] = set()
+        out: list[dict[str, str]] = []
+        for candidate in candidates:
+            path = candidate.get("path") or ""
+            if not path or path in seen:
+                continue
+            seen.add(path)
+            out.append(candidate)
+        return out
+
+    candidates = [
+        {"source": "custom", "path": os.getenv("CODEX_BIN", "")},
+        {"source": "app", "path": "/Applications/Codex.app/Contents/Resources/codex"},
+        {"source": "app", "path": str(Path.home() / "Applications" / "Codex.app" / "Contents" / "Resources" / "codex")},
+        {"source": "cli", "path": shutil.which("codex") or ""},
+        {"source": "cli", "path": "/opt/homebrew/bin/codex"},
+        {"source": "cli", "path": "/usr/local/bin/codex"},
+    ]
+
+    seen: set[str] = set()
+    out: list[dict[str, str]] = []
+    for candidate in candidates:
+        path = candidate.get("path") or ""
+        if not path or path in seen:
+            continue
+        seen.add(path)
+        out.append(candidate)
+    return out

connector/launch.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import os
+import shutil
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+
+Launcher = Literal["direct", "powershell", "cmd"]
+
+
+@dataclass(frozen=True, slots=True)
+class LaunchTarget:
+    source: str
+    path: str
+    launcher: Launcher = "direct"
+
+    def command(self, args: list[str] | tuple[str, ...] = ()) -> list[str]:
+        argv = list(args)
+        if self.launcher == "powershell":
+            return [
+                _powershell_bin(),
+                "-NoProfile",
+                "-ExecutionPolicy",
+                "Bypass",
+                "-File",
+                self.path,
+                *argv,
+            ]
+        if self.launcher == "cmd":
+            script = _powershell_invoke_script(self.path, argv)
+            return [
+                _powershell_bin(),
+                "-NoProfile",
+                "-ExecutionPolicy",
+                "Bypass",
+                "-Command",
+                script,
+            ]
+        return [self.path, *argv]
+
+    def report_path(self) -> str:
+        return self.path
+
+
+def launch_target(source: str, path: str) -> LaunchTarget:
+    launcher: Launcher = "direct"
+    if sys.platform == "win32":
+        suffix = Path(path).suffix.lower()
+        if suffix == ".ps1":
+            launcher = "powershell"
+        elif suffix in {".cmd", ".bat"}:
+            launcher = "cmd"
+    return LaunchTarget(source=source, path=path, launcher=launcher)
+
+
+def command_name(name: str) -> LaunchTarget | None:
+    found = shutil.which(name)
+    if not found:
+        return None
+    return launch_target("cli", found)
+
+
+def existing_launch_targets(candidates: list[tuple[str, str]]) -> list[LaunchTarget]:
+    seen: set[str] = set()
+    out: list[LaunchTarget] = []
+    for source, raw in candidates:
+        path = expand_vars(raw)
+        if not path or path in seen:
+            continue
+        seen.add(path)
+        out.append(launch_target(source, path))
+    return out
+
+
+def expand_vars(value: str) -> str:
+    return os.path.expandvars(os.path.expanduser(value))
+
+
+def path_exists_for_launch(path: str) -> bool:
+    if not Path(path).is_file():
+        return False
+    if sys.platform == "win32":
+        return True
+    return os.access(path, os.X_OK)
+
+
+def _powershell_invoke_script(path: str, args: list[str]) -> str:
+    return " ".join(["&", _powershell_quote(path), *(_powershell_quote(arg) for arg in args)])
+
+
+def _cmd_quote(value: str) -> str:
+    escaped = value.replace('"', r'\"')
+    return f'"{escaped}"'
+
+
+def _powershell_quote(value: str) -> str:
+    return "'" + value.replace("'", "''") + "'"
+
+
+def _powershell_bin() -> str:
+    return shutil.which("powershell.exe") or shutil.which("powershell") or "powershell.exe"

connector/local/__init__.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+from connector.local.common import StaleFileError
+from connector.local.ops import LocalOps, create_local_ops
+
+__all__ = ["LocalOps", "StaleFileError", "create_local_ops"]

connector/local/common.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import Any, Awaitable, Callable
+
+
+MAX_DIR_ENTRIES = 500
+MAX_OUTPUT_CHARS = 64_000
+MAX_READ_TEXT_BYTES = 4 * 1024 * 1024
+
+Notify = Callable[[str, dict[str, Any]], Awaitable[None]]
+
+
+class StaleFileError(Exception):
+    """Raised when fs.writeFile's ifMatch check fails."""
+
+    code = "stale"
+
+
+def workspace_root(params: dict[str, Any]) -> Path:
+    raw_root = params.get("root") or params.get("cwd")
+    if not isinstance(raw_root, str) or not raw_root.strip():
+        raise ValueError("root is required")
+    return Path(raw_root).expanduser().resolve(strict=False)
+
+
+def resolve_path(root: Path, raw_path: str) -> Path:
+    path = Path(raw_path).expanduser()
+    if not path.is_absolute():
+        path = root / path
+    return path.resolve(strict=False)
+
+
+def nearest_existing_dir(path: Path, *, fallback: Path | None = None) -> Path:
+    """Return `path` if it is a directory, otherwise the closest existing parent.
+
+    Workspace paths can point at projects that were deleted or moved after a
+    session was recorded. Runtime panels should still open somewhere useful
+    instead of failing on a stale cwd/path.
+    """
+    current = path
+    while True:
+        if current.is_dir():
+            return current
+        parent = current.parent
+        if parent == current:
+            break
+        current = parent
+    if fallback is not None:
+        fallback_current = fallback
+        while True:
+            if fallback_current.is_dir():
+                return fallback_current
+            parent = fallback_current.parent
+            if parent == fallback_current:
+                break
+            fallback_current = parent
+    return Path.cwd()
+
+
+def required_string(params: dict[str, Any], key: str) -> str:
+    value = params.get(key)
+    if not isinstance(value, str) or not value:
+        raise ValueError(f"{key} is required")
+    return value
+
+
+def required_text(params: dict[str, Any], key: str) -> str:
+    value = params.get(key)
+    if not isinstance(value, str):
+        raise ValueError(f"{key} is required")
+    return value
+
+
+def required_int(params: dict[str, Any], key: str) -> int:
+    value = params.get(key)
+    if not isinstance(value, int):
+        raise ValueError(f"{key} is required")
+    return value
+
+
+def encoding(params: dict[str, Any]) -> str:
+    value = params.get("encoding", "utf8")
+    if value not in {"utf8", "utf-8"}:
+        raise ValueError("only utf8 encoding is supported")
+    return "utf-8"
+
+
+def decode_output(output: bytes) -> tuple[str, bool]:
+    text = output.decode("utf-8", errors="replace")
+    if len(text) <= MAX_OUTPUT_CHARS:
+        return text, False
+    return text[:MAX_OUTPUT_CHARS], True
+
+
+def shell_result(
+    cwd: Path,
+    command: str,
+    exit_code: int | None,
+    timed_out: bool,
+    start: float,
+    stdout: bytes,
+    stderr: bytes,
+) -> dict[str, Any]:
+    stdout_text, stdout_truncated = decode_output(stdout)
+    stderr_text, stderr_truncated = decode_output(stderr)
+    return {
+        "cwd": str(cwd),
+        "command": command,
+        "exitCode": exit_code,
+        "timedOut": timed_out,
+        "durationMs": int((time.monotonic() - start) * 1000),
+        "stdout": stdout_text,
+        "stderr": stderr_text,
+        "stdoutTruncated": stdout_truncated,
+        "stderrTruncated": stderr_truncated,
+    }

connector/local/file_ops.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+import mimetypes
+import hashlib
+from typing import Any
+
+from connector.local.common import (
+    MAX_DIR_ENTRIES,
+    MAX_READ_TEXT_BYTES,
+    StaleFileError,
+    encoding,
+    nearest_existing_dir,
+    required_string,
+    required_text,
+    resolve_path,
+    workspace_root,
+)
+
+
+class FileOps:
+    async def prepare_download(self, params: dict[str, Any]) -> dict[str, Any]:
+        root = workspace_root(params)
+        path = resolve_path(root, required_string(params, "path"))
+        if not path.is_file():
+            raise FileNotFoundError(f"file not found: {path}")
+        data = path.read_bytes()
+        return {
+            "path": str(path),
+            "name": path.name,
+            "size": len(data),
+            "sha256": hashlib.sha256(data).hexdigest(),
+            "mediaType": mimetypes.guess_type(path.name)[0] or "application/octet-stream",
+        }
+
+    def prepared_download_path(self, params: dict[str, Any]) -> str:
+        root = workspace_root(params)
+        return str(resolve_path(root, required_string(params, "path")))
+
+    async def write_file(self, params: dict[str, Any]) -> dict[str, Any]:
+        root = workspace_root(params)
+        path = resolve_path(root, required_string(params, "path"))
+        content_encoding = encoding(params)
+        content = required_text(params, "content")
+        if_match = params.get("ifMatch")
+        if not path.parent.is_dir():
+            raise FileNotFoundError(f"parent directory not found: {path.parent}")
+        if if_match is not None:
+            if not isinstance(if_match, str):
+                raise ValueError("ifMatch must be a sha256 hex string")
+            current_hash = ""
+            if path.is_file():
+                current_hash = hashlib.sha256(path.read_bytes()).hexdigest()
+            elif if_match != "":
+                raise StaleFileError(
+                    f"file disappeared (expected sha256={if_match})"
+                )
+            if if_match and current_hash != if_match:
+                raise StaleFileError(
+                    f"file changed on disk (expected sha256={if_match}, found sha256={current_hash or 'none'})"
+                )
+        data = content.encode(content_encoding)
+        path.write_bytes(data)
+        return {
+            "path": str(path),
+            "encoding": "utf8",
+            "bytesWritten": len(data),
+            "sha256": hashlib.sha256(data).hexdigest(),
+        }
+
+    async def read_text(self, params: dict[str, Any]) -> dict[str, Any]:
+        root = workspace_root(params)
+        path = resolve_path(root, required_string(params, "path"))
+        if not path.is_file():
+            raise FileNotFoundError(f"file not found: {path}")
+        raw_max = params.get("maxBytes", 1_048_576)
+        if not isinstance(raw_max, int):
+            raise ValueError("maxBytes must be an integer")
+        max_bytes = min(max(raw_max, 1), MAX_READ_TEXT_BYTES)
+        full = path.read_bytes()
+        clipped = full[:max_bytes]
+        truncated = len(full) > max_bytes
+        binary = b"\x00" in clipped
+        content = "" if binary else clipped.decode("utf-8", errors="replace")
+        return {
+            "path": str(path),
+            "name": path.name,
+            "size": len(full),
+            "sha256": hashlib.sha256(full).hexdigest(),
+            "encoding": "utf8",
+            "content": content,
+            "truncated": truncated,
+            "binary": binary,
+        }
+
+    async def read_dir(self, params: dict[str, Any]) -> dict[str, Any]:
+        root = workspace_root(params)
+        raw_path = params.get("path")
+        path = root if raw_path is None else resolve_path(root, required_string(params, "path"))
+        path = nearest_existing_dir(path, fallback=root)
+
+        entries: list[dict[str, Any]] = []
+        for child in sorted(path.iterdir(), key=lambda item: item.name):
+            if len(entries) >= MAX_DIR_ENTRIES:
+                break
+            try:
+                stat = child.stat()
+            except OSError:
+                stat = None
+            entries.append(
+                {
+                    "name": child.name,
+                    "path": str(child),
+                    "type": "directory" if child.is_dir() else "file" if child.is_file() else "other",
+                    "size": stat.st_size if stat is not None and child.is_file() else None,
+                }
+            )
+
+        return {
+            "path": str(path),
+            "entries": entries,
+            "truncated": len(entries) >= MAX_DIR_ENTRIES,
+        }

connector/local/ops.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import sys
+from typing import Any
+
+from connector.local.common import Notify
+from connector.local.file_ops import FileOps
+from connector.local.shell import ShellBackend, UnixShellBackend, WindowsShellBackend
+from connector.local.terminal import TerminalBackend, default_terminal_backend
+
+
+class LocalOps:
+    def __init__(
+        self,
+        *,
+        files: FileOps,
+        shell: ShellBackend,
+        terminal: TerminalBackend,
+    ) -> None:
+        self.files = files
+        self.shell = shell
+        self.terminal = terminal
+
+    @property
+    def notify(self) -> Notify | None:
+        return self.shell.notify
+
+    @notify.setter
+    def notify(self, value: Notify | None) -> None:
+        self.shell.notify = value
+        self.terminal.notify = value
+
+    async def prepare_download(self, params: dict[str, Any]) -> dict[str, Any]:
+        return await self.files.prepare_download(params)
+
+    def prepared_download_path(self, params: dict[str, Any]) -> str:
+        return self.files.prepared_download_path(params)
+
+    async def write_file(self, params: dict[str, Any]) -> dict[str, Any]:
+        return await self.files.write_file(params)
+
+    async def read_text(self, params: dict[str, Any]) -> dict[str, Any]:
+        return await self.files.read_text(params)
+
+    async def read_dir(self, params: dict[str, Any]) -> dict[str, Any]:
+        return await self.files.read_dir(params)
+
+    async def shell_exec(self, params: dict[str, Any]) -> dict[str, Any]:
+        return await self.shell.exec(params)
+
+    async def shell_task_start(self, params: dict[str, Any]) -> dict[str, Any]:
+        return await self.shell.task_start(params)
+
+    async def shell_task_cancel(self, params: dict[str, Any]) -> dict[str, Any]:
+        return await self.shell.task_cancel(params)
+
+    async def terminal_create(self, params: dict[str, Any]) -> dict[str, Any]:
+        return await self.terminal.create(params)
+
+    async def terminal_write(self, params: dict[str, Any]) -> dict[str, Any]:
+        return await self.terminal.write(params)
+
+    async def terminal_resize(self, params: dict[str, Any]) -> dict[str, Any]:
+        return await self.terminal.resize(params)
+
+    async def terminal_close(self, params: dict[str, Any]) -> dict[str, Any]:
+        return await self.terminal.close(params)
+
+    async def terminal_list(self, params: dict[str, Any]) -> dict[str, Any]:
+        return await self.terminal.list(params)
+
+
+def create_local_ops(
+    notify: Notify | None = None,
+) -> LocalOps:
+    files = FileOps()
+    shell: ShellBackend
+    if sys.platform == "win32":
+        shell = WindowsShellBackend(notify=notify)
+    else:
+        shell = UnixShellBackend(notify=notify)
+    terminal = default_terminal_backend(notify=notify)
+    return LocalOps(files=files, shell=shell, terminal=terminal)