lemming-cli 0.1.0__py3-none-any.whl

lemming/__init__.py

@@ -0,0 +1 @@
+"""Lemming: an autonomous, iterative task runner for AI agents."""

lemming/api/__init__.py

@@ -0,0 +1,5 @@
+"""HTTP API for the lemming web UI, built on FastAPI."""
+
+from .main import QuietPollFilter, app
+
+__all__ = ["app", "QuietPollFilter"]

lemming/api/auth.py

@@ -0,0 +1,34 @@
+"""Share-token authentication middleware for remotely shared servers."""
+
+import fastapi
+
+
+async def share_token_middleware(request: fastapi.Request, call_next):
+    """Require a share token for non-local requests when one is configured.
+
+    Accepts the token via the ``token`` query parameter (persisting it in a
+    cookie) or via the ``lemming_share_token`` cookie. Requests from
+    localhost bypass the check. Returns 401 when the token is missing or
+    invalid.
+    """
+    share_token = getattr(request.app.state, "share_token", None)
+    if not share_token:
+        return await call_next(request)
+
+    host = request.headers.get("host", "")
+    if host.startswith("127.0.0.1") or host.startswith("localhost"):
+        return await call_next(request)
+
+    token = request.query_params.get("token")
+    if token == share_token:
+        response = await call_next(request)
+        response.set_cookie(
+            key="lemming_share_token", value=token, httponly=True
+        )
+        return response
+
+    cookie_token = request.cookies.get("lemming_share_token")
+    if cookie_token == share_token:
+        return await call_next(request)
+
+    return fastapi.Response("Unauthorized", status_code=401)

lemming/api/auth_test.py

@@ -0,0 +1,40 @@
+import fastapi.testclient
+
+from lemming import api
+
+
+def test_share_token_middleware():
+    # Setup test client
+    original_token = getattr(api.app.state, "share_token", None)
+    try:
+        api.app.state.share_token = "secret123"
+        # We need a fresh client for each test that modifies app state
+        # middleware if it uses the app state, but here TestClient is
+        # created with api.app
+        client = fastapi.testclient.TestClient(api.app)
+
+        # Missing token -> 401
+        response = client.get("/api/data")
+        assert response.status_code == 401
+
+        # Valid token via query
+        response = client.get("/api/data?token=secret123")
+        assert response.status_code == 200
+        assert "lemming_share_token=secret123" in response.headers.get(
+            "set-cookie", ""
+        )
+
+        # Valid token via cookie
+        client.cookies.set("lemming_share_token", "secret123")
+        response = client.get("/api/data")
+        assert response.status_code == 200
+
+        # Local bypass via host header
+        response = client.get("/api/data", headers={"host": "127.0.0.1:8999"})
+        assert response.status_code == 200
+
+        response = client.get("/api/data", headers={"host": "localhost:8999"})
+        assert response.status_code == 200
+    finally:
+        # Restore
+        api.app.state.share_token = original_token

lemming/api/config.py

@@ -0,0 +1,85 @@
+"""API routes for runner discovery, project configuration, and loop runs."""
+
+import os
+import subprocess
+import sys
+
+import fastapi
+import pydantic
+
+from .. import models, tasks
+from . import context
+
+router = fastapi.APIRouter()
+
+
+@router.get("/api/runners")
+def get_runners():
+    """List the names of all known task runners."""
+    return list(models.KNOWN_RUNNERS)
+
+
+@router.post("/api/context")
+def update_context(
+    request: fastapi.Request, update: dict, project: str | None = None
+):
+    """Update the shared project context passed to task runners."""
+    tasks_file = context.resolve_tasks_file(request.app.state, project)
+    tasks.update_context(tasks_file, update.get("context", ""))
+    return {"status": "ok"}
+
+
+@router.post("/api/config")
+def update_config(
+    request: fastapi.Request,
+    config: tasks.RoadmapConfig,
+    project: str | None = None,
+):
+    """Replace the roadmap configuration and return the saved value."""
+    tasks_file = context.resolve_tasks_file(request.app.state, project)
+    with tasks.lock_tasks(tasks_file):
+        data = tasks.load_tasks(tasks_file)
+        data.config = config
+        tasks.save_tasks(tasks_file, data)
+    return data.config
+
+
+class RunRequest(pydantic.BaseModel):
+    """Request body for starting the orchestrator loop."""
+
+    env: dict[str, str] | None = None
+
+
+@router.post("/api/run")
+def run_loop(
+    request: fastapi.Request,
+    run_request: RunRequest,
+    project: str | None = None,
+):
+    """Start the orchestrator loop as a detached background process."""
+    tasks_file = context.resolve_tasks_file(request.app.state, project)
+    project_dir = context.resolve_project_dir(request.app.state, project)
+
+    # Use sys.executable -m lemming.main to ensure we use the same environment
+    # and pass the explicit tasks file.
+    cmd = [
+        sys.executable,
+        "-m",
+        "lemming.main",
+    ]
+    if getattr(request.app.state, "verbose", False):
+        cmd.append("--verbose")
+    cmd.extend(
+        [
+            "--tasks-file",
+            str(tasks_file),
+            "run",
+        ]
+    )
+
+    env = os.environ.copy()
+    if run_request.env:
+        env.update(run_request.env)
+
+    subprocess.Popen(cmd, start_new_session=True, env=env, cwd=project_dir)
+    return {"status": "started"}

lemming/api/config_test.py

@@ -0,0 +1,84 @@
+from unittest.mock import patch
+
+from lemming import api
+
+
+def test_run_loop(client, test_tasks):
+    with patch("subprocess.Popen") as mock_popen:
+        response = client.post("/api/run", json={"env": {"KEY": "VALUE"}})
+        assert response.status_code == 200
+        assert response.json() == {"status": "started"}
+
+        args = mock_popen.call_args[0][0]
+        assert "run" in args
+        # Check that we didn't pass redundant flags
+        assert "--runner" not in args
+        assert "--retries" not in args
+        assert "--hook" not in args
+
+
+def test_get_runners(client):
+    response = client.get("/api/runners")
+    assert response.status_code == 200
+    assert response.json() == ["agy", "aider", "claude", "codex"]
+
+
+def test_project_context_isolation(client, test_tasks):
+    """Context is isolated per project."""
+    root = api.app.state.root
+    subdir = root / "ctx_test"
+    subdir.mkdir(exist_ok=True)
+
+    # Set context for sub-project
+    response = client.post(
+        "/api/context",
+        json={"context": "Sub-project context"},
+        params={"project": "ctx_test"},
+    )
+    assert response.status_code == 200
+
+    # Root context should be unchanged
+    res = client.get("/api/data")
+    assert res.status_code == 200
+    assert res.json()["context"] == "Initial context"
+
+    # Sub-project context should be set
+    res = client.get("/api/data", params={"project": "ctx_test"})
+    assert res.status_code == 200
+    assert res.json()["context"] == "Sub-project context"
+
+
+def test_run_loop_with_project(client, test_tasks):
+    """POST /api/run with project param uses the correct tasks file."""
+    root = api.app.state.root
+    subdir = root / "run_project"
+    subdir.mkdir(exist_ok=True)
+    (subdir / "tasks.yml").touch()
+
+    with patch("subprocess.Popen") as mock_popen:
+        response = client.post(
+            "/api/run",
+            json={"runner": "claude"},
+            params={"project": "run_project"},
+        )
+        assert response.status_code == 200
+        args = mock_popen.call_args[0][0]
+        # The tasks file should be for the sub-project, not the default
+        tasks_file_idx = args.index("--tasks-file") + 1
+        assert "run_project" in args[tasks_file_idx]
+
+
+def test_run_loop_with_project_cwd(test_workspace, client):
+    root_dir, subproject_dir = test_workspace
+
+    with patch("subprocess.Popen") as mock_popen:
+        response = client.post(
+            "/api/run",
+            json={"runner": "echo", "retries": 1},
+            params={"project": "my-subproject"},
+        )
+        assert response.status_code == 200
+
+        # Verify Popen was called with the correct cwd
+        _, kwargs = mock_popen.call_args
+        assert str(kwargs["cwd"]) == str(subproject_dir)

lemming/api/conftest.py

@@ -0,0 +1,204 @@
+"""Shared pytest fixtures for the API test suite."""
+
+import os
+import pathlib
+import shutil
+import subprocess
+import tempfile
+import time
+
+import fastapi.testclient
+import pytest
+
+from lemming import api, paths, tasks
+
+
+@pytest.fixture
+def client():
+    """A TestClient bound to the lemming FastAPI app."""
+    return fastapi.testclient.TestClient(api.app)
+
+
+@pytest.fixture
+def test_tasks():
+    """A temporary tasks file with sample tasks, wired into the app state."""
+    # Create a temporary directory and a tasks file
+    test_dir = tempfile.mkdtemp()
+    test_tasks_file = pathlib.Path(test_dir) / "tasks_test.yml"
+
+    # Scaffold a valid file
+    data = tasks.Roadmap(
+        context="Initial context",
+        tasks=[
+            tasks.Task(
+                id="task1",
+                description="Completed Task",
+                status=tasks.TaskStatus.COMPLETED,
+                attempts=1,
+                progress=["All good"],
+                completed_at=123456789.0,
+            ),
+            tasks.Task(
+                id="task2",
+                description="Pending Task",
+                status=tasks.TaskStatus.PENDING,
+                attempts=0,
+                progress=[],
+            ),
+            tasks.Task(
+                id="task3",
+                description="In Progress Task",
+                status=tasks.TaskStatus.IN_PROGRESS,
+                attempts=1,
+                progress=[],
+                pid=os.getpid(),
+                last_heartbeat=time.time(),
+            ),
+        ],
+    )
+    tasks.save_tasks(test_tasks_file, data)
+
+    # Override the TASKS_FILE and root in the api module
+    original_tasks_file = api.app.state.tasks_file
+    original_root = api.app.state.root
+    original_auto_start = api.app.state.disable_auto_start
+    api.app.state.tasks_file = test_tasks_file
+    api.app.state.root = pathlib.Path(test_dir).resolve()
+    api.app.state.disable_auto_start = True
+
+    yield test_tasks_file
+
+    # Restore the originals
+    api.app.state.tasks_file = original_tasks_file
+    api.app.state.root = original_root
+    api.app.state.disable_auto_start = original_auto_start
+    shutil.rmtree(test_dir)
+
+
+@pytest.fixture
+def git_repo():
+    """A temporary git repo with tracked and gitignored files as the root."""
+    # Create a temporary directory and initialize a git repo
+    test_dir = tempfile.mkdtemp()
+    orig_cwd = os.getcwd()
+    original_root = api.app.state.root
+    os.chdir(test_dir)
+    api.app.state.root = pathlib.Path(test_dir).resolve()
+
+    # Clear cached git repo check from previous tests
+    if hasattr(paths.in_git_repo, "_result"):
+        del paths.in_git_repo._result
+
+    subprocess.run(["git", "init"], check=True)
+    subprocess.run(
+        ["git", "config", "user.email", "you@example.com"], check=True
+    )
+    subprocess.run(["git", "config", "user.name", "Your Name"], check=True)
+
+    # Create some files
+    (pathlib.Path(test_dir) / "file1.txt").write_text("content1")
+    (pathlib.Path(test_dir) / "dir1").mkdir()
+    (pathlib.Path(test_dir) / "dir1" / "file2.txt").write_text("content2")
+
+    # Create .gitignore and ignore some files
+    (pathlib.Path(test_dir) / ".gitignore").write_text(
+        "ignored.txt\nnode_modules/"
+    )
+    (pathlib.Path(test_dir) / "ignored.txt").write_text("should be ignored")
+    (pathlib.Path(test_dir) / "node_modules").mkdir()
+    (pathlib.Path(test_dir) / "node_modules" / "some_file.txt").write_text(
+        "ignored"
+    )
+
+    yield pathlib.Path(test_dir)
+
+    # Clear cached git repo check and restore cwd
+    if hasattr(paths.in_git_repo, "_result"):
+        del paths.in_git_repo._result
+    os.chdir(orig_cwd)
+    api.app.state.root = original_root
+    shutil.rmtree(test_dir)
+
+
+@pytest.fixture
+def non_git_dir():
+    """A temporary directory that is NOT a git repo."""
+    test_dir = tempfile.mkdtemp()
+    orig_cwd = os.getcwd()
+    original_root = api.app.state.root
+    os.chdir(test_dir)
+    api.app.state.root = pathlib.Path(test_dir).resolve()
+
+    # Clear cached git repo check
+    if hasattr(paths.in_git_repo, "_result"):
+        del paths.in_git_repo._result
+
+    # Create files (including one that would be "ignored" if git were present)
+    (pathlib.Path(test_dir) / "file1.txt").write_text("content1")
+    (pathlib.Path(test_dir) / "ignored.txt").write_text("not actually ignored")
+
+    yield pathlib.Path(test_dir)
+
+    if hasattr(paths.in_git_repo, "_result"):
+        del paths.in_git_repo._result
+    os.chdir(orig_cwd)
+    api.app.state.root = original_root
+    shutil.rmtree(test_dir)
+
+
+@pytest.fixture
+def temp_repo(tmp_path, monkeypatch):
+    """Create a temporary directory and set it as the API root."""
+    root = tmp_path / "repo"
+    root.mkdir()
+
+    # Mock api.app.state.root
+    original_root = api.app.state.root
+    api.app.state.root = root
+
+    yield root
+
+    # Restore original root
+    api.app.state.root = original_root
+
+
+@pytest.fixture
+def test_workspace():
+    """A temporary root with a subproject, with auto-start enabled."""
+    # Create a temporary root directory
+    root_dir = pathlib.Path(tempfile.mkdtemp()).resolve()
+
+    # Create a subproject directory
+    subproject_dir = root_dir / "my-subproject"
+    subproject_dir.mkdir()
+
+    # Set up some tasks in the subproject
+    sub_tasks_file = subproject_dir / "tasks.yml"
+    data = tasks.Roadmap(
+        context="Subproject context",
+        tasks=[
+            tasks.Task(
+                id="sub1",
+                description="Sub Task 1",
+                status=tasks.TaskStatus.PENDING,
+            ),
+        ],
+    )
+    tasks.save_tasks(sub_tasks_file, data)
+
+    # Override app state
+    original_root = api.app.state.root
+    original_tasks_file = api.app.state.tasks_file
+    original_auto_start = api.app.state.disable_auto_start
+
+    api.app.state.root = root_dir
+    api.app.state.tasks_file = root_dir / "tasks.yml"
+    api.app.state.disable_auto_start = False  # Enable auto-start for testing
+
+    yield root_dir, subproject_dir
+
+    # Restore app state
+    api.app.state.root = original_root
+    api.app.state.tasks_file = original_tasks_file
+    api.app.state.disable_auto_start = original_auto_start
+    shutil.rmtree(root_dir)

lemming/api/context.py

@@ -0,0 +1,39 @@
+"""Helpers to resolve per-project directories and tasks files."""
+
+import pathlib
+
+import fastapi
+
+from .. import paths
+
+
+def resolve_project_dir(
+    app_state: fastapi.datastructures.State, project: str | None = None
+) -> pathlib.Path:
+    """Resolve a project query parameter to its absolute directory path."""
+    if not project:
+        return app_state.root
+
+    root = app_state.root
+    target = (root / project).resolve()
+    if not target.is_relative_to(root):
+        raise fastapi.HTTPException(403, "Path is outside the server root")
+    if not target.is_dir():
+        raise fastapi.HTTPException(400, "Not a directory")
+
+    return target
+
+
+def resolve_tasks_file(
+    app_state: fastapi.datastructures.State, project: str | None = None
+) -> pathlib.Path:
+    """Resolve a project query parameter to a tasks file path.
+
+    When *project* is ``None`` or empty the server-wide default is returned.
+    Otherwise the value is treated as a relative directory under the server
+    root and the tasks file path is derived deterministically.
+    """
+    if not project:
+        return app_state.tasks_file
+
+    return paths.get_tasks_file_for_dir(resolve_project_dir(app_state, project))

lemming/api/context_test.py

@@ -0,0 +1,62 @@
+import pathlib
+
+import fastapi
+import pytest
+
+from lemming.api import context
+
+
+class MockAppState:
+    def __init__(self, root: pathlib.Path, tasks_file: pathlib.Path):
+        self.root = root
+        self.tasks_file = tasks_file
+
+
+def test_resolve_project_dir(tmp_path):
+    root = tmp_path / "root"
+    root.mkdir()
+    project = root / "project"
+    project.mkdir()
+
+    app_state = MockAppState(root, root / "tasks.yml")
+
+    # Default (no project)
+    assert context.resolve_project_dir(app_state) == root
+
+    # Specific project
+    assert context.resolve_project_dir(app_state, "project") == project
+
+    # Outside root
+    with pytest.raises(fastapi.HTTPException) as excinfo:
+        context.resolve_project_dir(app_state, "..")
+    assert excinfo.value.status_code == 403
+
+    # Not a directory
+    not_dir = root / "file.txt"
+    not_dir.write_text("hello")
+    with pytest.raises(fastapi.HTTPException) as excinfo:
+        context.resolve_project_dir(app_state, "file.txt")
+    assert excinfo.value.status_code == 400
+
+
+def test_resolve_tasks_file(tmp_path):
+    root = tmp_path / "root"
+    root.mkdir()
+    project = root / "project"
+    project.mkdir()
+
+    default_tasks = root / "tasks.yml"
+    app_state = MockAppState(root, default_tasks)
+
+    # Default
+    assert context.resolve_tasks_file(app_state) == default_tasks
+
+    # Project (should use get_tasks_file_for_dir logic)
+    # Since project / tasks.yml doesn't exist, it should be in lemming home
+    # with a hash
+    tasks_file = context.resolve_tasks_file(app_state, "project")
+    assert tasks_file.name == "tasks.yml"
+    assert (
+        tasks_file.parent.name != "project"
+    )  # It's a hash, not the project name
+    assert tasks_file.is_absolute()

lemming/api/directories.py

@@ -0,0 +1,57 @@
+"""API routes for browsing and creating directories under the root."""
+
+import fastapi
+import pydantic
+
+router = fastapi.APIRouter()
+
+
+@router.get("/api/directories")
+def list_directories(request: fastapi.Request, path: str = ""):
+    """List subdirectories under the server root for the project picker."""
+    root = request.app.state.root
+    target = (root / path).resolve() if path else root
+    if not target.is_relative_to(root):
+        raise fastapi.HTTPException(403, "Path is outside the server root")
+    if not target.is_dir():
+        raise fastapi.HTTPException(400, "Not a directory")
+
+    dirs = []
+    for item in sorted(target.iterdir()):
+        if item.is_dir() and not item.name.startswith("."):
+            rel = item.relative_to(root)
+            dirs.append({"name": item.name, "path": str(rel)})
+    return {"path": path, "directories": dirs}
+
+
+class CreateDirectoryRequest(pydantic.BaseModel):
+    """Request body for creating a directory under the server root."""
+
+    path: str = ""
+    name: str
+
+
+@router.post("/api/directories")
+def create_directory(
+    request: fastapi.Request, dir_request: CreateDirectoryRequest
+):
+    """Create a new directory under the server root."""
+    root = request.app.state.root
+    parent = (root / dir_request.path).resolve() if dir_request.path else root
+    if not parent.is_relative_to(root):
+        raise fastapi.HTTPException(403, "Path is outside the server root")
+    if not parent.is_dir():
+        raise fastapi.HTTPException(400, "Parent is not a directory")
+
+    new_dir = parent / dir_request.name
+    if not new_dir.resolve().is_relative_to(root):
+        raise fastapi.HTTPException(
+            403, "Target path is outside the server root"
+        )
+
+    if new_dir.exists():
+        raise fastapi.HTTPException(400, "Directory already exists")
+
+    new_dir.mkdir()
+    rel = new_dir.relative_to(root)
+    return {"name": new_dir.name, "path": str(rel)}