toq-plugins-common 0.1.0.dev1__tar.gz

toq_plugins_common-0.1.0.dev1/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+*.whl
+.venv/
+.env

toq_plugins_common-0.1.0.dev1/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: toq-plugins-common
+Version: 0.1.0.dev1
+Summary: Shared daemon management for toq framework plugins
+License-Expression: Apache-2.0
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.28

toq_plugins_common-0.1.0.dev1/pyproject.toml

@@ -0,0 +1,14 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "toq-plugins-common"
+version = "0.1.0.dev1"
+description = "Shared daemon management for toq framework plugins"
+requires-python = ">=3.10"
+license = "Apache-2.0"
+dependencies = ["httpx>=0.28"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["toq_plugins_common"]

toq_plugins_common-0.1.0.dev1/tests/test_binary.py

@@ -0,0 +1,134 @@
+"""Tests for toq_plugins_common.binary module."""
+
+import platform
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+from toq_plugins_common import binary
+
+
+def test_detect_platform_darwin_arm():
+    with patch.object(platform, "system", return_value="Darwin"), \
+         patch.object(platform, "machine", return_value="arm64"):
+        assert binary.detect_platform() == "darwin-aarch64"
+
+
+def test_detect_platform_linux_x86():
+    with patch.object(platform, "system", return_value="Linux"), \
+         patch.object(platform, "machine", return_value="x86_64"):
+        assert binary.detect_platform() == "linux-x86_64"
+
+
+def test_detect_platform_darwin_x86():
+    with patch.object(platform, "system", return_value="Darwin"), \
+         patch.object(platform, "machine", return_value="x86_64"):
+        assert binary.detect_platform() == "darwin-x86_64"
+
+
+def test_detect_platform_linux_aarch64():
+    with patch.object(platform, "system", return_value="Linux"), \
+         patch.object(platform, "machine", return_value="aarch64"):
+        assert binary.detect_platform() == "linux-aarch64"
+
+
+def test_detect_platform_unsupported_os():
+    with patch.object(platform, "system", return_value="Windows"), \
+         patch.object(platform, "machine", return_value="x86_64"):
+        with pytest.raises(binary.UnsupportedPlatformError, match="Unsupported OS"):
+            binary.detect_platform()
+
+
+def test_detect_platform_unsupported_arch():
+    with patch.object(platform, "system", return_value="Linux"), \
+         patch.object(platform, "machine", return_value="mips"):
+        with pytest.raises(binary.UnsupportedPlatformError, match="Unsupported architecture"):
+            binary.detect_platform()
+
+
+def test_binary_path():
+    path = binary.binary_path()
+    assert path == Path.home() / ".toq" / "bin" / "toq"
+
+
+def test_bundled_binary_path_raises_without_set():
+    binary._bundled_bin_dir = None
+    with pytest.raises(RuntimeError, match="No bundled binary directory"):
+        binary.bundled_binary_path()
+
+
+def test_set_bundled_bin_dir():
+    test_path = Path("/tmp/test-bin")
+    binary.set_bundled_bin_dir(test_path)
+    assert binary._bundled_bin_dir == test_path
+    binary._bundled_bin_dir = None  # cleanup
+
+
+def test_bundled_binary_path_returns_correct_after_set():
+    test_path = Path("/tmp/test-bin")
+    binary.set_bundled_bin_dir(test_path)
+    with patch.object(binary, "detect_platform", return_value="darwin-aarch64"):
+        result = binary.bundled_binary_path()
+        assert result == test_path / "darwin-aarch64" / "toq"
+    binary._bundled_bin_dir = None  # cleanup
+
+
+def test_ensure_extracted_copies_when_target_missing(tmp_path):
+    bundled_dir = tmp_path / "bundled" / "darwin-aarch64"
+    bundled_dir.mkdir(parents=True)
+    bundled_bin = bundled_dir / "toq"
+    bundled_bin.write_text("#!/bin/sh\necho toq 0.1.0")
+    bundled_bin.chmod(0o755)
+
+    target_dir = tmp_path / "bin"
+    target = target_dir / "toq"
+
+    binary.set_bundled_bin_dir(tmp_path / "bundled")
+
+    with patch.object(binary, "BIN_DIR", target_dir), \
+         patch.object(binary, "detect_platform", return_value="darwin-aarch64"):
+        result = binary.ensure_extracted()
+        assert result == target
+        assert target.exists()
+
+    binary._bundled_bin_dir = None
+
+
+def test_ensure_extracted_raises_if_bundled_missing(tmp_path):
+    bundled_dir = tmp_path / "bundled"
+    bundled_dir.mkdir()
+    binary.set_bundled_bin_dir(bundled_dir)
+
+    with patch.object(binary, "BIN_DIR", tmp_path / "bin"), \
+         patch.object(binary, "detect_platform", return_value="darwin-aarch64"):
+        with pytest.raises(FileNotFoundError, match="No bundled toq binary"):
+            binary.ensure_extracted()
+
+    binary._bundled_bin_dir = None
+
+
+def test_ensure_extracted_skips_if_versions_match(tmp_path):
+    import shutil
+
+    bundled_dir = tmp_path / "bundled" / "darwin-aarch64"
+    bundled_dir.mkdir(parents=True)
+    bundled_bin = bundled_dir / "toq"
+    bundled_bin.write_text("fake")
+    bundled_bin.chmod(0o755)
+
+    target_dir = tmp_path / "bin"
+    target_dir.mkdir()
+    target = target_dir / "toq"
+    target.write_text("fake")
+    target.chmod(0o755)
+
+    binary.set_bundled_bin_dir(tmp_path / "bundled")
+
+    with patch.object(binary, "BIN_DIR", target_dir), \
+         patch.object(binary, "detect_platform", return_value="darwin-aarch64"), \
+         patch.object(binary, "_get_version", return_value="toq 0.1.0"):
+        result = binary.ensure_extracted()
+        assert result == target
+
+    binary._bundled_bin_dir = None

toq_plugins_common-0.1.0.dev1/tests/test_daemon.py

@@ -0,0 +1,105 @@
+"""Tests for toq_plugins_common.daemon module."""
+
+import subprocess
+from unittest.mock import patch, MagicMock
+
+import pytest
+
+from toq_plugins_common import daemon
+
+
+def test_is_running_true():
+    with patch("httpx.get") as mock_get:
+        mock_get.return_value = MagicMock(status_code=200)
+        assert daemon.is_running(9009) is True
+
+
+def test_is_running_false_on_connect_error():
+    import httpx
+    with patch("httpx.get", side_effect=httpx.ConnectError("refused")):
+        assert daemon.is_running(9009) is False
+
+
+def test_is_running_false_on_timeout():
+    import httpx
+    with patch("httpx.get", side_effect=httpx.TimeoutException("timeout")):
+        assert daemon.is_running(9009) is False
+
+
+def test_stop_noop_when_no_managed_process():
+    daemon._managed_process = None
+    daemon.stop()  # should not raise
+
+
+def test_stop_sends_shutdown_and_waits():
+    mock_proc = MagicMock()
+    mock_proc.wait.return_value = 0
+    daemon._managed_process = mock_proc
+    daemon._log_file = MagicMock()
+
+    with patch("httpx.post"):
+        daemon.stop()
+
+    assert daemon._managed_process is None
+    mock_proc.wait.assert_called_once()
+
+
+def test_ensure_running_starts_if_not_running():
+    with patch.object(daemon, "is_running", return_value=False), \
+         patch.object(daemon, "start") as mock_start:
+        daemon.ensure_running()
+        mock_start.assert_called_once()
+
+
+def test_ensure_running_noop_if_running():
+    with patch.object(daemon, "is_running", return_value=True), \
+         patch.object(daemon, "start") as mock_start:
+        daemon.ensure_running()
+        mock_start.assert_not_called()
+
+
+def test_atexit_stop_swallows_exceptions():
+    with patch.object(daemon, "stop", side_effect=RuntimeError("boom")):
+        daemon._atexit_stop(9009)  # should not raise
+
+
+def test_start_raises_if_process_exits_immediately():
+    mock_proc = MagicMock()
+    mock_proc.poll.return_value = 1  # exited immediately
+    mock_proc.returncode = 1
+
+    with patch("subprocess.Popen", return_value=mock_proc), \
+         patch("builtins.open", MagicMock()), \
+         patch.object(daemon, "LOG_DIR", MagicMock()):
+        with pytest.raises(RuntimeError, match="exited immediately"):
+            daemon.start()
+
+
+def test_start_raises_if_health_timeout():
+    mock_proc = MagicMock()
+    mock_proc.poll.return_value = None  # still running
+
+    with patch("subprocess.Popen", return_value=mock_proc), \
+         patch("builtins.open", MagicMock()), \
+         patch.object(daemon, "LOG_DIR", MagicMock()), \
+         patch.object(daemon, "is_running", return_value=False), \
+         patch.object(daemon, "HEALTH_TIMEOUT_SECONDS", 0.1), \
+         patch.object(daemon, "HEALTH_POLL_INTERVAL_SECONDS", 0.05):
+        with pytest.raises(RuntimeError, match="did not become healthy"):
+            daemon.start()
+        mock_proc.terminate.assert_called_once()
+
+
+def test_stop_terminates_on_shutdown_timeout():
+    mock_proc = MagicMock()
+    mock_proc.wait.side_effect = [subprocess.TimeoutExpired("toq", 5), None]
+
+    daemon._managed_process = mock_proc
+    daemon._log_file = MagicMock()
+
+    import httpx
+    with patch("httpx.post", side_effect=httpx.ConnectError("refused")):
+        daemon.stop()
+
+    mock_proc.terminate.assert_called_once()
+    assert daemon._managed_process is None

toq_plugins_common-0.1.0.dev1/tests/test_setup.py

@@ -0,0 +1,61 @@
+"""Tests for toq_plugins_common.setup module."""
+
+from pathlib import Path
+from unittest.mock import patch, MagicMock
+
+from toq_plugins_common import setup
+
+
+def test_is_configured_true(tmp_path):
+    config = tmp_path / "config.toml"
+    config.write_text("[agent]")
+    with patch.object(setup, "CONFIG_PATH", config):
+        assert setup.is_configured() is True
+
+
+def test_is_configured_false(tmp_path):
+    with patch.object(setup, "CONFIG_PATH", tmp_path / "missing.toml"):
+        assert setup.is_configured() is False
+
+
+def test_ensure_configured_noop_when_configured(tmp_path):
+    config = tmp_path / "config.toml"
+    config.write_text("[agent]")
+    with patch.object(setup, "CONFIG_PATH", config), \
+         patch("subprocess.run") as mock_run:
+        setup.ensure_configured()
+        mock_run.assert_not_called()
+
+
+def test_ensure_configured_runs_setup(tmp_path):
+    with patch.object(setup, "CONFIG_PATH", tmp_path / "missing.toml"), \
+         patch("toq_plugins_common.setup.binary_path", return_value=Path("/usr/bin/toq")), \
+         patch("subprocess.run") as mock_run:
+        mock_run.return_value = MagicMock(returncode=0)
+        setup.ensure_configured(agent_name="bot", connection_mode="open")
+        mock_run.assert_called_once()
+        cmd = mock_run.call_args[0][0]
+        assert "--agent-name=bot" in cmd
+        assert "--connection-mode=open" in cmd
+
+
+def test_ensure_configured_raises_on_failure(tmp_path):
+    import pytest
+    with patch.object(setup, "CONFIG_PATH", tmp_path / "missing.toml"), \
+         patch("toq_plugins_common.setup.binary_path", return_value=Path("/usr/bin/toq")), \
+         patch("subprocess.run") as mock_run:
+        mock_run.return_value = MagicMock(returncode=1, stderr="setup failed")
+        with pytest.raises(RuntimeError, match="toq setup failed"):
+            setup.ensure_configured()
+
+
+def test_ensure_configured_uses_defaults(tmp_path):
+    with patch.object(setup, "CONFIG_PATH", tmp_path / "missing.toml"), \
+         patch("toq_plugins_common.setup.binary_path", return_value=Path("/usr/bin/toq")), \
+         patch("subprocess.run") as mock_run:
+        mock_run.return_value = MagicMock(returncode=0)
+        setup.ensure_configured()
+        cmd = mock_run.call_args[0][0]
+        assert "--agent-name=agent" in cmd
+        assert "--connection-mode=approval" in cmd
+        assert "--adapter=http" in cmd

toq_plugins_common-0.1.0.dev1/toq_plugins_common/__init__.py

@@ -0,0 +1,14 @@
+"""Shared daemon management for toq framework plugins."""
+
+from toq_plugins_common.binary import ensure_extracted
+from toq_plugins_common.daemon import ensure_running, start, stop
+from toq_plugins_common.setup import ensure_configured, is_configured
+
+__all__ = [
+    "ensure_extracted",
+    "ensure_configured",
+    "ensure_running",
+    "is_configured",
+    "start",
+    "stop",
+]

toq_plugins_common-0.1.0.dev1/toq_plugins_common/binary.py

@@ -0,0 +1,106 @@
+"""Binary bundling and extraction for the toq daemon."""
+
+import platform
+import shutil
+import stat
+import subprocess
+from pathlib import Path
+
+TOQ_HOME = Path.home() / ".toq"
+BIN_DIR = TOQ_HOME / "bin"
+BINARY_NAME = "toq"
+VERSION_CHECK_TIMEOUT_SECONDS = 5
+
+# Set by each plugin to point to its bundled binary directory.
+# e.g. Path(__file__).parent / "bin"
+_bundled_bin_dir: Path | None = None
+
+
+class UnsupportedPlatformError(RuntimeError):
+    """Raised when the current platform has no bundled binary."""
+
+
+def detect_platform() -> str:
+    """Return platform tag like 'darwin-aarch64' or 'linux-x86_64'."""
+    system = platform.system().lower()
+    machine = platform.machine().lower()
+
+    arch_map = {
+        "x86_64": "x86_64",
+        "amd64": "x86_64",
+        "aarch64": "aarch64",
+        "arm64": "aarch64",
+    }
+
+    if system not in ("darwin", "linux"):
+        raise UnsupportedPlatformError(f"Unsupported OS: {system}")
+
+    arch = arch_map.get(machine)
+    if arch is None:
+        raise UnsupportedPlatformError(f"Unsupported architecture: {machine}")
+
+    return f"{system}-{arch}"
+
+
+def binary_path() -> Path:
+    """Path where the extracted binary lives."""
+    return BIN_DIR / BINARY_NAME
+
+
+def bundled_binary_path() -> Path:
+    """Path to the binary inside the installed plugin wheel."""
+    if _bundled_bin_dir is None:
+        raise RuntimeError(
+            "No bundled binary directory configured. "
+            "Call toq_plugins_common.binary.set_bundled_bin_dir() first"
+        )
+    return _bundled_bin_dir / detect_platform() / BINARY_NAME
+
+
+def set_bundled_bin_dir(path: Path) -> None:
+    """Set the directory containing platform-specific bundled binaries."""
+    global _bundled_bin_dir
+    _bundled_bin_dir = path
+
+
+def _get_version(path: Path) -> str | None:
+    """Run the binary and return its version string, or None on failure."""
+    try:
+        result = subprocess.run(
+            [str(path), "--version"],
+            capture_output=True,
+            text=True,
+            timeout=VERSION_CHECK_TIMEOUT_SECONDS,
+        )
+        if result.returncode != 0:
+            return None
+        return result.stdout.strip()
+    except (subprocess.TimeoutExpired, OSError):
+        return None
+
+
+def ensure_extracted() -> Path:
+    """Extract the bundled binary to ~/.toq/bin/toq if needed.
+
+    Skips extraction if the binary exists and versions match.
+    Returns the path to the binary.
+    """
+    target = binary_path()
+    bundled = bundled_binary_path()
+
+    if not bundled.exists():
+        raise FileNotFoundError(
+            f"No bundled toq binary for {detect_platform()}"
+        )
+
+    if target.exists():
+        target_ver = _get_version(target)
+        bundled_ver = _get_version(bundled)
+        if target_ver and bundled_ver and target_ver == bundled_ver:
+            return target
+
+    BIN_DIR.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(bundled, target)
+    target.chmod(target.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+
+    return target

toq_plugins_common-0.1.0.dev1/toq_plugins_common/daemon.py

@@ -0,0 +1,128 @@
+"""Daemon lifecycle management for the toq daemon."""
+
+import atexit
+import logging
+import subprocess
+import time
+
+import httpx
+
+from toq_plugins_common.binary import TOQ_HOME, binary_path
+
+logger = logging.getLogger("toq_plugins_common.daemon")
+
+DEFAULT_PORT = 9009
+HEALTH_TIMEOUT_SECONDS = 10
+HEALTH_POLL_INTERVAL_SECONDS = 0.25
+HEALTH_CHECK_TIMEOUT_SECONDS = 2
+SHUTDOWN_TIMEOUT_SECONDS = 5
+KILL_TIMEOUT_SECONDS = 2
+LOG_DIR = TOQ_HOME / "logs"
+
+_managed_process: subprocess.Popen | None = None
+_log_file = None
+_atexit_registered = False
+
+
+def _health_url(port: int) -> str:
+    return f"http://127.0.0.1:{port}/v1/health"
+
+
+def _shutdown_url(port: int) -> str:
+    return f"http://127.0.0.1:{port}/v1/daemon/shutdown"
+
+
+def is_running(port: int = DEFAULT_PORT) -> bool:
+    """Check if the daemon is responding on the given port."""
+    try:
+        resp = httpx.get(_health_url(port), timeout=HEALTH_CHECK_TIMEOUT_SECONDS)
+        return resp.status_code == 200
+    except (httpx.ConnectError, httpx.TimeoutException):
+        return False
+
+
+def start(port: int = DEFAULT_PORT) -> subprocess.Popen:
+    """Start the toq daemon and wait for it to become healthy."""
+    global _managed_process, _log_file, _atexit_registered
+
+    LOG_DIR.mkdir(parents=True, exist_ok=True)
+    _log_file = open(LOG_DIR / "daemon.log", "a")
+
+    try:
+        proc = subprocess.Popen(
+            [str(binary_path()), "up", "--foreground"],
+            stdout=_log_file,
+            stderr=_log_file,
+        )
+    except Exception:
+        _log_file.close()
+        _log_file = None
+        raise
+
+    deadline = time.monotonic() + HEALTH_TIMEOUT_SECONDS
+    while time.monotonic() < deadline:
+        if proc.poll() is not None:
+            _log_file.close()
+            _log_file = None
+            raise RuntimeError(
+                f"toq daemon exited immediately (code {proc.returncode})"
+            )
+        if is_running(port):
+            _managed_process = proc
+            if not _atexit_registered:
+                atexit.register(_atexit_stop, port)
+                _atexit_registered = True
+            return proc
+        time.sleep(HEALTH_POLL_INTERVAL_SECONDS)
+
+    proc.terminate()
+    _log_file.close()
+    _log_file = None
+    raise RuntimeError(
+        f"toq daemon did not become healthy within {HEALTH_TIMEOUT_SECONDS}s"
+    )
+
+
+def stop(port: int = DEFAULT_PORT) -> None:
+    """Stop the daemon if we started it."""
+    global _managed_process, _log_file
+
+    if _managed_process is None:
+        return
+
+    try:
+        httpx.post(
+            _shutdown_url(port),
+            json={"graceful": True},
+            timeout=SHUTDOWN_TIMEOUT_SECONDS,
+        )
+    except (httpx.ConnectError, httpx.TimeoutException):
+        pass
+
+    try:
+        _managed_process.wait(timeout=SHUTDOWN_TIMEOUT_SECONDS)
+    except subprocess.TimeoutExpired:
+        _managed_process.terminate()
+        try:
+            _managed_process.wait(timeout=KILL_TIMEOUT_SECONDS)
+        except subprocess.TimeoutExpired:
+            _managed_process.kill()
+
+    _managed_process = None
+    if _log_file is not None:
+        _log_file.close()
+        _log_file = None
+
+
+def ensure_running(port: int = DEFAULT_PORT) -> None:
+    """Start the daemon if it's not already running."""
+    if not is_running(port):
+        start(port)
+
+
+def _atexit_stop(port: int) -> None:
+    """Registered with atexit to clean up the daemon on exit."""
+    try:
+        stop(port)
+    except Exception:
+        pass

toq_plugins_common-0.1.0.dev1/toq_plugins_common/setup.py

@@ -0,0 +1,45 @@
+"""Programmatic setup for the toq daemon."""
+
+import subprocess
+
+from toq_plugins_common.binary import TOQ_HOME, binary_path
+
+CONFIG_PATH = TOQ_HOME / "config.toml"
+
+DEFAULT_AGENT_NAME = "agent"
+DEFAULT_CONNECTION_MODE = "approval"
+DEFAULT_ADAPTER = "http"
+SETUP_TIMEOUT_SECONDS = 30
+
+
+def is_configured() -> bool:
+    """Return True if toq setup has been completed."""
+    return CONFIG_PATH.exists()
+
+
+def ensure_configured(
+    *,
+    agent_name: str | None = None,
+    connection_mode: str | None = None,
+    adapter: str | None = None,
+) -> None:
+    """Run toq setup --non-interactive if not already configured.
+
+    If config already exists, this is a no-op. Parameters only apply
+    to fresh setup.
+    """
+    if is_configured():
+        return
+
+    cmd = [
+        str(binary_path()),
+        "setup",
+        "--non-interactive",
+        f"--agent-name={agent_name or DEFAULT_AGENT_NAME}",
+        f"--connection-mode={connection_mode or DEFAULT_CONNECTION_MODE}",
+        f"--adapter={adapter or DEFAULT_ADAPTER}",
+    ]
+
+    result = subprocess.run(cmd, capture_output=True, text=True, timeout=SETUP_TIMEOUT_SECONDS)
+    if result.returncode != 0:
+        raise RuntimeError(f"toq setup failed: {result.stderr.strip()}")