anywhere-cli 0.1.0__py3-none-any.whl

connector/claude/timeline_identity.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from typing import Any
+
+
+class ClaudeTimelineIdentity:
+    @staticmethod
+    def message(*, session_id: str, claude_session_id: str, message_id: str) -> str:
+        return f"claude_msg_{_short('message', claude_session_id, message_id)}"
+
+    @staticmethod
+    def tool_call(
+        *,
+        session_id: str,
+        claude_session_id: str,
+        tool_use_id: str,
+    ) -> str:
+        return f"claude_tool_{_short('tool', claude_session_id, tool_use_id)}"
+
+    @staticmethod
+    def tool_result(
+        *,
+        session_id: str,
+        claude_session_id: str,
+        tool_use_id: str,
+    ) -> str:
+        return ClaudeTimelineIdentity.tool_call(
+            session_id=session_id,
+            claude_session_id=claude_session_id,
+            tool_use_id=tool_use_id,
+        )
+
+    @staticmethod
+    def derived(*values: Any) -> str:
+        return f"claude_derived_{_short(*values)}"
+
+
+def content_hash(*values: Any) -> str:
+    payload = json.dumps(values, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+    return "sha256:" + hashlib.sha256(payload.encode("utf-8")).hexdigest()
+
+
+def _short(*values: Any) -> str:
+    payload = json.dumps(values, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+    return hashlib.sha256(payload.encode("utf-8")).hexdigest()[:24]

connector/claude/timeline_reducer.py

@@ -0,0 +1,379 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from connector.claude.normalized import NormalizedClaudeEvent
+from connector.claude.timeline_identity import ClaudeTimelineIdentity, content_hash
+
+
+class ClaudeTimelineReducer:
+    def reduce(
+        self,
+        *,
+        session_id: str,
+        turn_id: str,
+        events: list[NormalizedClaudeEvent],
+    ) -> list[dict[str, Any]]:
+        items: dict[str, dict[str, Any]] = {}
+        ignored_tool_use_ids: set[str] = set()
+        order_seq = 1
+        for event in events:
+            if event.toolUseId and event.toolResult is None and is_task_event_tool_name(event.toolName):
+                ignored_tool_use_ids.add(event.toolUseId)
+                continue
+            if event.toolUseId and event.toolResult is not None and event.toolUseId in ignored_tool_use_ids:
+                continue
+            item = self._reduce_event(session_id=session_id, turn_id=turn_id, event=event, order_seq=order_seq)
+            if item is None:
+                continue
+            existing = items.get(item["id"])
+            if existing is None:
+                items[item["id"]] = item
+                order_seq += 1
+                continue
+            items[item["id"]] = _merge_item(existing, item)
+        return sorted(items.values(), key=lambda item: int(item.get("orderSeq") or 0))
+
+    def _reduce_event(
+        self,
+        *,
+        session_id: str,
+        turn_id: str,
+        event: NormalizedClaudeEvent,
+        order_seq: int,
+    ) -> dict[str, Any] | None:
+        message_id = event.messageId or event.sourceEventId
+        if event.toolUseId and event.toolResult is not None:
+            item_id = ClaudeTimelineIdentity.tool_result(
+                session_id=session_id,
+                claude_session_id=event.claudeSessionId,
+                tool_use_id=event.toolUseId,
+            )
+            content = _tool_result_content(event)
+            status = "failed" if event.toolResultIsError else "done"
+            return {
+                "id": item_id,
+                "sessionId": session_id,
+                "turnId": turn_id,
+                "type": "tool",
+                "status": status,
+                "role": "tool",
+                "content": content,
+                "source": _source(event, turn_id, "tool_result"),
+                "orderSeq": order_seq,
+                "revision": 1,
+                "contentHash": content_hash(content),
+                "createdAt": event.timestamp,
+                "updatedAt": event.timestamp,
+                "completedAt": event.timestamp,
+            }
+
+        if event.toolUseId:
+            item_id = ClaudeTimelineIdentity.tool_call(
+                session_id=session_id,
+                claude_session_id=event.claudeSessionId,
+                tool_use_id=event.toolUseId,
+            )
+            content = _tool_call_content(event)
+            return {
+                "id": item_id,
+                "sessionId": session_id,
+                "turnId": turn_id,
+                "type": "tool",
+                "status": "running",
+                "role": "tool",
+                "content": content,
+                "source": _source(event, turn_id, "tool_use"),
+                "orderSeq": order_seq,
+                "revision": 1,
+                "contentHash": content_hash(content),
+                "createdAt": event.timestamp,
+                "updatedAt": event.timestamp,
+            }
+
+        if event.role in {"user", "assistant", "system"} and event.text is not None and event.text.strip():
+            item_id = ClaudeTimelineIdentity.message(
+                session_id=session_id,
+                claude_session_id=event.claudeSessionId,
+                message_id=message_id,
+            )
+            content = {"text": event.text}
+            if event.attachments:
+                content["attachments"] = event.attachments
+            source = _source(event, turn_id, "message")
+            if event.clientMessageId:
+                source["clientMessageId"] = event.clientMessageId
+            return {
+                "id": item_id,
+                "sessionId": session_id,
+                "turnId": turn_id,
+                "type": "message",
+                "status": "done",
+                "role": event.role,
+                "content": content,
+                "source": source,
+                "orderSeq": order_seq,
+                "revision": 1,
+                "contentHash": content_hash(content),
+                "createdAt": event.timestamp,
+                "updatedAt": event.timestamp,
+                "completedAt": event.timestamp,
+            }
+        return None
+
+
+def _source(event: NormalizedClaudeEvent, turn_id: str, derived_key: str) -> dict[str, Any]:
+    return {
+        "runtime": "claude",
+        "sessionId": event.claudeSessionId,
+        "turnId": turn_id,
+        "itemId": event.toolUseId or event.messageId or event.sourceEventId,
+        "itemType": event.blockType,
+        "event": event.sourceEventId,
+        "derivedKey": derived_key,
+    }
+
+
+def _tool_kind(tool_name: str | None) -> str:
+    if _mcp_parts(tool_name) is not None:
+        return "mcp"
+    if tool_name in {"Edit", "Write", "NotebookEdit"}:
+        return "file_change"
+    if tool_name == "MultiEdit":
+        return "file_change"
+    if tool_name == "Bash":
+        return "command"
+    if tool_name in {"WebFetch", "WebSearch"}:
+        return "web_search"
+    return "tool"
+
+
+def is_task_event_tool_name(tool_name: str | None) -> bool:
+    """Claude Code task bookkeeping tools should not become user-visible tools.
+
+    Keep the real Claude sub-agent tool named exactly "Task"; hide status/event
+    tools such as TaskCreate and TaskUpdate.
+    """
+    return bool(tool_name and tool_name != "Task" and tool_name.startswith("Task") and len(tool_name) > 4 and tool_name[4].isupper())
+
+
+def _merge_item(existing: dict[str, Any], incoming: dict[str, Any]) -> dict[str, Any]:
+    if existing.get("type") == "tool" and incoming.get("status") in {"done", "failed", "interrupted", "cancelled"}:
+        data = dict(existing)
+        content = dict(data.get("content") or {})
+        incoming_content = incoming.get("content")
+        content.update(incoming_content if isinstance(incoming_content, dict) else {})
+        data["content"] = content
+        data["status"] = incoming.get("status")
+        data["role"] = incoming.get("role") or data.get("role")
+        data["revision"] = int(data.get("revision") or 1) + 1
+        data["contentHash"] = content_hash(content)
+        data["updatedAt"] = incoming.get("updatedAt")
+        data["completedAt"] = incoming.get("completedAt")
+        return data
+    if _content_score(incoming.get("content")) > _content_score(existing.get("content")):
+        return incoming
+    return existing
+
+
+def _content_score(content: Any) -> int:
+    return len(str(content or ""))
+
+
+def _tool_call_content(event: NormalizedClaudeEvent) -> dict[str, Any]:
+    tool_name = event.toolName or "tool"
+    tool_input = event.toolInput if isinstance(event.toolInput, dict) else event.toolInput
+    common = _tool_common(event)
+    kind = _tool_kind(tool_name)
+    if kind == "command":
+        input_data = tool_input if isinstance(tool_input, dict) else {}
+        command = _string(input_data.get("command") or input_data.get("cmd")) or ""
+        content = {
+            **common,
+            "kind": "command",
+            "command": command,
+            "description": _string(input_data.get("description")) or command,
+            "cwd": _string(input_data.get("cwd")),
+        }
+        if isinstance(input_data.get("run_in_background"), bool):
+            content["runInBackground"] = input_data.get("run_in_background")
+        return _strip_empty(content)
+
+    if kind == "file_change":
+        return _strip_empty({
+            **common,
+            "kind": "file_change",
+            "changes": _file_changes(tool_name, tool_input),
+        })
+
+    if kind == "web_search":
+        input_data = tool_input if isinstance(tool_input, dict) else {}
+        return _strip_empty({
+            **common,
+            "kind": "web_search",
+            "query": _string(input_data.get("query")),
+            "url": _string(input_data.get("url")),
+            "action": input_data,
+        })
+
+    mcp = _mcp_parts(tool_name)
+    if mcp is not None:
+        server, tool = mcp
+        return _strip_empty({
+            **common,
+            "kind": "mcp",
+            "server": server,
+            "tool": tool,
+            "arguments": tool_input if isinstance(tool_input, dict) else {},
+            "result": None,
+            "error": None,
+        })
+
+    return _strip_empty({
+        **common,
+        "kind": "tool",
+        "name": tool_name,
+        "tool": tool_name,
+        "arguments": tool_input if isinstance(tool_input, dict) else tool_input,
+    })
+
+
+def _tool_result_content(event: NormalizedClaudeEvent) -> dict[str, Any]:
+    text = _result_text(event.toolResult)
+    content: dict[str, Any] = {
+        "toolUseId": event.toolUseId,
+        "result": event.toolResult,
+        "text": text,
+        "outputText": text,
+        "outputPreview": _preview_text(text),
+        "outputLength": len(text),
+    }
+    if event.toolResultIsError:
+        content["isError"] = True
+        content["error"] = text
+    return content
+
+
+def _tool_common(event: NormalizedClaudeEvent) -> dict[str, Any]:
+    return {
+        "toolUseId": event.toolUseId,
+        "toolName": event.toolName,
+        "input": event.toolInput,
+    }
+
+
+def _file_changes(tool_name: str, tool_input: Any) -> list[dict[str, Any]]:
+    input_data = tool_input if isinstance(tool_input, dict) else {}
+    if tool_name == "Write":
+        path = _string(input_data.get("file_path") or input_data.get("path")) or ""
+        text = _string(input_data.get("content")) or ""
+        return [_strip_empty({
+            "path": path,
+            "action": "add",
+            "kind": {"type": "add"},
+            "diff": text,
+        })]
+    if tool_name == "Edit":
+        path = _string(input_data.get("file_path") or input_data.get("path")) or ""
+        return [_strip_empty({
+            "path": path,
+            "action": "update",
+            "kind": {"type": "update"},
+            "diff": _edit_diff(
+                path,
+                _string(input_data.get("old_string")) or "",
+                _string(input_data.get("new_string")) or "",
+            ),
+        })]
+    if tool_name == "MultiEdit":
+        path = _string(input_data.get("file_path") or input_data.get("path")) or ""
+        edits = input_data.get("edits")
+        if not isinstance(edits, list):
+            edits = []
+        diff_parts = []
+        for edit in edits:
+            if not isinstance(edit, dict):
+                continue
+            diff_parts.append(
+                _edit_diff(
+                    path,
+                    _string(edit.get("old_string")) or "",
+                    _string(edit.get("new_string")) or "",
+                    include_header=not diff_parts,
+                )
+            )
+        return [_strip_empty({
+            "path": path,
+            "action": "update",
+            "kind": {"type": "update"},
+            "diff": "\n".join(part for part in diff_parts if part),
+        })]
+    if tool_name == "NotebookEdit":
+        path = _string(input_data.get("notebook_path") or input_data.get("file_path") or input_data.get("path")) or ""
+        new_source = _string(input_data.get("new_source")) or _json_text(input_data.get("new_source"))
+        return [_strip_empty({
+            "path": path,
+            "action": "update",
+            "kind": {"type": "update"},
+            "diff": _edit_diff(path, "", new_source),
+        })]
+    path = _string(input_data.get("file_path") or input_data.get("path")) or ""
+    return [_strip_empty({"path": path, "action": "update", "kind": {"type": "update"}})]
+
+
+def _edit_diff(path: str, old: str, new: str, *, include_header: bool = True) -> str:
+    lines: list[str] = []
+    if include_header:
+        lines.extend([f"--- {path}", f"+++ {path}"])
+    lines.append("@@")
+    if old:
+        lines.extend(f"-{line}" for line in old.splitlines())
+    if new:
+        lines.extend(f"+{line}" for line in new.splitlines())
+    return "\n".join(lines)
+
+
+def _mcp_parts(tool_name: str | None) -> tuple[str, str] | None:
+    if not tool_name or not tool_name.startswith("mcp__"):
+        return None
+    parts = tool_name.split("__", 2)
+    if len(parts) != 3 or not parts[1] or not parts[2]:
+        return None
+    return parts[1], parts[2]
+
+
+def _result_text(value: Any) -> str:
+    if isinstance(value, str):
+        return value
+    if isinstance(value, list):
+        texts: list[str] = []
+        for item in value:
+            if isinstance(item, dict) and isinstance(item.get("text"), str):
+                texts.append(item["text"])
+            elif isinstance(item, str):
+                texts.append(item)
+        if texts:
+            return "\n".join(texts)
+    if value is None:
+        return ""
+    return _json_text(value)
+
+
+def _json_text(value: Any) -> str:
+    try:
+        return json.dumps(value, ensure_ascii=False, indent=2)
+    except TypeError:
+        return str(value)
+
+
+def _preview_text(value: str, limit: int = 4000) -> str:
+    return value[-limit:]
+
+
+def _string(value: Any) -> str | None:
+    return value if isinstance(value, str) else None
+
+
+def _strip_empty(value: dict[str, Any]) -> dict[str, Any]:
+    return {key: item for key, item in value.items() if item is not None}

connector/claude/trust.py

@@ -0,0 +1,69 @@
+"""Pre-accept the per-cwd Claude trust dialog.
+
+First time you point `claude` at a brand-new directory, the TUI pops a
+'Is this a project you trust?' prompt that blocks everything until you
+say yes. The decision is persisted in `~/.claude.json` under
+`projects[<cwd>].hasTrustDialogAccepted`.
+
+Daemon-driven spawns shouldn't see that dialog at all. This module writes
+the flag *before* spawn. Research doc §3.3: also write the resolved cwd
+because macOS may resolve symlinks before the prompt logic runs.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from loguru import logger
+
+
+def _claude_config_path() -> Path:
+    return Path.home() / ".claude.json"
+
+
+def ensure_trust(cwd: str | Path, *, config_path: Path | None = None) -> None:
+    """Idempotently mark `cwd` (and its resolved form) as trusted."""
+    path = config_path or _claude_config_path()
+    candidates = _trust_candidates(cwd)
+
+    try:
+        data = json.loads(path.read_text(encoding="utf-8")) if path.exists() else {}
+    except (OSError, json.JSONDecodeError) as exc:
+        logger.warning("trust: ~/.claude.json unreadable, starting fresh ({})", exc)
+        data = {}
+    if not isinstance(data, dict):
+        data = {}
+
+    projects = data.get("projects")
+    if not isinstance(projects, dict):
+        projects = {}
+        data["projects"] = projects
+
+    changed = False
+    for candidate in candidates:
+        entry = projects.get(candidate)
+        if not isinstance(entry, dict):
+            entry = {}
+            projects[candidate] = entry
+        if not entry.get("hasTrustDialogAccepted"):
+            entry["hasTrustDialogAccepted"] = True
+            changed = True
+
+    if not changed:
+        return
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+
+
+def _trust_candidates(cwd: str | Path) -> list[str]:
+    raw = str(cwd)
+    candidates = [raw]
+    try:
+        resolved = str(Path(cwd).resolve())
+    except OSError:
+        resolved = raw
+    if resolved != raw:
+        candidates.append(resolved)
+    return candidates

connector/cli.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+import argparse
+import asyncio
+import os
+import sys
+import time
+from pathlib import Path
+
+import httpx
+
+from connector.runtime import BackendRpcClient, ConnectorConfig
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+    try:
+        if args.command == "login":
+            asyncio.run(_login(args))
+        elif args.command == "configure":
+            _configure(args)
+        elif args.command == "start":
+            asyncio.run(_start(args))
+        else:
+            parser.print_help()
+    except KeyboardInterrupt:
+        raise SystemExit(130) from None
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="anywhere-cli", description="Agent Server Codex connector CLI")
+    subparsers = parser.add_subparsers(dest="command")
+
+    start = subparsers.add_parser("start", help="start the connector")
+    _add_config_args(start)
+    start.add_argument("--server-url", help="backend server URL")
+    start.add_argument("--connector-id", help="connector id")
+    start.add_argument("--connector-token", help="connector token")
+
+    login = subparsers.add_parser("login", help="pair with a backend, save credentials, and start the connector")
+    _add_config_args(login)
+    login.add_argument("--server-url", required=True, help="backend server URL")
+    login.add_argument("--poll-interval", type=float, default=2, help="seconds between pairing polls")
+    login.add_argument("--timeout", type=float, default=600, help="pairing timeout in seconds")
+    login.add_argument("--no-start", action="store_true", help="save credentials without starting the connector")
+
+    configure = subparsers.add_parser("configure", help="save connector credentials to local JSON")
+    _add_config_args(configure)
+    configure.add_argument("--server-url", required=True, help="backend server URL")
+    configure.add_argument("--connector-id", required=True, help="connector id")
+    configure.add_argument("--connector-token", required=True, help="connector token")
+    return parser
+
+
+def _add_config_args(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--config",
+        default=str(ConnectorConfig.default_path()),
+        help="local connector config JSON path",
+    )
+
+
+async def _start(args: argparse.Namespace) -> None:
+    config = _resolve_config(args)
+    await BackendRpcClient(config).run_forever()
+
+
+async def _login(args: argparse.Namespace) -> None:
+    server_url = args.server_url.rstrip("/")
+    async with httpx.AsyncClient(timeout=30) as client:
+        start_response = await client.post(
+            f"{server_url}/pairing/start",
+            json={"serverUrl": server_url, "ttlSeconds": int(args.timeout)},
+        )
+        start_response.raise_for_status()
+        pairing = start_response.json()
+        pairing_id = pairing["pairingId"]
+        code = pairing["code"]
+
+        print(f"Pairing code: {code}")
+        print("Claim it from the web UI")
+        # print(
+        #     "curl -s "
+        #     f"{server_url}/pairing/claim "
+        #     "-H 'content-type: application/json' "
+        #     f"-d '{{\"code\":\"{code}\",\"name\":\"local-codex\",\"userId\":\"local\",\"serverUrl\":\"{server_url}\"}}'"
+        # )
+        print("Waiting for credentials...")
+
+        deadline = time.monotonic() + args.timeout
+        while time.monotonic() < deadline:
+            poll_response = await client.post(f"{server_url}/pairing/poll", json={"pairingId": pairing_id})
+            poll_response.raise_for_status()
+            payload = poll_response.json()
+            if payload["status"] == "claimed" and payload.get("config"):
+                config = ConnectorConfig.from_mapping(payload["config"])
+                path = config.save(args.config)
+                print(f"Saved connector config: {path}")
+                if args.no_start:
+                    return
+                print("Starting connector...")
+                await BackendRpcClient(config).run_forever()
+                return
+            if payload["status"] in {"expired", "consumed"}:
+                raise RuntimeError(f"pairing ended with status: {payload['status']}")
+            await asyncio.sleep(args.poll_interval)
+
+    raise TimeoutError("pairing timed out")
+
+
+def _configure(args: argparse.Namespace) -> None:
+    config = ConnectorConfig(
+        server_url=args.server_url.rstrip("/"),
+        connector_id=args.connector_id,
+        connector_token=args.connector_token,
+    )
+    path = config.save(args.config)
+    print(f"Saved connector config: {path}")
+
+
+def _resolve_config(args: argparse.Namespace) -> ConnectorConfig:
+    server_url = args.server_url or os.environ.get("AGENT_SERVER_URL")
+    connector_id = args.connector_id or os.environ.get("AGENT_CONNECTOR_ID")
+    connector_token = args.connector_token or os.environ.get("AGENT_CONNECTOR_TOKEN")
+    if server_url and connector_id and connector_token:
+        return ConnectorConfig(
+            server_url=server_url.rstrip("/"),
+            connector_id=connector_id,
+            connector_token=connector_token,
+        )
+
+    config_path = Path(args.config)
+    if config_path.exists():
+        return ConnectorConfig.load(config_path)
+
+    missing = []
+    if not server_url:
+        missing.append("--server-url")
+    if not connector_id:
+        missing.append("--connector-id")
+    if not connector_token:
+        missing.append("--connector-token")
+    missing.append(f"or config file {config_path}")
+    raise SystemExit("missing connector credentials: " + ", ".join(missing))
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

connector/codex/__init__.py

@@ -0,0 +1,3 @@
+from connector.codex.adapter import CodexAdapter
+
+__all__ = ["CodexAdapter"]