anywhere-cli 0.1.0__py3-none-any.whl

anywhere_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: anywhere-cli
+Version: 0.1.0
+Summary: Local runtime connector for Agents Anywhere
+Requires-Python: >=3.12
+Requires-Dist: claude-agent-sdk
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: pexpect>=4.9.0; sys_platform != 'win32'
+Requires-Dist: ptyprocess>=0.7.0; sys_platform != 'win32'
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pyte>=0.8.2
+Requires-Dist: pywinpty>=2.0.13; sys_platform == 'win32'
+Requires-Dist: websockets>=16.0
+Description-Content-Type: text/markdown
+
+# Anywhere CLI
+
+Local runtime connector for Agents Anywhere. It runs on the machine that owns
+the workspace and agent runtimes, connects to the server over HTTP/WebSocket,
+executes connector RPC locally, and uploads normalized runtime/session state
+back to the backend.
+
+## Layout
+
+```text
+connector/
+  claude/       Claude Code discovery, adapter, reducer, and transcript logic
+  codex/        Codex app-server discovery, RPC, adapter, and reducer logic
+  local/        Local filesystem, shell, and terminal backends
+  cli.py        anywhere-cli CLI
+  runtime.py    Connector config, auth, WebSocket loop, and RPC dispatch
+tests/          Connector tests
+pyproject.toml  Connector dependencies and console script
+run.sh          Local helper for saved-config startup
+```
+
+## Run
+
+Install dependencies:
+
+```bash
+uv sync
+```
+
+Start with explicit credentials from the web pairing flow:
+
+```bash
+uvx anywhere-cli start \
+  --server-url http://127.0.0.1:8000 \
+  --connector-id conn_xxx \
+  --connector-token cxt_xxx
+```
+
+Or save the config locally and start without arguments:
+
+```bash
+uvx anywhere-cli configure \
+  --server-url http://127.0.0.1:8000 \
+  --connector-id conn_xxx \
+  --connector-token cxt_xxx
+
+uvx anywhere-cli start
+```
+
+The default config path is `~/.agent-server/connector.json`. Override it with
+`--config` or `AGENT_CONNECTOR_CONFIG`.
+
+## Runtime Discovery
+
+The connector discovers Codex and Claude locally and reports attached runtime
+capabilities to the server. If a runtime is not on `PATH`, set one of:
+
+```bash
+CODEX_BIN=/path/to/codex
+CLAUDE_BIN=/path/to/claude
+```
+
+The connector uses local runtime credentials and local filesystem permissions.
+Agents Anywhere does not proxy Claude or Codex account credentials.
+
+## Local Operations
+
+The server can ask an online connector to perform local work:
+
+- read/list/write files inside workspace-safe roots
+- upload/download file content through the server
+- run one-shot shell commands
+- start and wait for shell tasks
+- create, write, resize, stream, list, and close interactive terminals
+- start, interrupt, sync, and approve runtime turns
+
+## Environment
+
+| Variable | Purpose |
+| --- | --- |
+| `AGENT_CONNECTOR_CONFIG` | Connector config path. |
+| `AGENT_SERVER_URL` | Server URL used when `--server-url` is omitted. |
+| `AGENT_CONNECTOR_ID` | Connector id used when `--connector-id` is omitted. |
+| `AGENT_CONNECTOR_TOKEN` | Connector token used when `--connector-token` is omitted. |
+| `AGENT_CONNECTOR_ATTACHMENTS_ROOT` | Runtime attachment download directory. Defaults to `~/.agents-anywhere/attachments`. |
+| `CODEX_BIN` | Explicit Codex CLI/app-server path. |
+| `CLAUDE_BIN` | Explicit Claude Code CLI path. |
+
+## Verify
+
+```bash
+uv run ruff check connector tests
+uv run pytest -q
+```

anywhere_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,36 @@
+connector/__init__.py,sha256=uSDSaR-MjP0aiGRJv852lhPq5gjGJgWJ87a5MDZw3Sk,132
+connector/adapter.py,sha256=vDkyu1U5BzcbJAlKWuxPpBNgm_9t3qkZbRqV1pi-tZU,1323
+connector/attachments.py,sha256=Xy1FEh04WNPUCsobVESISvNdAfGBVM3Su5ddHKBRWZU,1259
+connector/capabilities.py,sha256=9N2UliuL0A3JQa4q3-1qhHmRM2FsJutBZNOvHfpZLpU,11426
+connector/cli.py,sha256=-D_fb9NP-cH_u1Ya3NN6v_CknWX6iNAf2jzJo2Zymuo,5680
+connector/launch.py,sha256=RJEN4BUQ_itdfRy6_E1nMdsXnFSmpUBjUhGJ8ELr1F4,2783
+connector/local_ops.py,sha256=1MTXYxcgH6Aw2DTPF1IPqen-WLSxRdCGQFcYCTiYS88,169
+connector/protocol.py,sha256=JEo2Y-Op-R_1bWvidieHG4U1-V52-OX0rplXWrzMVno,512
+connector/runtime.py,sha256=DP7RxGw2j7Tjw99Kzo41rmOBgE5eVEzd_tsafc_YnHs,45587
+connector/sync_state.py,sha256=3_U66rcC9LT1emE6Pbc967DL5MwxgZrH6QUCedM1bw4,5040
+connector/time.py,sha256=ZDCx-RaEQ0xU6siWnnnRsS7MNHy_RTkdEaiuZisDLjE,159
+connector/claude/__init__.py,sha256=lTL6yk26FR9RJ6du1DsIgVPIPH434wBpZcqn59FszMQ,243
+connector/claude/history_adapter.py,sha256=i1IU4Oj3wh4tXZ9VaIqeLrF1zgCqEUbK2lxVQnoNK8M,22859
+connector/claude/normalized.py,sha256=8MAErEZh7M4zLFWtJIbJ2apL8O8bxJEBNUPowQrxChw,687
+connector/claude/normalizers.py,sha256=HU4-TlZimCxQHg1_gNnLg5bzeiEQVu3B0pSdG_ccfiU,4117
+connector/claude/path_utils.py,sha256=QfXudfFUDto8rvKUoTaJ8gvOudcalTpdPx6dlWVmosA,483
+connector/claude/preferences.py,sha256=pHPUPs-gaVnoejZqwJK6tz4Zzy_V6P81EzKzVSJyRDI,1351
+connector/claude/sdk_adapter.py,sha256=-mm_XeCWqisB_CyIvjwNLULX6_Urrvsv9spIX3j_w7A,53578
+connector/claude/timeline_identity.py,sha256=5F4B6cH6baYkAE1JqcD-PxuzUNKFzLYuHzb3xlFpzG8,1365
+connector/claude/timeline_reducer.py,sha256=okS7VWLU-uGsVeH13bPqVYLcvYSZUATesvtDOghhJo0,13589
+connector/claude/trust.py,sha256=Z1cvFywh1zIbMg7DDXA7QMCwU32jTszoGBBxuMuDSpA,2139
+connector/codex/__init__.py,sha256=TeU5p5BpXLAaEaJdtJFCqbY1_QMi4R9SNKorfbOaXnk,77
+connector/codex/adapter.py,sha256=87J7CBwAQ-8ZSHS7jk2Or8s-3WJNAic_Tz0ynGmFPso,39368
+connector/codex/history.py,sha256=FqnMAmbmzZQkxU302-FIrd5JRvaVP0sOiMRNJ2wC6Vc,7001
+connector/codex/reducer.py,sha256=pWf-8OxzAf4wHHbvpj_4PlVrgUlMWhlTdddhdryJnPc,46401
+connector/codex/rpc.py,sha256=4pBZ88ebCt--W1-j1Zb7TbzMt4YEuNQnttBAluGgRwY,10320
+connector/local/__init__.py,sha256=Z6asmJEqFmAMGJ6Ia1ENN17j0AZfbX53zOSLcgl8ojw,207
+connector/local/common.py,sha256=43DE1ldHwworQ_CeHh_F4n0aHw9UUBD5sYmS_t80Jso,3391
+connector/local/file_ops.py,sha256=PApqYt4zmedoI91sfKwKh2OqJ1aV8LQcaBPF4XSUNb4,4578
+connector/local/ops.py,sha256=CMBkhV8a3jzDZP7K5e4NJwgMhLTily7pUnujgpBj4sU,2849
+connector/local/shell.py,sha256=HgHtkJmlnm0S2eyA3ZfKq6YjRpRKYarmmx1xJ4rnwwg,8375
+connector/local/terminal.py,sha256=QqdvF-7Fc4zfyDJXh-jggCkbzdt910LigH1zywaA2oY,13667
+anywhere_cli-0.1.0.dist-info/METADATA,sha256=io0JQQ2Cz0s9klE5RVo6zz9Z55tFVecsmJ5X5GVFKcg,3289
+anywhere_cli-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+anywhere_cli-0.1.0.dist-info/entry_points.txt,sha256=Y5lMVaUcp_EkVgEsOHdVOmGpBpKDX26UISSww2EEMe4,89
+anywhere_cli-0.1.0.dist-info/RECORD,,

anywhere_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

anywhere_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+agent-connector = connector.cli:main
+anywhere-cli = connector.cli:main

connector/__init__.py

@@ -0,0 +1,3 @@
+from connector.protocol import RpcNotification, RpcRequest, RpcResponse
+
+__all__ = ["RpcNotification", "RpcRequest", "RpcResponse"]

connector/adapter.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from typing import Any, Protocol, runtime_checkable
+
+
+NotificationSink = Callable[[str, dict[str, Any]], Awaitable[None]] | None
+
+
+@runtime_checkable
+class Adapter(Protocol):
+    """Per-runtime backend client (Codex / Claude / OpenCode / ACP).
+
+    `BackendRpcClient` holds a dict of these keyed by runtime name and routes
+    incoming RPCs by `params["runtime"]`. Every adapter must accept a
+    `notification_sink` for pushing reduced backend notifications upstream
+    (set after construction by the client).
+    """
+
+    notification_sink: NotificationSink
+
+    async def create_session(self, params: dict[str, Any]) -> dict[str, Any]: ...
+
+    async def sync_session(self, params: dict[str, Any]) -> dict[str, Any]: ...
+
+    async def sync_existing_sessions(
+        self,
+        connector_id: str,
+        *,
+        limit: int = 100,
+        force: bool = False,
+        notification_sink: Callable[[list[dict[str, Any]]], Awaitable[None]] | None = None,
+    ) -> dict[str, Any]: ...
+
+    async def start_turn(self, params: dict[str, Any]) -> dict[str, Any]: ...
+
+    async def interrupt_turn(self, params: dict[str, Any]) -> dict[str, Any]: ...
+
+    async def resolve_approval(self, params: dict[str, Any]) -> dict[str, Any]: ...

connector/attachments.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+
+ATTACHMENTS_ROOT_ENV = "AGENT_CONNECTOR_ATTACHMENTS_ROOT"
+DEFAULT_ATTACHMENTS_DIR = ".agents-anywhere/attachments"
+_SAFE_FILENAME_RE = re.compile(r"[^\w.\-+]+")
+
+
+def attachments_root() -> Path:
+    """Return the connector-local root used for runtime attachment copies."""
+    import os
+
+    configured = os.environ.get(ATTACHMENTS_ROOT_ENV)
+    root = Path(configured).expanduser() if configured else Path.home() / DEFAULT_ATTACHMENTS_DIR
+    return root.resolve(strict=False)
+
+
+def session_attachments_dir(session_id: str) -> Path:
+    session = _safe_filename(session_id) or "session"
+    return attachments_root() / session
+
+
+def attachment_target(session_id: str, file_id: str, original_name: str | None) -> Path:
+    safe_file_id = _safe_filename(file_id) or "file"
+    safe_name = _safe_filename(original_name or "") or safe_file_id
+    return session_attachments_dir(session_id) / f"{safe_file_id}-{safe_name}"
+
+
+def _safe_filename(name: str) -> str:
+    """Reduce arbitrary user/server values to safe single path components."""
+    name = name.rsplit("/", 1)[-1].rsplit("\\", 1)[-1]
+    sanitized = _SAFE_FILENAME_RE.sub("_", name).strip("._") or ""
+    return sanitized[:120]

connector/capabilities.py

@@ -0,0 +1,334 @@
+from __future__ import annotations
+
+import asyncio
+import importlib
+import os
+import shutil
+import sys
+import time
+from collections.abc import Iterable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from connector.launch import LaunchTarget, launch_target, path_exists_for_launch
+from connector.codex.rpc import JsonRpcStdioClient, codex_candidate_paths
+
+
+_CODEX_CHECK_TIMEOUT_S = 8.0
+_COMMAND_CHECK_TIMEOUT_S = 8.0
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeDiscovery:
+    report: dict[str, Any]
+    codex_bin: str | None = None
+    claude_bin: str | None = None
+    codex_target: LaunchTarget | None = None
+    claude_target: LaunchTarget | None = None
+
+
+async def discover_runtime_capabilities() -> RuntimeDiscovery:
+    started = time.perf_counter()
+    codex_report, codex_target = await discover_codex_capability()
+    claude_report, claude_target = await discover_claude_capability()
+    return RuntimeDiscovery(
+        report={
+            "version": 1,
+            "checkedAt": _now_iso(),
+            "elapsedMs": round((time.perf_counter() - started) * 1000, 1),
+            "runtimes": {
+                "codex": codex_report,
+                "claude": claude_report,
+            },
+        },
+        codex_bin=codex_target.path if codex_target else None,
+        claude_bin=claude_target.path if claude_target else None,
+        codex_target=codex_target,
+        claude_target=claude_target,
+    )
+
+
+async def discover_codex_capability(
+    *, extra_candidate: str | None = None
+) -> tuple[dict[str, Any], LaunchTarget | None]:
+    """Scan the local machine for a usable Codex install.
+
+    `extra_candidate`, when set, is checked first as `source="custom"`. Used
+    by the per-runtime scan endpoint when the user types a custom path in the
+    Add Agent modal.
+    """
+    candidates = codex_candidate_paths()
+    if extra_candidate:
+        candidates = _dedupe_candidates(
+            [{"source": "custom", "path": extra_candidate}, *candidates]
+        )
+    checked: list[dict[str, Any]] = []
+    for candidate in candidates:
+        target = _target_from_candidate(candidate)
+        result = await _check_codex_candidate(candidate)
+        checked.append(result)
+        if result["status"] == "ok":
+            return (
+                {
+                    "history": "ok",
+                    "execution": "ok",
+                    "selected": _selected_from_check(result),
+                    "checked": checked,
+                },
+                target,
+            )
+    return (
+        {
+            "history": "unavailable",
+            "execution": "unavailable",
+            "error": {
+                "code": "codex_unavailable",
+                "message": (
+                    "Codex is unavailable or broken. Checked custom path, Codex App, "
+                    "and Codex CLI. Plugin-based Codex installations are not supported yet."
+                ),
+            },
+            "checked": checked,
+        },
+        None,
+    )
+
+
+async def discover_claude_capability(
+    *, extra_candidate: str | None = None
+) -> tuple[dict[str, Any], LaunchTarget | None]:
+    history = _check_claude_history()
+    candidates = _claude_candidate_paths()
+    if extra_candidate:
+        candidates = _dedupe_candidates(
+            [{"source": "custom", "path": extra_candidate}, *candidates]
+        )
+    checked: list[dict[str, Any]] = []
+    selected_target: LaunchTarget | None = None
+    execution = "unavailable"
+    for candidate in candidates:
+        target = _target_from_candidate(candidate)
+        result = await _check_claude_candidate(candidate)
+        checked.append(result)
+        if result["status"] == "ok":
+            selected_target = target
+            execution = "ok"
+            break
+
+    report: dict[str, Any] = {
+        "history": history["status"],
+        "execution": execution,
+        "historyCheck": history,
+        "checked": checked,
+    }
+    if selected_target is not None:
+        report["selected"] = _selected_from_check(checked[-1])
+    else:
+        report["error"] = {
+            "code": "claude_cli_unavailable",
+            "message": "Claude Code is unavailable or broken. Checked CLAUDE_BIN, PATH, and common install paths.",
+        }
+    return report, selected_target
+
+
+async def _check_codex_candidate(candidate: dict[str, str] | LaunchTarget) -> dict[str, Any]:
+    target = _target_from_candidate(candidate)
+    path = target.path
+    source = target.source
+    base = {"source": source, "path": path}
+    if not Path(path).is_file():
+        return {**base, "status": "missing", "reason": "file not found"}
+    if not path_exists_for_launch(path):
+        return {**base, "status": "failed", "reason": "not executable"}
+
+    version = await _run_version(target.command(["--version"]))
+    if version["status"] != "ok":
+        return {**base, "status": "failed", "stage": "version", **version}
+
+    client = JsonRpcStdioClient(command=target.command(["app-server", "--listen", "stdio://"]))
+    try:
+        await asyncio.wait_for(client.start(lambda _payload: _noop()), timeout=_CODEX_CHECK_TIMEOUT_S)
+        list_result = await asyncio.wait_for(
+            client.request("thread/list", {"limit": 1, "sortKey": "updated_at"}),
+            timeout=_CODEX_CHECK_TIMEOUT_S,
+        )
+    except Exception as exc:
+        return {
+            **base,
+            "status": "failed",
+            "stage": "app-server",
+            "version": version.get("stdout"),
+            "reason": _exception_reason(exc),
+        }
+    finally:
+        try:
+            await client.close()
+        except Exception:
+            pass
+
+    return {
+        **base,
+        "status": "ok",
+        "version": version.get("stdout"),
+        "threadListKeys": sorted(list_result.keys()),
+    }
+
+
+async def _check_claude_candidate(candidate: dict[str, str] | LaunchTarget) -> dict[str, Any]:
+    target = _target_from_candidate(candidate)
+    path = target.path
+    source = target.source
+    base = {"source": source, "path": path}
+    if not Path(path).is_file():
+        return {**base, "status": "missing", "reason": "file not found"}
+    if not path_exists_for_launch(path):
+        return {**base, "status": "failed", "reason": "not executable"}
+
+    version = await _run_version(target.command(["--version"]))
+    if version["status"] != "ok":
+        return {**base, "status": "failed", "stage": "version", **version}
+    help_result = await _run_version(target.command(["--help"]))
+    if help_result["status"] != "ok":
+        return {
+            **base,
+            "status": "failed",
+            "stage": "help",
+            "version": version.get("stdout"),
+            "reason": help_result.get("reason"),
+        }
+    return {**base, "status": "ok", "version": version.get("stdout")}
+
+
+def _check_claude_history() -> dict[str, Any]:
+    source = "claude-agent-sdk"
+    api = "list_sessions"
+    try:
+        sessions = _list_claude_sdk_sessions()
+    except Exception as exc:
+        return {
+            "status": "unavailable",
+            "source": source,
+            "api": api,
+            "reason": _exception_reason(exc),
+        }
+    return {
+        "status": "ok" if sessions else "ok_empty",
+        "source": source,
+        "api": api,
+        "sessionCount": len(sessions),
+    }
+
+
+def _list_claude_sdk_sessions() -> list[Any]:
+    sdk = importlib.import_module("claude_agent_sdk")
+    list_sessions = getattr(sdk, "list_sessions")
+    return list(list_sessions())
+
+
+async def _run_version(command: list[str]) -> dict[str, Any]:
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            *command,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=_COMMAND_CHECK_TIMEOUT_S)
+    except Exception as exc:
+        return {"status": "failed", "reason": _exception_reason(exc)}
+    out = stdout.decode(errors="replace").strip()
+    err = stderr.decode(errors="replace").strip()
+    if proc.returncode != 0:
+        return {
+            "status": "failed",
+            "reason": f"exit {proc.returncode}",
+            "stdout": out[:500],
+            "stderr": err[:500],
+        }
+    return {"status": "ok", "stdout": out[:500], "stderr": err[:500]}
+
+
+def _claude_candidate_paths() -> list[dict[str, str]]:
+    if sys.platform == "win32":
+        home = Path.home()
+        appdata = os.environ.get("APPDATA", str(home / "AppData" / "Roaming"))
+        return _dedupe_candidates(
+            [
+                {"source": "custom", "path": os.environ.get("CLAUDE_BIN", "")},
+                {"source": "cli", "path": shutil.which("claude") or ""},
+                *[
+                    {"source": "cli", "path": str(home / ".local" / "bin" / name)}
+                    for name in ("claude.exe", "claude.cmd", "claude.ps1")
+                ],
+                *[
+                    {"source": "npm", "path": str(Path(appdata) / "npm" / name)}
+                    for name in ("claude.cmd", "claude.ps1", "claude.exe")
+                ],
+                *[
+                    {"source": "npm", "path": str(home / ".npm-global" / "bin" / name)}
+                    for name in ("claude.cmd", "claude.ps1", "claude.exe")
+                ],
+                *[
+                    {"source": "nvm", "path": str(Path("C:/nvm4w/nodejs") / name)}
+                    for name in ("claude.cmd", "claude.ps1", "claude.exe")
+                ],
+                *[
+                    {"source": "scoop", "path": str(home / "scoop" / "shims" / name)}
+                    for name in ("claude.exe", "claude.cmd", "claude.ps1")
+                ],
+            ]
+        )
+    return _dedupe_candidates(
+        [
+            {"source": "custom", "path": os.environ.get("CLAUDE_BIN", "")},
+            {"source": "cli", "path": shutil.which("claude") or ""},
+            {"source": "cli", "path": str(Path.home() / ".npm-global" / "bin" / "claude")},
+            {"source": "cli", "path": str(Path.home() / ".local" / "bin" / "claude")},
+            {"source": "cli", "path": "/opt/homebrew/bin/claude"},
+            {"source": "cli", "path": "/usr/local/bin/claude"},
+        ]
+    )
+
+
+def _target_from_candidate(candidate: dict[str, str] | LaunchTarget) -> LaunchTarget:
+    if isinstance(candidate, LaunchTarget):
+        return candidate
+    return launch_target(candidate["source"], candidate["path"])
+
+
+def _dedupe_candidates(candidates: Iterable[dict[str, str]]) -> list[dict[str, str]]:
+    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
+
+
+def _selected_from_check(result: dict[str, Any]) -> dict[str, Any]:
+    selected = {
+        "source": result["source"],
+        "path": result["path"],
+    }
+    if result.get("version"):
+        selected["version"] = result["version"]
+    return selected
+
+
+def _exception_reason(exc: BaseException) -> str:
+    if isinstance(exc, TimeoutError):
+        return "timeout"
+    return str(exc) or exc.__class__.__name__
+
+
+def _now_iso() -> str:
+    from datetime import UTC, datetime
+
+    return datetime.now(UTC).isoformat().replace("+00:00", "Z")
+
+
+async def _noop() -> None:
+    return None

connector/claude/__init__.py

@@ -0,0 +1,8 @@
+from connector.claude.preferences import read_local_preferences
+from connector.claude.sdk_adapter import ClaudeSdkAdapter, ClaudeSdkAdapterError
+
+__all__ = [
+    "ClaudeSdkAdapter",
+    "ClaudeSdkAdapterError",
+    "read_local_preferences",
+]