vystak-workspace-rpc 0.2.0__tar.gz

vystak_workspace_rpc-0.2.0/.gitignore

@@ -0,0 +1,45 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+build/
+.eggs/
+*.egg
+.venv/
+.pytest_cache/
+.ruff_cache/
+.pyright/
+
+# TypeScript
+node_modules/
+*.tsbuildinfo
+coverage/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Environment
+.env
+.env.local
+
+# Vystak generated output (was .agentstack/ before rename)
+.vystak/
+.agentstack/
+
+# Bundled templates copied into vystak-cli wheel at build time (build hook output)
+packages/python/vystak-cli/src/vystak_cli/templates/
+
+# Tooling workspaces (brainstorm sessions, local agent state)
+.superpowers/
+.worktrees/
+.claude/

vystak_workspace_rpc-0.2.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: vystak-workspace-rpc
+Version: 0.2.0
+Summary: JSON-RPC 2.0 subsystem server running inside vystak workspace containers
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# vystak-workspace-rpc
+
+Runs inside the workspace container as an OpenSSH subsystem. Exposes
+`fs.*`, `exec.*`, `git.*`, `tool.*` services over JSON-RPC 2.0 on
+stdin/stdout.
+
+Not intended to be run directly. Installed into the workspace image by
+the vystak Docker provider; launched by sshd per-channel.

vystak_workspace_rpc-0.2.0/README.md

@@ -0,0 +1,8 @@
+# vystak-workspace-rpc
+
+Runs inside the workspace container as an OpenSSH subsystem. Exposes
+`fs.*`, `exec.*`, `git.*`, `tool.*` services over JSON-RPC 2.0 on
+stdin/stdout.
+
+Not intended to be run directly. Installed into the workspace image by
+the vystak Docker provider; launched by sshd per-channel.

vystak_workspace_rpc-0.2.0/pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "vystak-workspace-rpc"
+dynamic = ["version"]
+description = "JSON-RPC 2.0 subsystem server running inside vystak workspace containers"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = []  # stdlib-only; runs in user-chosen base images
+
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/vystak_workspace_rpc"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = {root = "../../.."}

vystak_workspace_rpc-0.2.0/src/vystak_workspace_rpc/__init__.py

@@ -0,0 +1,3 @@
+"""Vystak workspace RPC subsystem — JSON-RPC 2.0 over stdio."""
+
+__version__ = "0.1.0"

vystak_workspace_rpc-0.2.0/src/vystak_workspace_rpc/__main__.py

@@ -0,0 +1,50 @@
+"""Entry point. sshd runs this as the `vystak-rpc` subsystem.
+
+Reads WORKSPACE_ROOT and TOOLS_DIR from env; defaults to /workspace and
+/workspace/tools. Builds a JsonRpcServer with all services registered,
+runs it against stdin/stdout.
+"""
+
+import asyncio
+import json
+import os
+import sys
+from pathlib import Path
+
+from vystak_workspace_rpc.server import JsonRpcServer, run_stdio
+from vystak_workspace_rpc.services.exec import register_exec
+from vystak_workspace_rpc.services.fs import register_fs
+from vystak_workspace_rpc.services.git import register_git
+from vystak_workspace_rpc.services.tool import register_tool
+
+
+def build_server(workspace_root: Path, tools_dir: Path) -> JsonRpcServer:
+    """Build a JsonRpcServer with all services registered."""
+    srv = JsonRpcServer()
+
+    async def progress_emitter(channel: str, data: dict) -> None:
+        """Forward to stdout as a JSON-RPC $/progress notification."""
+        note = {
+            "jsonrpc": "2.0",
+            "method": "$/progress",
+            "params": {"channel": channel, **data},
+        }
+        sys.stdout.write(json.dumps(note) + "\n")
+        sys.stdout.flush()
+
+    register_fs(srv, workspace_root)
+    register_exec(srv, workspace_root, progress_emitter=progress_emitter)
+    register_git(srv, workspace_root)
+    register_tool(srv, tools_dir)
+    return srv
+
+
+def main() -> None:
+    workspace_root = Path(os.environ.get("WORKSPACE_ROOT", "/workspace"))
+    tools_dir = Path(os.environ.get("TOOLS_DIR", str(workspace_root / "tools")))
+    srv = build_server(workspace_root, tools_dir)
+    asyncio.run(run_stdio(srv))
+
+
+if __name__ == "__main__":
+    main()

vystak_workspace_rpc-0.2.0/src/vystak_workspace_rpc/progress.py

@@ -0,0 +1,10 @@
+"""Progress notification helper for streaming responses.
+
+Handlers receive a progress_emitter callable they invoke with a channel
+name (e.g. 'stdout') and a data dict. The framework forwards these as
+JSON-RPC $/progress notifications back to the client.
+"""
+
+from collections.abc import Awaitable, Callable
+
+ProgressEmitter = Callable[[str, dict], Awaitable[None]]

vystak_workspace_rpc-0.2.0/src/vystak_workspace_rpc/server.py

@@ -0,0 +1,95 @@
+"""JSON-RPC 2.0 server over stdio, with per-channel dispatch.
+
+Reads newline-delimited JSON from stdin, writes responses to stdout.
+One instance per SSH channel (one process spawned by sshd for each
+`subsystem vystak-rpc` request).
+"""
+
+import asyncio
+import json
+import sys
+from collections.abc import Callable
+
+# JSON-RPC 2.0 error codes
+ERROR_PARSE = -32700
+ERROR_INVALID_REQUEST = -32600
+ERROR_METHOD_NOT_FOUND = -32601
+ERROR_INVALID_PARAMS = -32602
+ERROR_INTERNAL = -32603
+ERROR_SERVER = -32000  # implementation-defined server error
+
+
+class JsonRpcServer:
+    """Minimal JSON-RPC 2.0 handler.
+
+    Register methods via register(); call handle_line() to process one
+    request line and get the response line (or None for notifications).
+    """
+
+    def __init__(self) -> None:
+        self._handlers: dict[str, Callable] = {}
+
+    def register(self, method: str, handler: Callable) -> None:
+        """Register an async handler(params: dict) -> Any."""
+        self._handlers[method] = handler
+
+    async def handle_line(self, line: str) -> str | None:
+        """Process one JSON-RPC request line. Returns response line or None."""
+        try:
+            req = json.loads(line)
+        except json.JSONDecodeError as e:
+            return self._error_response(None, ERROR_PARSE, f"Parse error: {e}")
+
+        req_id = req.get("id")
+        method = req.get("method")
+        params = req.get("params", {})
+
+        if method is None:
+            return self._error_response(req_id, ERROR_INVALID_REQUEST,
+                                        "Invalid Request: method missing")
+
+        handler = self._handlers.get(method)
+        if handler is None:
+            if req_id is None:
+                return None  # notification to unknown method, silent
+            return self._error_response(req_id, ERROR_METHOD_NOT_FOUND,
+                                        f"Method not found: {method}")
+
+        try:
+            result = await handler(params)
+        except Exception as e:  # noqa: BLE001
+            if req_id is None:
+                return None  # notification errors are silent
+            return self._error_response(req_id, ERROR_SERVER, str(e))
+
+        if req_id is None:
+            return None  # notification: no response
+
+        return json.dumps({"jsonrpc": "2.0", "id": req_id, "result": result})
+
+    def _error_response(self, req_id, code: int, message: str,
+                        data: dict | None = None) -> str:
+        err = {"code": code, "message": message}
+        if data is not None:
+            err["data"] = data
+        return json.dumps({"jsonrpc": "2.0", "id": req_id, "error": err})
+
+
+async def run_stdio(server: JsonRpcServer) -> None:
+    """Read JSONL from stdin, write JSONL responses to stdout."""
+    loop = asyncio.get_event_loop()
+    reader = asyncio.StreamReader()
+    protocol = asyncio.StreamReaderProtocol(reader)
+    await loop.connect_read_pipe(lambda: protocol, sys.stdin)
+
+    while True:
+        line_bytes = await reader.readline()
+        if not line_bytes:
+            return  # EOF
+        line = line_bytes.decode("utf-8").rstrip("\n")
+        if not line:
+            continue
+        resp = await server.handle_line(line)
+        if resp is not None:
+            sys.stdout.write(resp + "\n")
+            sys.stdout.flush()

vystak_workspace_rpc-0.2.0/src/vystak_workspace_rpc/services/exec.py

@@ -0,0 +1,94 @@
+"""exec.* service — process execution with streaming stdout/stderr."""
+
+import asyncio
+import shutil
+from pathlib import Path
+
+from vystak_workspace_rpc.progress import ProgressEmitter
+
+
+def register_exec(server, workspace_root: Path,
+                  progress_emitter: ProgressEmitter) -> None:
+    """Register exec.* handlers. progress_emitter forwards chunks to the
+    JSON-RPC client as $/progress notifications."""
+    root = Path(workspace_root).resolve()
+
+    async def _stream_subprocess(argv: list[str], cwd: Path,
+                                  env: dict | None, timeout_s: float | None) -> dict:
+        import time
+
+        start = time.time()
+        proc = await asyncio.create_subprocess_exec(
+            *argv,
+            cwd=str(cwd),
+            env=env,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+
+        async def drain(reader, channel: str):
+            while True:
+                chunk = await reader.read(4096)
+                if not chunk:
+                    return
+                await progress_emitter(channel, {"chunk": chunk.decode("utf-8",
+                                                                       errors="replace")})
+
+        drain_stdout = asyncio.create_task(drain(proc.stdout, "stdout"))
+        drain_stderr = asyncio.create_task(drain(proc.stderr, "stderr"))
+
+        try:
+            if timeout_s is not None:
+                await asyncio.wait_for(proc.wait(), timeout=timeout_s)
+            else:
+                await proc.wait()
+        except TimeoutError:
+            proc.terminate()
+            try:
+                await asyncio.wait_for(proc.wait(), timeout=2.0)
+            except TimeoutError:
+                proc.kill()
+                await proc.wait()
+            drain_stdout.cancel()
+            drain_stderr.cancel()
+            raise TimeoutError(f"Process exceeded timeout {timeout_s}s") from None
+
+        await drain_stdout
+        await drain_stderr
+        duration_ms = int((time.time() - start) * 1000)
+        return {"exit_code": proc.returncode, "duration_ms": duration_ms}
+
+    async def run(params: dict) -> dict:
+        cmd = params["cmd"]
+        args = params.get("args", [])
+        argv = [cmd] + list(args) if isinstance(cmd, str) else list(cmd)
+
+        cwd_str = params.get("cwd", ".")
+        cwd = (root / cwd_str).resolve()
+        try:
+            cwd.relative_to(root)
+        except ValueError:
+            raise ValueError(f"cwd '{cwd_str}' escapes workspace root") from None
+
+        env = params.get("env")  # None = inherit
+        timeout_s = params.get("timeout_s")
+        return await _stream_subprocess(argv, cwd, env, timeout_s)
+
+    async def shell(params: dict) -> dict:
+        script = params["script"]
+        cwd_str = params.get("cwd", ".")
+        cwd = (root / cwd_str).resolve()
+        try:
+            cwd.relative_to(root)
+        except ValueError:
+            raise ValueError(f"cwd '{cwd_str}' escapes workspace root") from None
+        timeout_s = params.get("timeout_s")
+        return await _stream_subprocess(["sh", "-c", script], cwd, None, timeout_s)
+
+    async def which(params: dict) -> str | None:
+        found = shutil.which(params["name"])
+        return found
+
+    server.register("exec.run", run)
+    server.register("exec.shell", shell)
+    server.register("exec.which", which)

vystak_workspace_rpc-0.2.0/src/vystak_workspace_rpc/services/fs.py

@@ -0,0 +1,119 @@
+"""fs.* service — file operations rooted at the workspace directory.
+
+All paths are resolved relative to the workspace root. Attempts to
+escape via `..` or absolute paths outside the root raise ValueError.
+"""
+
+import difflib
+import shutil
+from pathlib import Path
+
+
+def register_fs(server, workspace_root: Path) -> None:
+    """Register fs.* handlers on the given JsonRpcServer."""
+    root = Path(workspace_root).resolve()
+
+    def _resolve(path: str) -> Path:
+        p = (root / path).resolve()
+        try:
+            p.relative_to(root)
+        except ValueError:
+            raise ValueError(
+                f"Path '{path}' resolves outside workspace root {root}"
+            ) from None
+        return p
+
+    async def read_file(params: dict) -> str:
+        encoding = params.get("encoding", "utf-8")
+        return _resolve(params["path"]).read_text(encoding=encoding)
+
+    async def write_file(params: dict) -> None:
+        p = _resolve(params["path"])
+        p.parent.mkdir(parents=True, exist_ok=True)
+        encoding = params.get("encoding", "utf-8")
+        p.write_text(params["content"], encoding=encoding)
+        if "mode" in params:
+            p.chmod(int(params["mode"], 8) if isinstance(params["mode"], str)
+                    else params["mode"])
+        return None
+
+    async def append_file(params: dict) -> None:
+        p = _resolve(params["path"])
+        encoding = params.get("encoding", "utf-8")
+        with p.open("a", encoding=encoding) as fh:
+            fh.write(params["content"])
+        return None
+
+    async def delete_file(params: dict) -> None:
+        p = _resolve(params["path"])
+        if p.is_dir():
+            shutil.rmtree(p)
+        else:
+            p.unlink()
+        return None
+
+    async def list_dir(params: dict) -> list[dict]:
+        p = _resolve(params["path"])
+        entries = []
+        for entry in sorted(p.iterdir()):
+            stat = entry.stat()
+            entries.append({
+                "name": entry.name,
+                "type": "directory" if entry.is_dir() else "file",
+                "size": stat.st_size,
+                "mtime": stat.st_mtime,
+            })
+        return entries
+
+    async def stat(params: dict) -> dict:
+        p = _resolve(params["path"])
+        s = p.stat()
+        return {
+            "type": "directory" if p.is_dir() else "file",
+            "size": s.st_size,
+            "mtime": s.st_mtime,
+            "permissions": oct(s.st_mode & 0o777),
+        }
+
+    async def exists(params: dict) -> bool:
+        try:
+            return _resolve(params["path"]).exists()
+        except ValueError:
+            return False
+
+    async def mkdir(params: dict) -> None:
+        p = _resolve(params["path"])
+        p.mkdir(parents=bool(params.get("parents", False)), exist_ok=True)
+        return None
+
+    async def move(params: dict) -> None:
+        src = _resolve(params["src"])
+        dst = _resolve(params["dst"])
+        shutil.move(str(src), str(dst))
+        return None
+
+    async def edit(params: dict) -> dict:
+        p = _resolve(params["path"])
+        old = params["old_str"]
+        new = params["new_str"]
+        content = p.read_text()
+        if old not in content:
+            raise ValueError(f"old_str not found in {params['path']}")
+        updated = content.replace(old, new, 1)  # one replacement by default
+        p.write_text(updated)
+        diff = "\n".join(difflib.unified_diff(
+            content.splitlines(), updated.splitlines(),
+            fromfile=params["path"], tofile=params["path"], lineterm="",
+        ))
+        return {"diff": diff}
+
+    server.register("fs.readFile", read_file)
+    server.register("fs.writeFile", write_file)
+    server.register("fs.appendFile", append_file)
+    server.register("fs.deleteFile", delete_file)
+    server.register("fs.listDir", list_dir)
+    server.register("fs.stat", stat)
+    server.register("fs.exists", exists)
+    server.register("fs.mkdir", mkdir)
+    server.register("fs.move", move)
+    server.register("fs.edit", edit)

vystak_workspace_rpc-0.2.0/src/vystak_workspace_rpc/services/git.py

@@ -0,0 +1,124 @@
+"""git.* service — thin wrapper over the git CLI."""
+
+import asyncio
+from pathlib import Path
+
+
+def register_git(server, workspace_root: Path) -> None:
+    root = Path(workspace_root).resolve()
+
+    async def _git(args: list[str]) -> tuple[int, str, str]:
+        proc = await asyncio.create_subprocess_exec(
+            "git", *args, cwd=str(root),
+            stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await proc.communicate()
+        return proc.returncode, stdout.decode("utf-8"), stderr.decode("utf-8")
+
+    async def _ensure_repo() -> None:
+        code, _, _ = await _git(["rev-parse", "--is-inside-work-tree"])
+        if code != 0:
+            raise RuntimeError(f"{root} is not a git repo")
+
+    async def status(params: dict) -> dict:
+        await _ensure_repo()
+        code, branch_out, _ = await _git(["rev-parse", "--abbrev-ref", "HEAD"])
+        branch = branch_out.strip() if code == 0 else "HEAD"
+
+        code, out, _ = await _git(["status", "--porcelain"])
+        staged: list[str] = []
+        unstaged: list[str] = []
+        untracked: list[str] = []
+        for line in out.splitlines():
+            if not line:
+                continue
+            xy, _, path = line.partition(" ")
+            # porcelain format: XY path, where X = staged state, Y = unstaged
+            x = line[0]
+            y = line[1]
+            path = line[3:].strip()
+            if x == "?" and y == "?":
+                untracked.append(path)
+            else:
+                if x != " ":
+                    staged.append(path)
+                if y != " ":
+                    unstaged.append(path)
+        return {
+            "branch": branch,
+            "dirty": bool(staged or unstaged or untracked),
+            "staged": staged,
+            "unstaged": unstaged,
+            "untracked": untracked,
+        }
+
+    async def log(params: dict) -> list[dict]:
+        await _ensure_repo()
+        limit = params.get("limit", 10)
+        path = params.get("path")
+        args = ["log", f"-{limit}", "--pretty=format:%H%x00%an%x00%ad%x00%s",
+                "--date=iso"]
+        if path:
+            args += ["--", path]
+        code, out, err = await _git(args)
+        if code != 0:
+            raise RuntimeError(f"git log failed: {err}")
+        result = []
+        for line in out.splitlines():
+            if not line:
+                continue
+            parts = line.split("\x00")
+            if len(parts) < 4:
+                continue
+            result.append({
+                "sha": parts[0],
+                "author": parts[1],
+                "date": parts[2],
+                "message": parts[3],
+            })
+        return result
+
+    async def diff(params: dict) -> str:
+        await _ensure_repo()
+        args = ["diff"]
+        if params.get("staged"):
+            args.append("--cached")
+        if params.get("path"):
+            args += ["--", params["path"]]
+        code, out, err = await _git(args)
+        if code != 0:
+            raise RuntimeError(f"git diff failed: {err}")
+        return out
+
+    async def add(params: dict) -> None:
+        await _ensure_repo()
+        paths = params.get("paths", [])
+        code, _, err = await _git(["add", *paths])
+        if code != 0:
+            raise RuntimeError(f"git add failed: {err}")
+        return None
+
+    async def commit(params: dict) -> dict:
+        await _ensure_repo()
+        args = ["commit", "-m", params["message"]]
+        if params.get("author"):
+            args += ["--author", params["author"]]
+        code, _, err = await _git(args)
+        if code != 0:
+            raise RuntimeError(f"git commit failed: {err}")
+        code, sha, _ = await _git(["rev-parse", "HEAD"])
+        return {"sha": sha.strip()}
+
+    async def branch(params: dict) -> str:
+        await _ensure_repo()
+        code, out, err = await _git(["rev-parse", "--abbrev-ref", "HEAD"])
+        if code != 0:
+            raise RuntimeError(f"git branch failed: {err}")
+        return out.strip()
+
+    server.register("git.status", status)
+    server.register("git.log", log)
+    server.register("git.diff", diff)
+    server.register("git.add", add)
+    server.register("git.commit", commit)
+    server.register("git.branch", branch)

vystak_workspace_rpc-0.2.0/src/vystak_workspace_rpc/services/tool.py

@@ -0,0 +1,51 @@
+"""tool.* service — discovers and invokes user-defined tools from tools/."""
+
+import asyncio
+import importlib.util
+import inspect
+import sys
+from pathlib import Path
+
+
+def register_tool(server, tools_dir: Path) -> None:
+    """Tools are Python files in tools_dir/<name>.py containing a function
+    named <name>. Invoked synchronously in-process."""
+    tools_root = Path(tools_dir)
+
+    async def invoke(params: dict) -> object:
+        name = params["name"]
+        args = params.get("args", {})
+        tool_path = tools_root / f"{name}.py"
+        if not tool_path.exists():
+            raise FileNotFoundError(f"Tool {name}.py not found in {tools_root}")
+
+        # Load module
+        spec = importlib.util.spec_from_file_location(f"vystak_tool_{name}", tool_path)
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[f"vystak_tool_{name}"] = module
+        spec.loader.exec_module(module)
+
+        fn = getattr(module, name, None)
+        if fn is None:
+            raise AttributeError(f"Tool {name}.py must define function '{name}'")
+
+        # Call sync or async, returning Python value
+        if inspect.iscoroutinefunction(fn):
+            return await fn(**args)
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, lambda: fn(**args))
+
+    async def list_tools(params: dict) -> list[dict]:
+        if not tools_root.exists():
+            return []
+        result = []
+        for entry in sorted(tools_root.iterdir()):
+            if entry.suffix != ".py":
+                continue
+            if entry.stem.startswith("_"):
+                continue
+            result.append({"name": entry.stem, "path": str(entry.relative_to(tools_root))})
+        return result
+
+    server.register("tool.invoke", invoke)
+    server.register("tool.list", list_tools)

vystak_workspace_rpc-0.2.0/tests/test_main.py

@@ -0,0 +1,21 @@
+"""Smoke test for __main__ wiring all services."""
+
+from vystak_workspace_rpc.__main__ import build_server
+
+
+def test_build_server_registers_all_services(tmp_path):
+    tools_dir = tmp_path / "tools"
+    tools_dir.mkdir()
+    srv = build_server(workspace_root=tmp_path, tools_dir=tools_dir)
+    registered = set(srv._handlers.keys())
+    # fs.*
+    assert "fs.readFile" in registered
+    assert "fs.writeFile" in registered
+    # exec.*
+    assert "exec.run" in registered
+    assert "exec.shell" in registered
+    # git.*
+    assert "git.status" in registered
+    # tool.*
+    assert "tool.invoke" in registered
+    assert "tool.list" in registered

vystak_workspace_rpc-0.2.0/tests/test_server.py

@@ -0,0 +1,71 @@
+"""Tests for the JSON-RPC 2.0 server core."""
+
+import json
+
+import pytest
+from vystak_workspace_rpc.server import JsonRpcServer
+
+
+@pytest.mark.asyncio
+async def test_server_handles_single_request():
+    async def echo(params):
+        return {"echoed": params.get("message", "")}
+
+    srv = JsonRpcServer()
+    srv.register("test.echo", echo)
+
+    req = json.dumps({"jsonrpc": "2.0", "id": "1", "method": "test.echo",
+                      "params": {"message": "hi"}})
+    response_line = await srv.handle_line(req)
+    assert response_line is not None
+    resp = json.loads(response_line)
+    assert resp["jsonrpc"] == "2.0"
+    assert resp["id"] == "1"
+    assert resp["result"] == {"echoed": "hi"}
+
+
+@pytest.mark.asyncio
+async def test_server_handles_unknown_method():
+    srv = JsonRpcServer()
+    req = json.dumps({"jsonrpc": "2.0", "id": "2", "method": "nope", "params": {}})
+    line = await srv.handle_line(req)
+    resp = json.loads(line)
+    assert resp["error"]["code"] == -32601
+    assert "Method not found" in resp["error"]["message"]
+
+
+@pytest.mark.asyncio
+async def test_server_handles_handler_exception():
+    async def boom(params):
+        raise ValueError("kaboom")
+
+    srv = JsonRpcServer()
+    srv.register("test.boom", boom)
+
+    req = json.dumps({"jsonrpc": "2.0", "id": "3", "method": "test.boom", "params": {}})
+    line = await srv.handle_line(req)
+    resp = json.loads(line)
+    assert resp["error"]["code"] == -32000
+    assert "kaboom" in resp["error"]["message"]
+
+
+@pytest.mark.asyncio
+async def test_server_handles_malformed_json():
+    srv = JsonRpcServer()
+    line = await srv.handle_line("not json {")
+    resp = json.loads(line)
+    assert resp["error"]["code"] == -32700
+    assert "Parse error" in resp["error"]["message"]
+
+
+@pytest.mark.asyncio
+async def test_server_notification_has_no_response():
+    """Requests without an id are notifications — no response expected."""
+    async def noop(params):
+        return None
+
+    srv = JsonRpcServer()
+    srv.register("test.noop", noop)
+    req = json.dumps({"jsonrpc": "2.0", "method": "test.noop", "params": {}})
+    line = await srv.handle_line(req)
+    assert line is None

vystak_workspace_rpc-0.2.0/tests/test_service_exec.py

@@ -0,0 +1,88 @@
+"""Tests for exec.* service."""
+
+import pytest
+from vystak_workspace_rpc.services.exec import register_exec
+
+
+def _build_server(workspace_root, chunks_out):
+    from vystak_workspace_rpc.server import JsonRpcServer
+
+    srv = JsonRpcServer()
+
+    async def progress_sink(channel: str, data: dict):
+        chunks_out.append((channel, data))
+
+    register_exec(srv, workspace_root, progress_emitter=progress_sink)
+    return srv
+
+
+@pytest.mark.asyncio
+async def test_exec_run_success(tmp_path):
+    chunks = []
+    srv = _build_server(tmp_path, chunks)
+    result = await srv._handlers["exec.run"]({
+        "cmd": ["echo", "hello"], "cwd": "."
+    })
+    assert result["exit_code"] == 0
+    assert any("hello" in c[1].get("chunk", "") for c in chunks)
+
+
+@pytest.mark.asyncio
+async def test_exec_run_nonzero_exit(tmp_path):
+    chunks = []
+    srv = _build_server(tmp_path, chunks)
+    result = await srv._handlers["exec.run"]({
+        "cmd": ["sh", "-c", "exit 3"]
+    })
+    assert result["exit_code"] == 3
+
+
+@pytest.mark.asyncio
+async def test_exec_run_streams_stdout(tmp_path):
+    chunks = []
+    srv = _build_server(tmp_path, chunks)
+    await srv._handlers["exec.run"]({
+        "cmd": ["sh", "-c", "echo line1; echo line2"]
+    })
+    stdout_chunks = [c[1]["chunk"] for c in chunks if c[0] == "stdout"]
+    combined = "".join(stdout_chunks)
+    assert "line1" in combined and "line2" in combined
+
+
+@pytest.mark.asyncio
+async def test_exec_shell_runs_script(tmp_path):
+    chunks = []
+    srv = _build_server(tmp_path, chunks)
+    result = await srv._handlers["exec.shell"]({
+        "script": "echo hi && false || echo recovered"
+    })
+    assert result["exit_code"] == 0
+    combined = "".join(c[1].get("chunk", "") for c in chunks)
+    assert "hi" in combined and "recovered" in combined
+
+
+@pytest.mark.asyncio
+async def test_exec_run_timeout(tmp_path):
+    chunks = []
+    srv = _build_server(tmp_path, chunks)
+    with pytest.raises(TimeoutError):
+        await srv._handlers["exec.run"]({
+            "cmd": ["sleep", "10"], "timeout_s": 0.2
+        })
+
+
+@pytest.mark.asyncio
+async def test_exec_which_found(tmp_path):
+    chunks = []
+    srv = _build_server(tmp_path, chunks)
+    result = await srv._handlers["exec.which"]({"name": "sh"})
+    assert result is not None
+    assert "sh" in result
+
+
+@pytest.mark.asyncio
+async def test_exec_which_not_found(tmp_path):
+    chunks = []
+    srv = _build_server(tmp_path, chunks)
+    result = await srv._handlers["exec.which"]({"name": "definitely_not_a_real_command_12345"})
+    assert result is None

vystak_workspace_rpc-0.2.0/tests/test_service_fs.py

@@ -0,0 +1,101 @@
+"""Tests for the fs.* service."""
+
+from pathlib import Path
+
+import pytest
+from vystak_workspace_rpc.services.fs import register_fs
+
+
+def _build_server(workspace_root: Path):
+    from vystak_workspace_rpc.server import JsonRpcServer
+
+    srv = JsonRpcServer()
+    register_fs(srv, workspace_root)
+    return srv
+
+
+@pytest.mark.asyncio
+async def test_fs_write_and_read(tmp_path):
+    srv = _build_server(tmp_path)
+    await srv._handlers["fs.writeFile"]({"path": "a.txt", "content": "hello"})
+    result = await srv._handlers["fs.readFile"]({"path": "a.txt"})
+    assert result == "hello"
+
+
+@pytest.mark.asyncio
+async def test_fs_exists(tmp_path):
+    srv = _build_server(tmp_path)
+    (tmp_path / "foo").write_text("x")
+    r = await srv._handlers["fs.exists"]({"path": "foo"})
+    assert r is True
+    r = await srv._handlers["fs.exists"]({"path": "nope"})
+    assert r is False
+
+
+@pytest.mark.asyncio
+async def test_fs_list_dir(tmp_path):
+    (tmp_path / "a.py").write_text("1")
+    (tmp_path / "b.md").write_text("2")
+    (tmp_path / "sub").mkdir()
+    srv = _build_server(tmp_path)
+    entries = await srv._handlers["fs.listDir"]({"path": "."})
+    names = {e["name"] for e in entries}
+    assert names == {"a.py", "b.md", "sub"}
+    sub = next(e for e in entries if e["name"] == "sub")
+    assert sub["type"] == "directory"
+    a = next(e for e in entries if e["name"] == "a.py")
+    assert a["type"] == "file"
+    assert a["size"] == 1
+
+
+@pytest.mark.asyncio
+async def test_fs_delete_file(tmp_path):
+    (tmp_path / "gone.txt").write_text("bye")
+    srv = _build_server(tmp_path)
+    await srv._handlers["fs.deleteFile"]({"path": "gone.txt"})
+    assert not (tmp_path / "gone.txt").exists()
+
+
+@pytest.mark.asyncio
+async def test_fs_mkdir_with_parents(tmp_path):
+    srv = _build_server(tmp_path)
+    await srv._handlers["fs.mkdir"]({"path": "a/b/c", "parents": True})
+    assert (tmp_path / "a" / "b" / "c").is_dir()
+
+
+@pytest.mark.asyncio
+async def test_fs_move(tmp_path):
+    (tmp_path / "src.txt").write_text("x")
+    srv = _build_server(tmp_path)
+    await srv._handlers["fs.move"]({"src": "src.txt", "dst": "dst.txt"})
+    assert not (tmp_path / "src.txt").exists()
+    assert (tmp_path / "dst.txt").read_text() == "x"
+
+
+@pytest.mark.asyncio
+async def test_fs_edit_replaces(tmp_path):
+    (tmp_path / "f.py").write_text("hello world")
+    srv = _build_server(tmp_path)
+    result = await srv._handlers["fs.edit"]({
+        "path": "f.py", "old_str": "world", "new_str": "vystak"
+    })
+    assert (tmp_path / "f.py").read_text() == "hello vystak"
+    assert "diff" in result
+
+
+@pytest.mark.asyncio
+async def test_fs_edit_old_str_not_found_raises(tmp_path):
+    (tmp_path / "f.py").write_text("hello world")
+    srv = _build_server(tmp_path)
+    with pytest.raises(ValueError, match="old_str not found"):
+        await srv._handlers["fs.edit"]({
+            "path": "f.py", "old_str": "missing", "new_str": "x"
+        })
+
+
+@pytest.mark.asyncio
+async def test_fs_readFile_escape_attempt_raises(tmp_path):
+    """Paths outside workspace root are rejected."""
+    srv = _build_server(tmp_path)
+    with pytest.raises(ValueError, match="outside workspace root"):
+        await srv._handlers["fs.readFile"]({"path": "../../../etc/passwd"})

vystak_workspace_rpc-0.2.0/tests/test_service_git.py

@@ -0,0 +1,90 @@
+"""Tests for git.* service. Uses a real temp git repo."""
+
+import subprocess
+
+import pytest
+from vystak_workspace_rpc.services.git import register_git
+
+
+def _init_repo(path):
+    subprocess.run(["git", "init", "-q"], cwd=path, check=True)
+    subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=path, check=True)
+    subprocess.run(["git", "config", "user.name", "test"], cwd=path, check=True)
+
+
+def _build_server(workspace_root):
+    from vystak_workspace_rpc.server import JsonRpcServer
+
+    srv = JsonRpcServer()
+    register_git(srv, workspace_root)
+    return srv
+
+
+@pytest.mark.asyncio
+async def test_git_status_clean(tmp_path):
+    _init_repo(tmp_path)
+    srv = _build_server(tmp_path)
+    result = await srv._handlers["git.status"]({})
+    assert "branch" in result
+    assert result["dirty"] is False
+    assert result["staged"] == []
+    assert result["unstaged"] == []
+    assert result["untracked"] == []
+
+
+@pytest.mark.asyncio
+async def test_git_status_with_untracked_file(tmp_path):
+    _init_repo(tmp_path)
+    (tmp_path / "new.txt").write_text("hi")
+    srv = _build_server(tmp_path)
+    result = await srv._handlers["git.status"]({})
+    assert result["dirty"] is True
+    assert "new.txt" in result["untracked"]
+
+
+@pytest.mark.asyncio
+async def test_git_add_and_commit(tmp_path):
+    _init_repo(tmp_path)
+    (tmp_path / "f.txt").write_text("hello")
+    srv = _build_server(tmp_path)
+    await srv._handlers["git.add"]({"paths": ["f.txt"]})
+    status = await srv._handlers["git.status"]({})
+    assert "f.txt" in status["staged"]
+    commit = await srv._handlers["git.commit"]({"message": "add f"})
+    assert "sha" in commit
+    assert len(commit["sha"]) >= 7
+
+
+@pytest.mark.asyncio
+async def test_git_log(tmp_path):
+    _init_repo(tmp_path)
+    (tmp_path / "a.txt").write_text("x")
+    subprocess.run(["git", "add", "."], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-qm", "first"], cwd=tmp_path, check=True)
+    srv = _build_server(tmp_path)
+    result = await srv._handlers["git.log"]({"limit": 10})
+    assert isinstance(result, list)
+    assert len(result) == 1
+    assert result[0]["message"] == "first"
+    assert "sha" in result[0]
+    assert "author" in result[0]
+
+
+@pytest.mark.asyncio
+async def test_git_branch(tmp_path):
+    _init_repo(tmp_path)
+    (tmp_path / "a").write_text("x")
+    subprocess.run(["git", "add", "."], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-qm", "init"], cwd=tmp_path, check=True)
+    srv = _build_server(tmp_path)
+    branch = await srv._handlers["git.branch"]({})
+    # Default branch is either "main" or "master" depending on git version config
+    assert branch in ("main", "master")
+
+
+@pytest.mark.asyncio
+async def test_git_not_a_repo_returns_error(tmp_path):
+    # No git init
+    srv = _build_server(tmp_path)
+    with pytest.raises(RuntimeError, match="not a git repo"):
+        await srv._handlers["git.status"]({})

vystak_workspace_rpc-0.2.0/tests/test_service_tool.py

@@ -0,0 +1,74 @@
+"""Tests for tool.* service — user-defined tools discovery + invocation."""
+
+import pytest
+from vystak_workspace_rpc.services.tool import register_tool
+
+
+def _build_server(tools_dir):
+    from vystak_workspace_rpc.server import JsonRpcServer
+
+    srv = JsonRpcServer()
+    register_tool(srv, tools_dir)
+    return srv
+
+
+@pytest.mark.asyncio
+async def test_tool_invoke_simple(tmp_path):
+    tools = tmp_path / "tools"
+    tools.mkdir()
+    (tools / "greet.py").write_text(
+        "def greet(name: str) -> str:\n    return f'hello {name}'\n"
+    )
+    srv = _build_server(tools)
+    result = await srv._handlers["tool.invoke"]({
+        "name": "greet", "args": {"name": "world"}
+    })
+    assert result == "hello world"
+
+
+@pytest.mark.asyncio
+async def test_tool_invoke_returns_dict(tmp_path):
+    tools = tmp_path / "tools"
+    tools.mkdir()
+    (tools / "calc.py").write_text(
+        "def calc(x: int, y: int) -> dict:\n    return {'sum': x+y, 'prod': x*y}\n"
+    )
+    srv = _build_server(tools)
+    result = await srv._handlers["tool.invoke"]({
+        "name": "calc", "args": {"x": 3, "y": 4}
+    })
+    assert result == {"sum": 7, "prod": 12}
+
+
+@pytest.mark.asyncio
+async def test_tool_invoke_unknown_raises(tmp_path):
+    tools = tmp_path / "tools"
+    tools.mkdir()
+    srv = _build_server(tools)
+    with pytest.raises(FileNotFoundError, match="nope.py"):
+        await srv._handlers["tool.invoke"]({"name": "nope", "args": {}})
+
+
+@pytest.mark.asyncio
+async def test_tool_list(tmp_path):
+    tools = tmp_path / "tools"
+    tools.mkdir()
+    (tools / "a.py").write_text("def a(): return 1\n")
+    (tools / "b.py").write_text("def b(): return 2\n")
+    (tools / "__init__.py").write_text("")  # should not appear in list
+    srv = _build_server(tools)
+    result = await srv._handlers["tool.list"]({})
+    names = {t["name"] for t in result}
+    assert names == {"a", "b"}
+
+
+@pytest.mark.asyncio
+async def test_tool_invoke_tool_raising_propagates(tmp_path):
+    tools = tmp_path / "tools"
+    tools.mkdir()
+    (tools / "oops.py").write_text(
+        "def oops():\n    raise ValueError('user-error')\n"
+    )
+    srv = _build_server(tools)
+    with pytest.raises(ValueError, match="user-error"):
+        await srv._handlers["tool.invoke"]({"name": "oops", "args": {}})