agentlink-cli 0.1.0__py3-none-any.whl

connector/local/file_ops.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+import mimetypes
+import hashlib
+import sys
+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:
+    def _windows_drive_entries(self) -> list[dict[str, Any]]:
+        if sys.platform != "win32":
+            return []
+
+        entries: list[dict[str, Any]] = []
+        from pathlib import Path
+
+        for code in range(ord("A"), ord("Z") + 1):
+            letter = chr(code)
+            path = Path(f"{letter}:\\")
+            try:
+                exists = path.exists()
+            except OSError:
+                exists = False
+            if not exists:
+                continue
+            entries.append({"name": f"{letter}:", "path": str(path), "type": "directory", "size": None})
+        return entries
+
+    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")
+        if sys.platform == "win32" and raw_path == "":
+            return {"path": "", "entries": self._windows_drive_entries(), "truncated": False}
+        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,92 @@
+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_rename(self, params: dict[str, Any]) -> dict[str, Any]:
+        return await self.terminal.rename(params)
+
+    async def terminal_list(self, params: dict[str, Any]) -> dict[str, Any]:
+        return await self.terminal.list(params)
+
+    async def terminal_release(self, params: dict[str, Any]) -> dict[str, Any]:
+        return await self.terminal.release(params)
+
+    async def terminal_snapshot(self, params: dict[str, Any]) -> dict[str, Any]:
+        return await self.terminal.snapshot(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)

connector/local/shell.py

@@ -0,0 +1,225 @@
+from __future__ import annotations
+
+import asyncio
+import os
+import signal
+import subprocess
+import time
+from pathlib import Path
+from typing import Any
+
+from connector.local.common import (
+    Notify,
+    required_int,
+    required_string,
+    resolve_path,
+    shell_result,
+    workspace_root,
+)
+
+
+class ShellBackend:
+    def __init__(self, notify: Notify | None = None) -> None:
+        self.notify = notify
+        self._shell_tasks: dict[str, dict[str, Any]] = {}
+
+    async def exec(self, params: dict[str, Any]) -> dict[str, Any]:
+        root = workspace_root(params)
+        cwd = resolve_path(root, required_string(params, "cwd"))
+        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")
+
+        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()
+
+        return shell_result(cwd, command, process.returncode, timed_out, start, stdout, stderr)
+
+    async def task_start(self, params: dict[str, Any]) -> dict[str, Any]:
+        root = workspace_root(params)
+        cwd = resolve_path(root, required_string(params, "cwd"))
+        if not cwd.is_dir():
+            raise NotADirectoryError(f"cwd not found: {cwd}")
+        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")
+        if task_id in self._shell_tasks:
+            raise ValueError(f"shell task already exists: {task_id}")
+
+        record: dict[str, Any] = {"process": None, "cancelled": False}
+        background = asyncio.create_task(
+            self._run_shell_task(
+                task_id=task_id,
+                session_id=session_id,
+                cwd=cwd,
+                command=command,
+                timeout_ms=timeout_ms,
+                record=record,
+            )
+        )
+        record["background"] = background
+        self._shell_tasks[task_id] = record
+        await self._notify("shell.task.started", {"taskId": task_id, "sessionId": session_id, "status": "running"})
+        return {"taskId": task_id, "sessionId": session_id, "status": "running"}
+
+    async def task_cancel(self, params: dict[str, Any]) -> dict[str, Any]:
+        task_id = required_string(params, "taskId")
+        session_id = required_string(params, "sessionId")
+        record = self._shell_tasks.get(task_id)
+        if record is None:
+            return {"taskId": task_id, "sessionId": session_id, "cancelled": False}
+        record["cancelled"] = True
+        await self._terminate_process(record.get("process"))
+        background = record.get("background")
+        if isinstance(background, asyncio.Task):
+            background.cancel()
+        self._shell_tasks.pop(task_id, None)
+        await self._notify("shell.task.completed", {"taskId": task_id, "sessionId": session_id, "status": "cancelled"})
+        return {"taskId": task_id, "sessionId": session_id, "cancelled": True}
+
+    async def _run_shell_task(
+        self,
+        *,
+        task_id: str,
+        session_id: str,
+        cwd: Path,
+        command: str,
+        timeout_ms: int,
+        record: dict[str, Any],
+    ) -> None:
+        start = time.monotonic()
+        timed_out = False
+        stdout = b""
+        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)
+            await self._notify(
+                "shell.task.completed",
+                {"taskId": task_id, "sessionId": session_id, "status": "completed", "result": result},
+            )
+        except asyncio.CancelledError:
+            if process is not None:
+                await self._terminate_process(process)
+            raise
+        except Exception as exc:
+            await self._notify(
+                "shell.task.completed",
+                {
+                    "taskId": task_id,
+                    "sessionId": session_id,
+                    "status": "failed",
+                    "error": {"code": exc.__class__.__name__, "message": str(exc)},
+                },
+            )
+        finally:
+            self._shell_tasks.pop(task_id, None)
+
+    async def _create_process(self, cwd: Path, command: str) -> asyncio.subprocess.Process:
+        raise NotImplementedError
+
+    async def _terminate_process(self, process: Any) -> None:
+        raise NotImplementedError
+
+    async def _notify(self, method: str, params: dict[str, Any]) -> None:
+        if self.notify is not None:
+            await self.notify(method, params)
+
+
+class UnixShellBackend(ShellBackend):
+    async def _create_process(self, cwd: Path, command: str) -> asyncio.subprocess.Process:
+        return await asyncio.create_subprocess_shell(
+            command,
+            cwd=str(cwd),
+            stdin=asyncio.subprocess.DEVNULL,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            start_new_session=True,
+        )
+
+    async def _terminate_process(self, process: Any) -> None:
+        if process is None or getattr(process, "returncode", None) is not None:
+            return
+        pid = getattr(process, "pid", None)
+        if isinstance(pid, int):
+            try:
+                os.killpg(pid, signal.SIGTERM)
+            except ProcessLookupError:
+                return
+            except OSError:
+                process.terminate()
+        else:
+            process.terminate()
+        try:
+            await asyncio.wait_for(process.wait(), timeout=2)
+        except TimeoutError:
+            if isinstance(pid, int):
+                try:
+                    os.killpg(pid, signal.SIGKILL)
+                except ProcessLookupError:
+                    return
+                except OSError:
+                    process.kill()
+            else:
+                process.kill()
+            await process.wait()
+
+
+class WindowsShellBackend(ShellBackend):
+    async def _create_process(self, cwd: Path, command: str) -> asyncio.subprocess.Process:
+        creationflags = getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0)
+        return await asyncio.create_subprocess_shell(
+            command,
+            cwd=str(cwd),
+            stdin=asyncio.subprocess.DEVNULL,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            creationflags=creationflags,
+        )
+
+    async def _terminate_process(self, process: Any) -> None:
+        if process is None or getattr(process, "returncode", None) is not None:
+            return
+        pid = getattr(process, "pid", None)
+        if isinstance(pid, int):
+            try:
+                taskkill = await asyncio.create_subprocess_exec(
+                    "taskkill",
+                    "/T",
+                    "/F",
+                    "/PID",
+                    str(pid),
+                    stdout=asyncio.subprocess.DEVNULL,
+                    stderr=asyncio.subprocess.DEVNULL,
+                )
+                await asyncio.wait_for(taskkill.wait(), timeout=5)
+            except Exception:
+                process.terminate()
+        else:
+            process.terminate()
+        try:
+            await asyncio.wait_for(process.wait(), timeout=5)
+        except TimeoutError:
+            process.kill()
+            await process.wait()