agentlink-cli 0.1.6__tar.gz → 0.1.7__tar.gz

{agentlink_cli-0.1.6 → agentlink_cli-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentlink-cli
-Version: 0.1.6
+Version: 0.1.7
 Summary: Local runtime connector for AgentLink
 Requires-Python: >=3.12
 Requires-Dist: claude-agent-sdk

{agentlink_cli-0.1.6 → agentlink_cli-0.1.7}/connector/claude/sdk_adapter.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 import base64
 import hashlib
+import inspect
 import json
 import re
 import secrets
@@ -10,18 +11,19 @@ from collections.abc import Awaitable, Callable
 from dataclasses import dataclass, field
 from typing import Any
 
-from connector.logging import logger
-
-from connector.attachments import attachment_target
 from connector.adapter import NotificationSink
+from connector.attachments import attachment_target
 from connector.claude.history_adapter import ClaudeHistoryAdapter
 from connector.claude.normalized import NormalizedClaudeEvent
 from connector.claude.normalizers import ClaudeLiveNormalizer
-from connector.claude.timeline_reducer import ClaudeTimelineReducer, is_task_event_tool_name
+from connector.claude.timeline_reducer import (
+    ClaudeTimelineReducer,
+    is_task_event_tool_name,
+)
 from connector.launch import LaunchTarget, launch_target
+from connector.logging import logger
 from connector.time import utc_now
 
-
 AttachmentDownloader = Callable[[str, str], Awaitable[tuple[bytes, str, str]]]
 """(session_id, file_id) -> (data, original_name, media_type)"""
 
@@ -97,6 +99,28 @@ class ClaudeSdkAdapter:
     def apply_history_sync_state(self, state: list[dict[str, Any]]) -> None:
         self.history_adapter.apply_history_sync_state(state)
 
+    async def close(self) -> None:
+        tasks = [
+            runtime.active_task
+            for runtime in self._sessions.values()
+            if runtime.active_task is not None and not runtime.active_task.done()
+        ]
+        for runtime in self._sessions.values():
+            runtime.interrupted = True
+            for pending in runtime.pending_approvals.values():
+                if not pending.future.done():
+                    pending.future.set_result("cancelled")
+            client = runtime.client
+            if client is not None:
+                disconnect = getattr(client, "disconnect", None)
+                if callable(disconnect):
+                    result = disconnect()
+                    if inspect.isawaitable(result):
+                        await result
+        for task in tasks:
+            task.cancel()
+        await asyncio.gather(*tasks, return_exceptions=True)
+
     async def create_session(self, params: dict[str, Any]) -> dict[str, Any]:
         session_id = (
             _optional_string(params.get("sessionId"))

{agentlink_cli-0.1.6 → agentlink_cli-0.1.7}/connector/codex/adapter.py

@@ -1,24 +1,29 @@
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Awaitable, Callable
-from dataclasses import dataclass, field
-from datetime import UTC, datetime
 import hashlib
 import json
 import time
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
 from typing import Any
 
-from connector.logging import logger
-
 from connector.attachments import attachment_target
-from connector.codex.reducer import CODEX_APPROVAL_METHODS, ReductionResult, TimelineReducer
-from connector.codex.collaboration import collaboration_mode_payload, normalize_collaboration_modes
+from connector.codex.collaboration import (
+    collaboration_mode_payload,
+    normalize_collaboration_modes,
+)
+from connector.codex.reducer import (
+    CODEX_APPROVAL_METHODS,
+    ReductionResult,
+    TimelineReducer,
+)
 from connector.codex.rpc import JsonRpcStdioClient
+from connector.logging import logger
 from connector.sync_state import SyncStateStore
 from connector.time import utc_now
 
-
 AttachmentDownloader = Callable[[str, str], Awaitable[tuple[bytes, str, str]]]
 """(session_id, file_id) -> (data, original_name, media_type)"""
 
@@ -115,6 +120,16 @@ class CodexAdapter:
         self._existing_thread_sync_markers.clear()
         self._existing_thread_names.clear()
 
+    async def close(self) -> None:
+        tasks = [task for task in self._history_sync_tasks.values() if not task.done()]
+        for task in tasks:
+            task.cancel()
+        await asyncio.gather(*tasks, return_exceptions=True)
+        self._history_sync_tasks.clear()
+        if self.rpc is not None:
+            await self.rpc.close()
+        self._started = False
+
     def forget_persisted_sync_state(self, connector_id: str) -> None:
         self.forget_sync_state()
         if self.sync_state_store is not None:

{agentlink_cli-0.1.6 → agentlink_cli-0.1.7}/connector/control.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import math
 from collections.abc import Awaitable, Callable
 from pathlib import Path
 from typing import Any
@@ -15,8 +16,11 @@ from connector.local_runtime import (
     write_runtime,
 )
 from connector.logging import logger
-from connector.runtime import BackendRpcClient, ConnectorAuthenticationError, ConnectorConfig
-
+from connector.runtime import (
+    BackendRpcClient,
+    ConnectorAuthenticationError,
+    ConnectorConfig,
+)
 
 ControlNotifier = Callable[[str, Any], Awaitable[None]]
 
@@ -254,10 +258,10 @@ def config_from_params(params: Any) -> ConnectorConfig:
         server_url=server_url,
         connector_id=connector_id,
         connector_token=connector_token,
-        heartbeat_seconds=float(params.get("heartbeatSeconds", 20)),
-        reconnect_seconds=float(params.get("reconnectSeconds", 3)),
-        sync_existing_on_connect=bool(params.get("syncExistingOnConnect", True)),
-        sync_interval_seconds=float(params.get("syncIntervalSeconds", 30)),
+        heartbeat_seconds=positive_number_param(params, "heartbeatSeconds", 20),
+        reconnect_seconds=positive_number_param(params, "reconnectSeconds", 3),
+        sync_existing_on_connect=bool_param(params, "syncExistingOnConnect", True),
+        sync_interval_seconds=positive_number_param(params, "syncIntervalSeconds", 30),
         state_db_path=params.get("stateDbPath") if isinstance(params.get("stateDbPath"), str) else None,
     )
 
@@ -296,3 +300,24 @@ def float_param(params: Any, key: str, default: float) -> float:
         return float(params.get(key, default))
     except (TypeError, ValueError):
         return default
+
+
+def bool_param(params: Any, key: str, default: bool) -> bool:
+    if not isinstance(params, dict):
+        return default
+    value = params.get(key, default)
+    if not isinstance(value, bool):
+        raise TypeError(f"{key} must be a boolean")
+    return value
+
+
+def positive_number_param(params: Any, key: str, default: float) -> float:
+    if not isinstance(params, dict):
+        return default
+    value = params.get(key, default)
+    if isinstance(value, bool) or not isinstance(value, int | float):
+        raise TypeError(f"{key} must be a finite positive number")
+    parsed = float(value)
+    if not math.isfinite(parsed) or parsed <= 0:
+        raise ValueError(f"{key} must be a finite positive number")
+    return parsed

{agentlink_cli-0.1.6 → agentlink_cli-0.1.7}/connector/local/common.py

@@ -1,13 +1,19 @@
 from __future__ import annotations
 
 import time
+from collections.abc import Awaitable, Callable
 from pathlib import Path
-from typing import Any, Awaitable, Callable
-
+from typing import Any
 
 MAX_DIR_ENTRIES = 500
 MAX_OUTPUT_CHARS = 64_000
+# UTF-8 uses at most four bytes per Unicode code point. Retaining this many
+# bytes guarantees that the first MAX_OUTPUT_CHARS decoded characters are
+# available while keeping subprocess output memory bounded.
+MAX_OUTPUT_BYTES = MAX_OUTPUT_CHARS * 4
 MAX_READ_TEXT_BYTES = 4 * 1024 * 1024
+MAX_COMMAND_CHARS = 64 * 1024
+MAX_SHELL_TIMEOUT_MS = 60 * 60 * 1000
 
 Notify = Callable[[str, dict[str, Any]], Awaitable[None]]
 
@@ -18,6 +24,14 @@ class StaleFileError(Exception):
     code = "stale"
 
 
+class WorkspaceBoundaryError(ValueError):
+    code = "workspace_boundary"
+
+
+class ResourceLimitError(RuntimeError):
+    code = "resource_limit"
+
+
 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():
@@ -26,10 +40,18 @@ def workspace_root(params: dict[str, Any]) -> Path:
 
 
 def resolve_path(root: Path, raw_path: str) -> Path:
-    path = Path(raw_path).expanduser()
+    if raw_path.startswith("~"):
+        raise WorkspaceBoundaryError("path must stay within the workspace")
+    root = root.resolve(strict=False)
+    path = Path(raw_path)
     if not path.is_absolute():
         path = root / path
-    return path.resolve(strict=False)
+    resolved = path.resolve(strict=False)
+    try:
+        resolved.relative_to(root)
+    except ValueError as exc:
+        raise WorkspaceBoundaryError("path must stay within the workspace") from exc
+    return resolved
 
 
 def nearest_existing_dir(path: Path, *, fallback: Path | None = None) -> Path:
@@ -102,6 +124,9 @@ def shell_result(
     start: float,
     stdout: bytes,
     stderr: bytes,
+    *,
+    stdout_bytes_truncated: bool = False,
+    stderr_bytes_truncated: bool = False,
 ) -> dict[str, Any]:
     stdout_text, stdout_truncated = decode_output(stdout)
     stderr_text, stderr_truncated = decode_output(stderr)
@@ -113,6 +138,6 @@ def shell_result(
         "durationMs": int((time.monotonic() - start) * 1000),
         "stdout": stdout_text,
         "stderr": stderr_text,
-        "stdoutTruncated": stdout_truncated,
-        "stderrTruncated": stderr_truncated,
+        "stdoutTruncated": stdout_truncated or stdout_bytes_truncated,
+        "stderrTruncated": stderr_truncated or stderr_bytes_truncated,
     }

{agentlink_cli-0.1.6 → agentlink_cli-0.1.7}/connector/local/file_ops.py

@@ -1,8 +1,13 @@
 from __future__ import annotations
 
-import mimetypes
+import asyncio
 import hashlib
+import mimetypes
+import os
+import stat
 import sys
+import tempfile
+from pathlib import Path
 from typing import Any
 
 from connector.local.common import (
@@ -43,12 +48,12 @@ class FileOps:
         path = resolve_path(root, required_string(params, "path"))
         if not path.is_file():
             raise FileNotFoundError(f"file not found: {path}")
-        data = path.read_bytes()
+        size, digest = await asyncio.to_thread(_file_metadata, path)
         return {
             "path": str(path),
             "name": path.name,
-            "size": len(data),
-            "sha256": hashlib.sha256(data).hexdigest(),
+            "size": size,
+            "sha256": digest,
             "mediaType": mimetypes.guess_type(path.name)[0] or "application/octet-stream",
         }
 
@@ -79,7 +84,7 @@ class FileOps:
                     f"file changed on disk (expected sha256={if_match}, found sha256={current_hash or 'none'})"
                 )
         data = content.encode(content_encoding)
-        path.write_bytes(data)
+        await asyncio.to_thread(_atomic_write, path, data)
         return {
             "path": str(path),
             "encoding": "utf8",
@@ -96,16 +101,15 @@ class FileOps:
         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
+        size, digest, clipped = await asyncio.to_thread(_read_text_metadata, path, max_bytes)
+        truncated = size > 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(),
+            "size": size,
+            "sha256": digest,
             "encoding": "utf8",
             "content": content,
             "truncated": truncated,
@@ -142,3 +146,44 @@ class FileOps:
             "entries": entries,
             "truncated": len(entries) >= MAX_DIR_ENTRIES,
         }
+
+
+def _file_metadata(path: Path) -> tuple[int, str]:
+    digest = hashlib.sha256()
+    size = 0
+    with path.open("rb") as stream:
+        while chunk := stream.read(1024 * 1024):
+            size += len(chunk)
+            digest.update(chunk)
+    return size, digest.hexdigest()
+
+
+def _read_text_metadata(path: Path, max_bytes: int) -> tuple[int, str, bytes]:
+    digest = hashlib.sha256()
+    size = 0
+    clipped = bytearray()
+    with path.open("rb") as stream:
+        while chunk := stream.read(1024 * 1024):
+            size += len(chunk)
+            digest.update(chunk)
+            if len(clipped) < max_bytes:
+                clipped.extend(chunk[: max_bytes - len(clipped)])
+    return size, digest.hexdigest(), bytes(clipped)
+
+
+def _atomic_write(path: Path, data: bytes) -> None:
+    existing_mode = stat.S_IMODE(path.stat().st_mode) if path.exists() else None
+    fd, temporary = tempfile.mkstemp(prefix=f".{path.name}.", dir=path.parent)
+    try:
+        if existing_mode is not None:
+            os.chmod(temporary, existing_mode)
+        with os.fdopen(fd, "wb") as stream:
+            stream.write(data)
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.replace(temporary, path)
+    finally:
+        try:
+            os.unlink(temporary)
+        except FileNotFoundError:
+            pass

{agentlink_cli-0.1.6 → agentlink_cli-0.1.7}/connector/local/ops.py

@@ -78,6 +78,10 @@ class LocalOps:
     async def terminal_snapshot(self, params: dict[str, Any]) -> dict[str, Any]:
         return await self.terminal.snapshot(params)
 
+    async def aclose(self) -> None:
+        await self.shell.aclose()
+        await self.terminal.aclose()
+
 
 def create_local_ops(
     notify: Notify | None = None,

{agentlink_cli-0.1.6 → agentlink_cli-0.1.7}/connector/local/shell.py

@@ -9,7 +9,11 @@ from pathlib import Path
 from typing import Any
 
 from connector.local.common import (
+    MAX_COMMAND_CHARS,
+    MAX_OUTPUT_BYTES,
+    MAX_SHELL_TIMEOUT_MS,
     Notify,
+    ResourceLimitError,
     required_int,
     required_string,
     resolve_path,
@@ -17,11 +21,15 @@ from connector.local.common import (
     workspace_root,
 )
 
+MAX_SHELL_PROCESSES = 8
+
 
 class ShellBackend:
     def __init__(self, notify: Notify | None = None) -> None:
         self.notify = notify
         self._shell_tasks: dict[str, dict[str, Any]] = {}
+        self._process_slots = asyncio.Semaphore(MAX_SHELL_PROCESSES)
+        self._closing = False
 
     async def exec(self, params: dict[str, Any]) -> dict[str, Any]:
         root = workspace_root(params)
@@ -29,21 +37,26 @@ class ShellBackend:
         if not cwd.is_dir():
             raise NotADirectoryError(f"cwd not found: {cwd}")
         command = required_string(params, "command")
-        timeout_ms = required_int(params, "timeoutMs")
-        if timeout_ms <= 0:
-            raise ValueError("timeoutMs must be positive")
+        timeout_ms = _validated_request(command, required_int(params, "timeoutMs"))
 
-        start = time.monotonic()
-        process = await self._create_process(cwd, command)
-        timed_out = False
-        try:
-            stdout, stderr = await asyncio.wait_for(process.communicate(), timeout=timeout_ms / 1000)
-        except TimeoutError:
-            timed_out = True
-            await self._terminate_process(process)
-            stdout, stderr = await process.communicate()
+        async with self._process_slots:
+            start = time.monotonic()
+            process = await self._create_process(cwd, command)
+            stdout, stderr, timed_out, stdout_truncated, stderr_truncated = (
+                await self._collect_process(process, timeout_ms)
+            )
 
-        return shell_result(cwd, command, process.returncode, timed_out, start, stdout, stderr)
+        return shell_result(
+            cwd,
+            command,
+            process.returncode,
+            timed_out,
+            start,
+            stdout,
+            stderr,
+            stdout_bytes_truncated=stdout_truncated,
+            stderr_bytes_truncated=stderr_truncated,
+        )
 
     async def task_start(self, params: dict[str, Any]) -> dict[str, Any]:
         root = workspace_root(params)
@@ -53,11 +66,11 @@ class ShellBackend:
         task_id = required_string(params, "taskId")
         session_id = required_string(params, "sessionId")
         command = required_string(params, "command")
-        timeout_ms = required_int(params, "timeoutMs")
-        if timeout_ms <= 0:
-            raise ValueError("timeoutMs must be positive")
+        timeout_ms = _validated_request(command, required_int(params, "timeoutMs"))
         if task_id in self._shell_tasks:
             raise ValueError(f"shell task already exists: {task_id}")
+        if self._closing or len(self._shell_tasks) >= MAX_SHELL_PROCESSES:
+            raise ResourceLimitError("too many active shell tasks")
 
         record: dict[str, Any] = {"process": None, "cancelled": False}
         background = asyncio.create_task(
@@ -106,15 +119,23 @@ class ShellBackend:
         stderr = b""
         process: asyncio.subprocess.Process | None = None
         try:
-            process = await self._create_process(cwd, command)
-            record["process"] = process
-            try:
-                stdout, stderr = await asyncio.wait_for(process.communicate(), timeout=timeout_ms / 1000)
-            except TimeoutError:
-                timed_out = True
-                await self._terminate_process(process)
-                stdout, stderr = await process.communicate()
-            result = shell_result(cwd, command, process.returncode, timed_out, start, stdout, stderr)
+            async with self._process_slots:
+                process = await self._create_process(cwd, command)
+                record["process"] = process
+                stdout, stderr, timed_out, stdout_truncated, stderr_truncated = (
+                    await self._collect_process(process, timeout_ms)
+                )
+            result = shell_result(
+                cwd,
+                command,
+                process.returncode,
+                timed_out,
+                start,
+                stdout,
+                stderr,
+                stdout_bytes_truncated=stdout_truncated,
+                stderr_bytes_truncated=stderr_truncated,
+            )
             await self._notify(
                 "shell.task.completed",
                 {"taskId": task_id, "sessionId": session_id, "status": "completed", "result": result},
@@ -136,6 +157,58 @@ class ShellBackend:
         finally:
             self._shell_tasks.pop(task_id, None)
 
+    async def _collect_process(
+        self, process: asyncio.subprocess.Process, timeout_ms: int
+    ) -> tuple[bytes, bytes, bool, bool, bool]:
+        async def read_limited(stream: asyncio.StreamReader | None) -> tuple[bytes, bool]:
+            if stream is None:
+                return b"", False
+            retained = bytearray()
+            truncated = False
+            while chunk := await stream.read(64 * 1024):
+                if len(retained) < MAX_OUTPUT_BYTES:
+                    remaining = MAX_OUTPUT_BYTES - len(retained)
+                    retained.extend(chunk[:remaining])
+                    truncated = truncated or len(chunk) > remaining
+                else:
+                    truncated = True
+            return bytes(retained), truncated
+
+        stdout_task = asyncio.create_task(read_limited(process.stdout))
+        stderr_task = asyncio.create_task(read_limited(process.stderr))
+        timed_out = False
+        try:
+            await asyncio.wait_for(process.wait(), timeout=timeout_ms / 1000)
+        except TimeoutError:
+            timed_out = True
+            await self._terminate_process(process)
+        except asyncio.CancelledError:
+            try:
+                await self._terminate_process(process)
+            finally:
+                stdout_task.cancel()
+                stderr_task.cancel()
+                await asyncio.gather(stdout_task, stderr_task, return_exceptions=True)
+            raise
+        (stdout, stdout_truncated), (stderr, stderr_truncated) = await asyncio.gather(
+            stdout_task, stderr_task
+        )
+        return stdout, stderr, timed_out, stdout_truncated, stderr_truncated
+
+    async def aclose(self) -> None:
+        self._closing = True
+        records = list(self._shell_tasks.values())
+        for record in records:
+            await self._terminate_process(record.get("process"))
+            task = record.get("background")
+            if isinstance(task, asyncio.Task):
+                task.cancel()
+        await asyncio.gather(
+            *(record["background"] for record in records if isinstance(record.get("background"), asyncio.Task)),
+            return_exceptions=True,
+        )
+        self._shell_tasks.clear()
+
     async def _create_process(self, cwd: Path, command: str) -> asyncio.subprocess.Process:
         raise NotImplementedError
 
@@ -223,3 +296,11 @@ class WindowsShellBackend(ShellBackend):
         except TimeoutError:
             process.kill()
             await process.wait()
+
+
+def _validated_request(command: str, timeout_ms: int) -> int:
+    if len(command) > MAX_COMMAND_CHARS:
+        raise ResourceLimitError("command is too large")
+    if timeout_ms <= 0 or timeout_ms > MAX_SHELL_TIMEOUT_MS:
+        raise ValueError(f"timeoutMs must be between 1 and {MAX_SHELL_TIMEOUT_MS}")
+    return timeout_ms

{agentlink_cli-0.1.6 → agentlink_cli-0.1.7}/connector/local/terminal.py

@@ -7,13 +7,18 @@ import os
 import signal
 import sys
 import time
+from collections.abc import Awaitable, Callable
 from datetime import UTC, datetime
 from pathlib import Path
-from collections.abc import Awaitable, Callable
 from typing import Any
 
-from connector.local.common import Notify, nearest_existing_dir, required_string, resolve_path, workspace_root
-
+from connector.local.common import (
+    Notify,
+    nearest_existing_dir,
+    required_string,
+    resolve_path,
+    workspace_root,
+)
 
 TerminalOutput = Callable[[str, dict[str, Any]], Awaitable[None]]
 TERMINAL_SCROLLBACK_MAX_BYTES = 512 * 1024
@@ -191,6 +196,12 @@ class TerminalBackend:
         self._forget_terminal(terminal_id)
         return {"terminalId": terminal_id, "closed": True}
 
+    async def aclose(self) -> None:
+        records = list(self._terminals.values())
+        for record in records:
+            await self._kill_terminal(record)
+            self._forget_terminal(record["id"])
+
     async def rename(self, params: dict[str, Any]) -> dict[str, Any]:
         self._gc()
         terminal_id = required_string(params, "terminalId")

{agentlink_cli-0.1.6 → agentlink_cli-0.1.7}/connector/local_runtime.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import json
 import os
 import sys
+import tempfile
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -66,7 +67,9 @@ def write_runtime(path: str | Path, config: ConnectorConfig, *, kind: str, pid:
 
     runtime_file = Path(path)
     runtime_file.parent.mkdir(parents=True, exist_ok=True)
-    runtime_file.write_text(
+    if runtime_file.is_symlink():
+        raise ValueError("connector runtime path must not be a symlink")
+    payload = (
         json.dumps(
             {
                 "pid": int(pid if pid is not None else os.getpid()),
@@ -77,13 +80,21 @@ def write_runtime(path: str | Path, config: ConnectorConfig, *, kind: str, pid:
             },
             indent=2,
         )
-        + "\n",
-        encoding="utf-8",
+        + "\n"
     )
+    fd, temporary = tempfile.mkstemp(prefix=f".{runtime_file.name}.", dir=runtime_file.parent)
     try:
-        runtime_file.chmod(0o600)
-    except OSError:
-        pass
+        os.chmod(temporary, 0o600)
+        with os.fdopen(fd, "w", encoding="utf-8") as stream:
+            stream.write(payload)
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.replace(temporary, runtime_file)
+    finally:
+        try:
+            os.unlink(temporary)
+        except FileNotFoundError:
+            pass
     return runtime_file