agentlink-cli 0.1.0__py3-none-any.whl

connector/local_runtime.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+import json
+import os
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+from connector.runtime import ConnectorConfig
+
+
+@dataclass(slots=True)
+class RuntimeOwner:
+    pid: int
+    kind: str
+    connector_id: str
+    server_url: str
+    started_at: str | None = None
+
+
+class ConnectorAlreadyRunningError(RuntimeError):
+    def __init__(self, owner: RuntimeOwner) -> None:
+        super().__init__(f"connector {owner.connector_id} is already running in {owner.kind} pid {owner.pid}")
+        self.owner = owner
+
+
+def runtime_path(config_path: str | Path | None = None) -> Path:
+    base = Path(config_path) if config_path is not None else ConnectorConfig.default_path()
+    return base.with_name("connector-runtime.json")
+
+
+def read_runtime(path: str | Path) -> RuntimeOwner | None:
+    try:
+        data = json.loads(Path(path).read_text(encoding="utf-8-sig"))
+    except (OSError, ValueError):
+        return None
+    pid = data.get("pid")
+    kind = data.get("kind")
+    connector_id = data.get("connectorId")
+    server_url = data.get("serverUrl")
+    if not isinstance(pid, int) or not isinstance(kind, str) or not isinstance(connector_id, str) or not isinstance(server_url, str):
+        return None
+    return RuntimeOwner(
+        pid=pid,
+        kind=kind,
+        connector_id=connector_id,
+        server_url=server_url,
+        started_at=data.get("startedAt") if isinstance(data.get("startedAt"), str) else None,
+    )
+
+
+def assert_can_start(path: str | Path, config: ConnectorConfig, *, current_pid: int | None = None) -> None:
+    owner = read_runtime(path)
+    if owner is None:
+        return
+    if current_pid is not None and owner.pid == current_pid:
+        return
+    if not _pid_alive(owner.pid):
+        clear_runtime(path)
+        return
+    raise ConnectorAlreadyRunningError(owner)
+
+
+def write_runtime(path: str | Path, config: ConnectorConfig, *, kind: str, pid: int | None = None) -> Path:
+    import datetime as _dt
+
+    runtime_file = Path(path)
+    runtime_file.parent.mkdir(parents=True, exist_ok=True)
+    runtime_file.write_text(
+        json.dumps(
+            {
+                "pid": int(pid if pid is not None else os.getpid()),
+                "kind": kind,
+                "connectorId": config.connector_id,
+                "serverUrl": config.server_url,
+                "startedAt": _dt.datetime.now(_dt.UTC).isoformat(),
+            },
+            indent=2,
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+    try:
+        runtime_file.chmod(0o600)
+    except OSError:
+        pass
+    return runtime_file
+
+
+def clear_runtime(path: str | Path, *, pid: int | None = None) -> None:
+    runtime_file = Path(path)
+    if pid is not None:
+        owner = read_runtime(runtime_file)
+        if owner is not None and owner.pid != pid:
+            return
+    try:
+        runtime_file.unlink()
+    except FileNotFoundError:
+        return
+    except OSError:
+        return
+
+
+def _pid_alive(pid: int) -> bool:
+    if pid <= 0:
+        return False
+    if pid == os.getpid():
+        return True
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    except OSError:
+        if sys.platform != "win32":
+            return False
+        return _windows_pid_alive(pid)
+    return True
+
+
+def _windows_pid_alive(pid: int) -> bool:
+    try:
+        import ctypes
+        from ctypes import wintypes
+
+        PROCESS_QUERY_LIMITED_INFORMATION = 0x1000
+        handle = ctypes.windll.kernel32.OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, False, pid)
+        if not handle:
+            return False
+        exit_code = wintypes.DWORD()
+        try:
+            if not ctypes.windll.kernel32.GetExitCodeProcess(handle, ctypes.byref(exit_code)):
+                return False
+            return exit_code.value == 259
+        finally:
+            ctypes.windll.kernel32.CloseHandle(handle)
+    except Exception:
+        return False

connector/logging.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+from loguru import logger as logger
+
+
+RpcLogNotifier = Callable[[str, Any], Awaitable[None]]
+
+
+class RpcLogSink:
+    def __init__(self, notifier: RpcLogNotifier) -> None:
+        self.notifier = notifier
+        self._tasks: set[asyncio.Task[None]] = set()
+        self._sink_id: int | None = None
+
+    def install(self, *, level: str = "TRACE", remove_default_sink: bool = False) -> RpcLogSink:
+        if remove_default_sink:
+            logger.remove()
+        self._sink_id = logger.add(self._write, level=level, format="{message}")
+        return self
+
+    async def close(self) -> None:
+        if self._sink_id is not None:
+            logger.remove(self._sink_id)
+            self._sink_id = None
+        if self._tasks:
+            await asyncio.gather(*self._tasks, return_exceptions=True)
+
+    def _write(self, message: Any) -> None:
+        record = message.record
+        payload = {
+            "time": record["time"].isoformat(),
+            "level": record["level"].name,
+            "name": record["name"],
+            "message": record["message"],
+        }
+        exception = record.get("exception")
+        if exception is not None:
+            payload["exception"] = str(exception)
+
+        task = asyncio.create_task(self.notifier("connector/log", payload))
+        self._tasks.add(task)
+        task.add_done_callback(self._tasks.discard)
+
+
+def install_rpc_log_sink(notifier: RpcLogNotifier, *, level: str = "TRACE", remove_default_sink: bool = False) -> RpcLogSink:
+    return RpcLogSink(notifier).install(level=level, remove_default_sink=remove_default_sink)

connector/perf.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+import time
+from collections.abc import Iterator
+from contextlib import contextmanager
+from typing import Any
+
+from connector.logging import logger
+
+_FIELD_ORDER = (
+    "method",
+    "runtime",
+    "session_id",
+    "turn_id",
+    "connector_id",
+    "outcome",
+    "command",
+)
+
+
+def elapsed_ms(started: float) -> float:
+    return round((time.perf_counter() - started) * 1000, 1)
+
+
+def log_stage(stage: str, elapsed_ms_value: float, *, level: str = "info", **fields: Any) -> None:
+    parts = [f"stage={stage}", f"elapsed_ms={elapsed_ms_value:.1f}"]
+    for key in _FIELD_ORDER:
+        value = fields.pop(key, None)
+        if value is None or value == "":
+            continue
+        parts.append(f"{key}={value}")
+    for key, value in fields.items():
+        if value is None or value == "":
+            continue
+        parts.append(f"{key}={value}")
+    message = " ".join(parts)
+    logger.log(level.upper(), message)
+
+
+class StageTimer:
+    """Wall-clock timer for agent invoke stages."""
+
+    __slots__ = ("_started", "_first_timeline_logged")
+
+    def __init__(self, started: float | None = None) -> None:
+        self._started = time.perf_counter() if started is None else started
+        self._first_timeline_logged = False
+
+    def elapsed_ms(self) -> float:
+        return elapsed_ms(self._started)
+
+    def mark(self, stage: str, *, level: str = "info", **fields: Any) -> float:
+        value = self.elapsed_ms()
+        log_stage(stage, value, level=level, **fields)
+        return value
+
+    def mark_first_timeline(self, *, level: str = "info", **fields: Any) -> float | None:
+        if self._first_timeline_logged:
+            return None
+        self._first_timeline_logged = True
+        # Prefer explicit alias; default is first assistant text token (TTFB).
+        stage = fields.pop("stage_alias", None) or "adapter.first_assistant_token"
+        return self.mark(str(stage), level=level, **fields)
+
+    def mark_turn_complete(
+        self,
+        *,
+        outcome: str,
+        level: str = "info",
+        **fields: Any,
+    ) -> float:
+        return self.mark("adapter.turn_complete", level=level, outcome=outcome, **fields)
+
+    @contextmanager
+    def span(self, stage: str, *, level: str = "info", **fields: Any) -> Iterator[None]:
+        started = time.perf_counter()
+        try:
+            yield
+        finally:
+            log_stage(stage, elapsed_ms(started), level=level, **fields)
+
+
+@contextmanager
+def span_stage(stage: str, *, level: str = "info", **fields: Any) -> Iterator[None]:
+    started = time.perf_counter()
+    try:
+        yield
+    finally:
+        log_stage(stage, elapsed_ms(started), level=level, **fields)

connector/protocol.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from pydantic import BaseModel
+
+
+class RpcRequest(BaseModel):
+    id: str
+    type: Literal["request"] = "request"
+    method: str
+    params: Any = None
+
+
+class RpcResponse(BaseModel):
+    id: str
+    type: Literal["response"] = "response"
+    ok: bool
+    result: Any = None
+    error: dict[str, str] | None = None
+
+
+class RpcNotification(BaseModel):
+    type: Literal["notification"] = "notification"
+    method: str
+    params: Any = None

connector/registry.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+from connector.acp.adapter import AcpAdapter
+from connector.acp.manifest import AgentManifest, load_builtin_manifests
+from connector.adapter import Adapter
+from connector.claude.history_adapter import ClaudeHistoryAdapter
+from connector.claude.sdk_adapter import ClaudeSdkAdapter
+from connector.codex.adapter import CodexAdapter
+from connector.sync_state import SyncStateStore
+
+
+NotificationSink = Callable[[str, dict[str, Any]], Awaitable[None]] | None
+AttachmentDownloader = Callable[[str, str], Awaitable[tuple[bytes, str, str]]]
+
+
+def build_default_adapters(
+    *,
+    notification_sink: NotificationSink = None,
+    sync_state_store: SyncStateStore | None = None,
+    attachment_downloader: AttachmentDownloader | None = None,
+    acp_manifests: list[AgentManifest] | None = None,
+) -> dict[str, Adapter]:
+    """Assemble native + ACP adapters for BackendRpcClient."""
+    adapters: dict[str, Adapter] = {
+        "codex": CodexAdapter(
+            notification_sink=notification_sink,
+            sync_state_store=sync_state_store,
+            attachment_downloader=attachment_downloader,
+        ),
+        "claude": ClaudeSdkAdapter(
+            notification_sink=notification_sink,
+            history_adapter=ClaudeHistoryAdapter(sync_state_store=sync_state_store),
+            attachment_downloader=attachment_downloader,
+        ),
+    }
+    for manifest in acp_manifests if acp_manifests is not None else load_builtin_manifests():
+        adapters[manifest.id] = AcpAdapter(
+            manifest=manifest,
+            notification_sink=notification_sink,
+            attachment_downloader=attachment_downloader,
+        )
+    return adapters
+
+
+def builtin_acp_runtime_ids() -> list[str]:
+    return [manifest.id for manifest in load_builtin_manifests()]