Skip to content

Your lightweight open-source personal agent.

17.6 KB
Raw Blame
from unittest.mock import MagicMock

import pytest

from nanobot.security.workspace_access import (
    WORKSPACE_SCOPE_METADATA_KEY,
    WorkspaceScopeError,
    default_workspace_scope,
)
from nanobot.session.manager import SessionManager
from nanobot.session.sqlite_store import SqliteSessionStore
from nanobot.webui.workspaces import (
    WebUIWorkspaceController,
    read_webui_default_access_mode,
    read_webui_workspace_state,
    webui_workspace_state_path,
    workspaces_payload,
    write_webui_default_access_mode,
)


def test_workspace_state_defaults_when_file_missing(tmp_path, monkeypatch) -> None:
    monkeypatch.setattr("nanobot.webui.workspaces.get_webui_dir", lambda: tmp_path / "webui")

    state = read_webui_workspace_state()

    assert state["default_access_mode"] == "default"
    assert webui_workspace_state_path() == tmp_path / "webui" / "workspace-state.json"


def test_workspace_payload_is_config_data_dir_scoped(tmp_path, monkeypatch) -> None:
    monkeypatch.setattr("nanobot.webui.workspaces.get_webui_dir", lambda: tmp_path / "webui")
    default = tmp_path / "default"
    default.mkdir()

    payload = workspaces_payload(
        default_workspace=default,
        default_restrict_to_workspace=False,
        can_change_project=True,
    )

    assert payload["default_scope"]["project_path"] == str(default.resolve())
    assert payload["default_scope"]["access_mode"] == "full"
    assert payload["default_access_mode"] == "default"
    assert payload["controls"]["can_change_project"] is True


def test_workspace_payload_hides_project_selection_when_unavailable(
    tmp_path,
    monkeypatch,
) -> None:
    monkeypatch.setattr("nanobot.webui.workspaces.get_webui_dir", lambda: tmp_path / "webui")
    default = tmp_path / "default"
    default.mkdir()

    payload = workspaces_payload(
        default_workspace=default,
        default_restrict_to_workspace=False,
        can_change_project=False,
    )

    assert payload["controls"]["can_change_project"] is False


def test_workspace_payload_uses_webui_default_access_mode(tmp_path, monkeypatch) -> None:
    monkeypatch.setattr("nanobot.webui.workspaces.get_webui_dir", lambda: tmp_path / "webui")
    default = tmp_path / "default"
    default.mkdir()

    assert write_webui_default_access_mode("full") is True
    assert write_webui_default_access_mode("full") is False

    payload = workspaces_payload(
        default_workspace=default,
        default_restrict_to_workspace=True,
        can_change_project=True,
    )

    assert payload["default_access_mode"] == "full"
    assert payload["default_scope"]["project_path"] == str(default.resolve())
    assert payload["default_scope"]["access_mode"] == "full"


def test_legacy_restricted_webui_default_access_mode_maps_to_default(tmp_path, monkeypatch) -> None:
    monkeypatch.setattr("nanobot.webui.workspaces.get_webui_dir", lambda: tmp_path / "webui")

    assert write_webui_default_access_mode("restricted") is False
    assert read_webui_default_access_mode() == "default"


async def test_webui_default_access_applies_to_unscoped_old_sessions(tmp_path, monkeypatch) -> None:
    monkeypatch.setattr("nanobot.webui.workspaces.get_webui_dir", lambda: tmp_path / "webui")
    default = tmp_path / "default"
    default.mkdir()
    sessions = SessionManager(tmp_path / "sessions")
    sessions.save(sessions.get_or_create("websocket:old-chat"))
    write_webui_default_access_mode("full")
    controller = WebUIWorkspaceController(
        session_manager=sessions,
        default_workspace=default,
        default_restrict_to_workspace=True,
    )

    scope = controller.scope_for_session_key("websocket:old-chat")
    new_scope = await controller.scope_for_new_chat(
        {},
        can_change_project=True,
    )

    assert scope.project_path == default.resolve()
    assert scope.access_mode == "full"
    assert new_scope.access_mode == "full"


@pytest.mark.parametrize("scope_present", [False, True])
async def test_old_session_scope_defaults_respect_connection_authority(
    tmp_path, monkeypatch, scope_present: bool,
) -> None:
    monkeypatch.setattr("nanobot.webui.workspaces.get_webui_dir", lambda: tmp_path / "webui")
    default = tmp_path / "default"
    default.mkdir()
    sessions = SessionManager(tmp_path / "sessions")
    session = sessions.get_or_create("websocket:legacy")
    if scope_present:
        session.metadata[WORKSPACE_SCOPE_METADATA_KEY] = None
    sessions.save(session)
    write_webui_default_access_mode("full")
    controller = WebUIWorkspaceController(
        session_manager=sessions, default_workspace=default, default_restrict_to_workspace=True,
    )

    client_scope = await controller.scope_for_message(
        {}, chat_id="legacy", chat_running=False, can_change_project=False,
    )
    owner_scope = await controller.scope_for_message(
        {}, chat_id="legacy", chat_running=False, can_change_project=True,
    )

    assert client_scope.project_path == default.resolve()
    assert client_scope.access_mode == "restricted"
    assert owner_scope.access_mode == ("restricted" if scope_present else "full")
    assert sessions.read_session_metadata("websocket:legacy")["metadata"] == session.metadata


def test_indexed_scope_preserves_missing_and_explicit_null_semantics(tmp_path, monkeypatch) -> None:
    monkeypatch.setattr("nanobot.webui.workspaces.get_webui_dir", lambda: tmp_path / "webui")
    default = tmp_path / "default"
    default.mkdir()
    write_webui_default_access_mode("full")
    controller = WebUIWorkspaceController(
        session_manager=None,
        default_workspace=default,
        default_restrict_to_workspace=True,
    )
    webui_default = controller.default_scope()

    missing = controller.scope_for_indexed_metadata(
        None,
        scope_present=False,
        default_scope=webui_default,
    )
    explicit_null = controller.scope_for_indexed_metadata(
        None,
        scope_present=True,
        default_scope=webui_default,
    )

    assert missing.access_mode == "full"
    assert explicit_null.access_mode == "restricted"


async def test_webui_default_access_does_not_override_explicit_session_scope(tmp_path, monkeypatch) -> None:
    monkeypatch.setattr("nanobot.webui.workspaces.get_webui_dir", lambda: tmp_path / "webui")
    default = tmp_path / "default"
    project = tmp_path / "project"
    default.mkdir()
    project.mkdir()
    sessions = SessionManager(tmp_path / "sessions")
    controller = WebUIWorkspaceController(
        session_manager=sessions,
        default_workspace=default,
        default_restrict_to_workspace=True,
    )
    explicit = default_workspace_scope(project, restrict_to_workspace=False)
    await controller.persist_scope("explicit-chat", explicit)

    scope = controller.scope_for_session_key("websocket:explicit-chat")

    assert scope.project_path == project.resolve()
    assert scope.access_mode == "full"


async def test_scope_for_session_key_reads_metadata_without_full_history(
    tmp_path,
    monkeypatch,
) -> None:
    monkeypatch.setattr("nanobot.webui.workspaces.get_webui_dir", lambda: tmp_path / "webui")
    default = tmp_path / "default"
    project = tmp_path / "project"
    default.mkdir()
    project.mkdir()
    sessions = SessionManager(tmp_path / "sessions")
    controller = WebUIWorkspaceController(
        session_manager=sessions,
        default_workspace=default,
        default_restrict_to_workspace=True,
    )
    explicit = default_workspace_scope(project, restrict_to_workspace=False)
    await controller.persist_scope("metadata-only", explicit)

    def fail_full_read(_key: str) -> None:
        raise AssertionError("scope lookup should not read full session history")

    monkeypatch.setattr(sessions, "read_session_file", fail_full_read)

    scope = controller.scope_for_session_key("websocket:metadata-only")

    assert scope.project_path == project.resolve()
    assert scope.access_mode == "full"


async def test_new_chat_scope_is_persisted_only_after_first_message(tmp_path, monkeypatch) -> None:
    monkeypatch.setattr("nanobot.webui.workspaces.get_webui_dir", lambda: tmp_path / "webui")
    default = tmp_path / "default"
    project = tmp_path / "project"
    default.mkdir()
    project.mkdir()
    sessions = SessionManager(tmp_path / "sessions")
    controller = WebUIWorkspaceController(
        session_manager=sessions,
        default_workspace=default,
        default_restrict_to_workspace=True,
    )
    scope = default_workspace_scope(project, restrict_to_workspace=False)

    await controller.stage_scope("draft-chat", default_workspace_scope(default, True))
    await controller.stage_scope("draft-chat", scope)

    assert sessions.list_sessions() == []
    assert controller.scope_for_session_key("websocket:draft-chat") == scope

    await controller.persist_scope("draft-chat", scope)

    assert [item["key"] for item in sessions.list_sessions()] == ["websocket:draft-chat"]
    with pytest.raises(WorkspaceScopeError, match="project_locked"):
        await controller.stage_scope("draft-chat", default_workspace_scope(default, True))
    await controller.stage_scope("draft-chat", default_workspace_scope(project, True))
    assert controller.scope_for_session_key("websocket:draft-chat").access_mode == "restricted"


async def test_missing_bound_project_does_not_allow_rebinding_to_default(tmp_path, monkeypatch) -> None:
    monkeypatch.setattr("nanobot.webui.workspaces.get_webui_dir", lambda: tmp_path / "webui")
    project = tmp_path / "project"
    project.mkdir()
    sessions = SessionManager(tmp_path / "sessions")
    controller = WebUIWorkspaceController(
        session_manager=sessions, default_workspace=tmp_path, default_restrict_to_workspace=True,
    )
    await controller.persist_scope("missing-project", default_workspace_scope(project, True))
    project.rmdir()

    with pytest.raises(WorkspaceScopeError, match="project_locked"):
        await controller.persist_scope("missing-project", default_workspace_scope(tmp_path, True))
    saved = sessions.read_session_metadata("websocket:missing-project")
    assert saved["metadata"][WORKSPACE_SCOPE_METADATA_KEY]["project_path"] == str(project)


def test_scope_for_session_key_always_reads_the_active_store(tmp_path, monkeypatch) -> None:
    monkeypatch.setattr("nanobot.webui.workspaces.get_webui_dir", lambda: tmp_path / "webui")
    default = tmp_path / "default"
    project = tmp_path / "project"
    default.mkdir()
    project.mkdir()
    workspace = tmp_path / "session-data"
    full_scope = default_workspace_scope(project, restrict_to_workspace=False)
    restricted_scope = default_workspace_scope(project, restrict_to_workspace=True)

    residual_sessions = SessionManager(workspace)
    residual = residual_sessions.get_or_create("websocket:cached")
    residual.metadata[WORKSPACE_SCOPE_METADATA_KEY] = full_scope.metadata()
    residual_sessions.save(residual)

    store = MagicMock(spec=SqliteSessionStore)
    store.read_metadata.side_effect = [
        {
            "key": "websocket:cached",
            "created_at": None,
            "updated_at": None,
            "metadata": {WORKSPACE_SCOPE_METADATA_KEY: full_scope.metadata()},
        },
        {
            "key": "websocket:cached",
            "created_at": None,
            "updated_at": None,
            "metadata": {WORKSPACE_SCOPE_METADATA_KEY: restricted_scope.metadata()},
        },
    ]
    sessions = SessionManager(workspace)
    monkeypatch.setattr(sessions._store, "read_metadata", store.read_metadata)
    controller = WebUIWorkspaceController(
        session_manager=sessions,
        default_workspace=default,
        default_restrict_to_workspace=True,
    )

    first = controller.scope_for_session_key("websocket:cached")
    second = controller.scope_for_session_key("websocket:cached")

    assert first.project_path == project.resolve()
    assert first.access_mode == "full"
    assert second.project_path == project.resolve()
    assert second.access_mode == "restricted"
    assert store.read_metadata.call_count == 2


async def test_remote_existing_chat_can_reduce_its_workspace_access(tmp_path, monkeypatch) -> None:
    monkeypatch.setattr("nanobot.webui.workspaces.get_webui_dir", lambda: tmp_path / "webui")
    default = tmp_path / "default"
    project = tmp_path / "project"
    default.mkdir()
    project.mkdir()
    sessions = SessionManager(tmp_path / "sessions")
    controller = WebUIWorkspaceController(
        session_manager=sessions,
        default_workspace=default,
        default_restrict_to_workspace=True,
    )
    await controller.persist_scope(
        "remote-chat",
        default_workspace_scope(project, restrict_to_workspace=False),
    )

    scope = await controller.scope_for_set_request(
        {
            "workspace_scope": {
                "project_path": str(project),
                "access_mode": "restricted",
            }
        },
        chat_id="remote-chat",
        chat_running=False,
        can_change_project=True,
    )

    assert scope.project_path == project.resolve()
    assert scope.access_mode == "restricted"


@pytest.mark.parametrize(
    ("default_restricted", "project_name", "access_mode"),
    [
        (False, "default", "restricted"),
        (True, "default", "full"),
        (False, "other", "restricted"),
        (False, "other", "full"),
    ],
)
async def test_new_chat_allows_project_selection_in_either_access_mode(
    tmp_path,
    monkeypatch,
    default_restricted: bool,
    project_name: str,
    access_mode: str,
) -> None:
    monkeypatch.setattr("nanobot.webui.workspaces.get_webui_dir", lambda: tmp_path / "webui")
    default = tmp_path / "default"
    other = tmp_path / "other"
    default.mkdir()
    other.mkdir()
    controller = WebUIWorkspaceController(
        session_manager=None,
        default_workspace=default,
        default_restrict_to_workspace=default_restricted,
    )
    requested_path = tmp_path / project_name

    scope = await controller.scope_for_new_chat(
        {
            "workspace_scope": {
                "project_path": str(requested_path),
                "access_mode": access_mode,
            }
        },
        can_change_project=True,
    )
    assert scope.project_path == requested_path.resolve()
    assert scope.access_mode == access_mode


async def test_project_selection_can_remain_disabled_for_untrusted_connections(
    tmp_path,
    monkeypatch,
) -> None:
    monkeypatch.setattr("nanobot.webui.workspaces.get_webui_dir", lambda: tmp_path / "webui")
    default = tmp_path / "default"
    other = tmp_path / "other"
    default.mkdir()
    other.mkdir()
    controller = WebUIWorkspaceController(
        session_manager=None,
        default_workspace=default,
        default_restrict_to_workspace=True,
    )

    with pytest.raises(
        WorkspaceScopeError,
        match="project selection is unavailable for this connection",
    ):
        await controller.scope_for_new_chat(
            {
                "workspace_scope": {
                    "project_path": str(other),
                    "access_mode": "restricted",
                }
            },
            can_change_project=False,
        )


async def test_recent_projects_survive_controller_restart_without_changing_access(tmp_path, monkeypatch) -> None:
    monkeypatch.setattr("nanobot.webui.workspaces.get_webui_dir", lambda: tmp_path / "webui")
    default = tmp_path / "default"
    project = tmp_path / "project"
    default.mkdir()
    project.mkdir()
    controller = WebUIWorkspaceController(
        session_manager=None, default_workspace=default, default_restrict_to_workspace=True,
    )
    scope = await controller.scope_for_new_chat(
        {WORKSPACE_SCOPE_METADATA_KEY: {"project_path": str(project), "access_mode": "restricted"}},
        can_change_project=True,
    )
    await controller.stage_scope("first", scope)
    await controller.stage_scope("second", scope)
    restarted = WebUIWorkspaceController(
        session_manager=None, default_workspace=default, default_restrict_to_workspace=True,
    )
    payload = restarted.payload(can_change_project=True)
    assert payload["recent_projects"] == [{"name": "project", "path": str(project)}]
    assert payload["default_scope"]["project_path"] == str(default)
    assert payload["default_scope"]["access_mode"] == "restricted"
    assert payload["controls"]["can_change_project"] is True


def test_favorites_keep_pin_order_across_restart_and_can_remove_deleted_folder(tmp_path, monkeypatch) -> None:
    monkeypatch.setattr("nanobot.webui.workspaces.get_webui_dir", lambda: tmp_path / "webui")
    default, alpha, beta = (tmp_path / name for name in ("default", "alpha", "beta"))
    for folder in (default, alpha, beta):
        folder.mkdir()
    controller = WebUIWorkspaceController(
        session_manager=None, default_workspace=default, default_restrict_to_workspace=True,
    )
    controller.set_favorite_project(str(beta), True)
    controller.set_favorite_project(str(alpha), True)
    controller.set_favorite_project(str(beta), True)
    controller.resolve_project(str(alpha))
    restarted = WebUIWorkspaceController(
        session_manager=None, default_workspace=default, default_restrict_to_workspace=True,
    )
    payload = restarted.payload(can_change_project=True)
    assert [item["path"] for item in payload["favorite_projects"]] == [str(beta), str(alpha)]
    assert [item["path"] for item in payload["recent_projects"]] == [str(alpha)]
    assert payload["default_scope"]["project_path"] == str(default)
    assert payload["default_scope"]["access_mode"] == "restricted"
    beta.rmdir()
    assert restarted.set_favorite_project(str(beta), False) == [{"name": "alpha", "path": str(alpha)}]
    with pytest.raises(WorkspaceScopeError, match="existing directory"):
        restarted.set_favorite_project(str(beta), True)