Skip to content

Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.

26.1 KB
Raw Blame
# SPDX-License-Identifier: AGPL-3.0-only
# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0

"""A project can run its tools in an existing folder of the user's (#10873, #9321).

The folder is only ever pointed at: the managed workspace stays where it was, a project delete
removes that and nothing else, and a folder that moved or was replaced is never followed.
"""

import asyncio
import os
import base64
import hashlib
import hmac
import json
import platform
import shutil
import sqlite3
import stat
import uuid
import time
from pathlib import Path
from types import SimpleNamespace

import pytest
from fastapi import HTTPException

from storage import studio_db


@pytest.fixture
def projects_home(tmp_path):
    """macOS tmp_path is under /private, which the project-delete guard refuses."""
    candidate = tmp_path / "Projects"
    resolved = str(candidate.resolve())
    check = os.path.normcase(resolved) if platform.system() == "Windows" else resolved
    if any(check == p or check.startswith(p + os.sep) for p in studio_db._denied_path_prefixes()):
        candidate = Path.home() / ".unsloth-studio-tests" / uuid.uuid4().hex
    candidate.mkdir(parents = True, exist_ok = True)
    try:
        yield candidate
    finally:
        if ".unsloth-studio-tests" in candidate.parts:
            shutil.rmtree(candidate, ignore_errors = True)


@pytest.fixture
def repo_parent(tmp_path):
    """macOS tmp_path is under /private, which Link folder refuses as a system directory."""
    from hub.storage.scan_folders import is_denied_system_path

    if not is_denied_system_path(os.path.realpath(tmp_path)):
        yield tmp_path
        return
    candidate = Path.home() / ".unsloth-studio-tests" / uuid.uuid4().hex
    candidate.mkdir(parents = True)
    try:
        yield candidate
    finally:
        shutil.rmtree(candidate, ignore_errors = True)


@pytest.fixture
def env(tmp_path, monkeypatch, projects_home, repo_parent):
    from core.inference import tools

    monkeypatch.setenv("UNSLOTH_STUDIO_HOME", str(tmp_path / "studio"))
    monkeypatch.setenv("UNSLOTH_STUDIO_PROJECTS_HOME", str(projects_home))
    monkeypatch.delenv("UNSLOTH_STUDIO_SANDBOX_HOME", raising = False)
    monkeypatch.setattr(studio_db, "_schema_ready", set())
    monkeypatch.setattr(tools, "_workdirs", {})
    monkeypatch.setattr(tools, "_legacy_sandbox_migrated", True)
    repo = repo_parent / "repo"
    repo.mkdir()
    (repo / "main.py").write_text("print('hi')\n")
    os.chmod(repo, 0o755)
    project = studio_db.upsert_chat_project(
        {"id": "p1", "name": "Repo", "createdAt": 1, "updatedAt": 1}
    )
    return SimpleNamespace(tools = tools, repo = repo, project = project)


def _identity(path):
    st = os.stat(path)
    return (st.st_dev, st.st_ino)


def test_create_with_working_folder_saves_identity_and_survives_reload(env):
    project = {"id": "p2", "name": "Existing repo", "createdAt": 1, "updatedAt": 1}
    saved = studio_db.upsert_chat_project(
        project, working_folder = (str(env.repo), _identity(env.repo))
    )
    assert saved["workingFolder"] == str(env.repo)
    assert studio_db.available_project_working_folder(studio_db.get_chat_project("p2")) == str(
        env.repo
    )
    assert env.tools._get_workdir("project-p2") == str(env.repo)
    assert (env.repo / "main.py").read_text() == "print('hi')\n"
    studio_db.delete_chat_project("p2")
    assert (env.repo / "main.py").is_file()


def test_create_cannot_change_an_existing_projects_folder(env):
    with pytest.raises(studio_db.ProjectWorkingFolderConflictError):
        studio_db.upsert_chat_project(
            {**env.project, "name": "Unexpected rename"},
            working_folder = (str(env.repo), _identity(env.repo)),
        )
    saved = studio_db.get_chat_project("p1")
    assert saved["workingFolder"] is None
    assert saved["name"] == "Repo"


def test_failed_folder_save_rolls_back_project_creation(env):
    conn = studio_db.get_connection()
    try:
        conn.execute("""CREATE TRIGGER reject_workspace BEFORE UPDATE OF working_folder
            ON chat_projects BEGIN SELECT RAISE(ABORT, 'workspace unavailable'); END""")
        conn.commit()
    finally:
        conn.close()
    with pytest.raises(sqlite3.IntegrityError, match = "workspace unavailable"):
        studio_db.upsert_chat_project(
            {"id": "p2", "name": "Repo", "createdAt": 1, "updatedAt": 1},
            working_folder = (str(env.repo), _identity(env.repo)),
        )
    assert studio_db.get_chat_project("p2") is None


def test_create_route_requires_a_verified_lease(env, monkeypatch):
    from routes import chat_history
    from utils import native_path_leases

    seen = []

    def verify(lease, **checks):
        seen.append((lease, checks))
        return _grant(env.repo)

    monkeypatch.setattr(native_path_leases, "verify_native_path_lease", verify)
    body = chat_history.ChatProjectCreate(
        id = "p2", name = "Repo", createdAt = 1, updatedAt = 1, nativePathLease = "picked-folder"
    )
    saved = chat_history.save_project(body, current_subject = "u")
    assert saved.workingFolder == str(env.repo)
    assert seen[0][0] == "picked-folder"
    assert seen[0][1]["expected_path_type"] == "directory"
    assert seen[0][1]["operation"] == "link-documents"


def test_create_route_rejects_invalid_folder_before_creating_project(env, monkeypatch):
    from routes import chat_history

    def refuse(lease):
        raise HTTPException(status_code = 400, detail = "Folder selection expired")

    monkeypatch.setattr(chat_history, "_resolve_project_working_folder", refuse)
    body = chat_history.ChatProjectCreate(
        id = "p2", name = "Repo", createdAt = 1, updatedAt = 1, nativePathLease = "expired"
    )
    with pytest.raises(HTTPException) as caught:
        chat_history.save_project(body, current_subject = "u")
    assert caught.value.status_code == 400
    assert studio_db.get_chat_project("p2") is None


def test_create_failure_after_spending_the_grant_is_an_http_error(env, monkeypatch):
    from routes import chat_history

    monkeypatch.setattr(
        chat_history,
        "_resolve_project_working_folder",
        lambda lease: (str(env.repo), _identity(env.repo)),
    )

    def locked(*args, **kwargs):
        raise sqlite3.OperationalError("database is locked")

    monkeypatch.setattr(chat_history, "upsert_chat_project", locked)
    body = chat_history.ChatProjectCreate(
        id = "p2", name = "Repo", createdAt = 1, updatedAt = 1, nativePathLease = "picked"
    )
    with pytest.raises(HTTPException) as caught:
        chat_history.save_project(body, current_subject = "u")
    assert caught.value.status_code == 500
    plain = chat_history.ChatProjectCreate(id = "p3", name = "Repo", createdAt = 1, updatedAt = 1)
    with pytest.raises(sqlite3.OperationalError):
        chat_history.save_project(plain, current_subject = "u")


def test_resolution_failure_after_spending_the_grant_is_an_http_error(env, monkeypatch):
    from routes import chat_history

    def vanished(lease):
        raise FileNotFoundError("the folder was removed after its grant was verified")

    monkeypatch.setattr(chat_history, "_resolve_project_working_folder", vanished)
    body = chat_history.ChatProjectCreate(
        id = "p2", name = "Repo", createdAt = 1, updatedAt = 1, nativePathLease = "picked"
    )
    with pytest.raises(HTTPException) as caught:
        chat_history.save_project(body, current_subject = "u")
    assert caught.value.status_code == 500
    assert studio_db.get_chat_project("p2") is None


def test_create_with_local_folder_requires_owner(env, monkeypatch):
    from routes import chat_history

    monkeypatch.setattr(chat_history, "is_owner_context", lambda: False)
    body = chat_history.ChatProjectCreate(
        id = "p2", name = "Repo", createdAt = 1, updatedAt = 1, nativePathLease = "picked"
    )
    with pytest.raises(HTTPException) as caught:
        chat_history.save_project(body, current_subject = "managed-account")
    assert caught.value.status_code == 403
    assert studio_db.get_chat_project("p2") is None


def test_http_create_consumes_real_signed_grant_and_tools_write_to_selected_folder(
    env, monkeypatch
):
    from fastapi import FastAPI
    from fastapi.testclient import TestClient
    from routes import chat_history
    from utils import native_path_leases as leases

    secret = b"workspace-test-key-material-32!!!"

    def b64(value):
        return base64.urlsafe_b64encode(value).decode().rstrip("=")

    monkeypatch.setenv(leases.LEASE_SECRET_ENV, b64(secret))
    monkeypatch.setattr(leases, "_CACHED_LEASE_SECRET", None)
    monkeypatch.setattr(leases, "_USED_NONCES", {})
    now = int(time.time() * 1000)
    device, inode = _identity(env.repo)
    payload = {
        "version": 1,
        "operation": "link-documents",
        "canonical_path": str(env.repo),
        "path_kind": "document-folder",
        "path_type": "directory",
        "source_kind": "dialog",
        "token_id_hash": hashlib.sha256(b"test-picker").hexdigest(),
        "issued_at_ms": now,
        "expires_at_ms": now + 120_000,
        "nonce": os.urandom(16).hex(),
        "display_label": "repo",
        "size_bytes": None,
        "modified_ms": None,
        "device_id": format(device, "x"),
        "file_id": format(inode, "x"),
    }
    encoded = b64(json.dumps(payload).encode())
    lease = encoded + "." + b64(hmac.new(secret, encoded.encode(), hashlib.sha256).digest())
    app = FastAPI()
    app.include_router(chat_history.router, prefix = "/api/chat")
    app.dependency_overrides[chat_history.get_current_subject] = lambda: "owner-test"
    body = {"id": "p2", "name": "Repo", "createdAt": 1, "updatedAt": 1, "nativePathLease": lease}
    with TestClient(app) as client:
        response = client.post("/api/chat/projects", json = body)
        assert response.status_code == 200, response.text
        assert response.json()["workingFolder"] == str(env.repo)
        assert "nativePathLease" not in response.json()
        assert client.post("/api/chat/projects", json = {**body, "id": "p3"}).status_code == 400
        assert studio_db.get_chat_project("p3") is None
        assert (
            client.post(
                "/api/chat/projects",
                json = {**body, "id": "p4", "nativePathLease": "forged.signature"},
            ).status_code
            == 400
        )
        assert studio_db.get_chat_project("p4") is None
    result = env.tools._python_exec(
        "from pathlib import Path\nPath('written.txt').write_text('saved')\nprint('done')",
        session_id = "project-p2",
    )
    assert "done" in result, result
    assert (env.repo / "written.txt").read_text() == "saved"
    assert not (Path(response.json()["sandboxPath"]) / "written.txt").exists()


def _use_repo(env):
    return studio_db.set_chat_project_working_folder("p1", str(env.repo), _identity(env.repo))


def test_tools_run_in_the_users_folder_and_back(env):
    managed = env.tools._get_project_workdir("project-p1")
    assert managed == os.path.realpath(env.project["sandboxPath"])
    assert env.tools._get_workdir("project-p1") == managed

    saved = _use_repo(env)
    assert saved["workingFolder"] == str(env.repo)
    assert env.tools._get_project_workdir("project-p1") == os.path.realpath(env.repo)
    assert env.tools._get_workdir("project-p1") == os.path.realpath(env.repo)

    cleared = studio_db.set_chat_project_working_folder("p1", None)
    assert cleared["workingFolder"] is None
    assert env.tools._get_workdir("project-p1") == managed


def test_setting_and_clearing_are_idempotent(env):
    first = _use_repo(env)
    second = _use_repo(env)
    assert first["workingFolder"] == second["workingFolder"] == str(env.repo)
    assert studio_db.set_chat_project_working_folder("p1", None)["workingFolder"] is None
    assert studio_db.set_chat_project_working_folder("p1", None)["workingFolder"] is None
    assert studio_db.set_chat_project_working_folder("missing", None) is None


def test_a_saved_record_cannot_set_or_drop_the_folder(env):
    studio_db.upsert_chat_project({**env.project, "workingFolder": "/etc", "updatedAt": 2})
    assert studio_db.get_chat_project("p1")["workingFolder"] is None
    _use_repo(env)
    studio_db.upsert_chat_project({**env.project, "name": "Renamed", "updatedAt": 3})
    project = studio_db.get_chat_project("p1")
    assert project["name"] == "Renamed"
    assert project["workingFolder"] == str(env.repo)


def test_a_moved_or_replaced_folder_falls_back_to_the_managed_one(env):
    _use_repo(env)
    managed = os.path.realpath(env.project["sandboxPath"])
    moved = env.repo.with_name("repo-moved")
    env.repo.rename(moved)
    assert env.tools._get_project_workdir("project-p1") == managed
    env.repo.mkdir()
    assert env.tools._get_project_workdir("project-p1") == managed
    assert not os.path.exists(env.repo / "main.py")


def test_the_users_folder_keeps_its_mode(env):
    _use_repo(env)
    # Windows reports 0o777 and ignores chmod.
    before = stat.S_IMODE(os.stat(env.repo).st_mode)
    env.tools._get_workdir("project-p1")
    assert stat.S_IMODE(os.stat(env.repo).st_mode) == before


def test_a_folder_cleared_mid_resolve_still_keeps_its_mode(env, monkeypatch):
    # Cleared between the resolve and the chmod.
    before = stat.S_IMODE(os.stat(env.repo).st_mode)
    monkeypatch.setattr(env.tools, "_project_workdir_for", lambda _sid: os.path.realpath(env.repo))
    env.tools._get_workdir("project-p1")
    assert stat.S_IMODE(os.stat(env.repo).st_mode) == before


def test_tools_in_the_users_folder_skip_the_isolation_scan(env, monkeypatch):
    from core.inference import os_sandbox

    # An isolation host whose workdir scan refuses the folder (an external hard link, say).
    def refuse(plan):
        raise os_sandbox.WorkdirUnsafeError(f"the session workdir {plan.workdir} is unsafe")

    monkeypatch.setattr(os_sandbox, "prepare_tool_launch", refuse)
    managed = env.tools.execute_tool("terminal", {"command": "pwd"}, session_id = "project-p1")
    assert "unsafe" in managed
    _use_repo(env)
    out = env.tools.execute_tool("terminal", {"command": "pwd"}, session_id = "project-p1")
    # Git Bash prints the POSIX spelling (/c/Users/...), so match the folder names, not the full path.
    assert f"{env.repo.parent.name}/repo" in out.replace("\\", "/") and "unsafe" not in out
    ran = env.tools.execute_tool(
        "python", {"code": "import os; print(os.getcwd())"}, session_id = "project-p1"
    )
    assert os.path.realpath(env.repo) in ran


def test_a_folder_reached_through_a_new_ancestor_link_is_not_followed(env):
    _use_repo(env)
    parent = env.repo.parent
    moved = parent.with_name(parent.name + "-moved")
    parent.rename(moved)
    try:
        parent.symlink_to(moved, target_is_directory = True)
    except OSError:
        moved.rename(parent)
        pytest.skip("symlinks unavailable")
    try:
        workdir = env.tools._get_project_workdir("project-p1")
        assert workdir == os.path.realpath(env.project["sandboxPath"])
        assert workdir != os.path.realpath(env.repo)
    finally:
        parent.unlink()
        moved.rename(parent)


def test_attachment_copies_are_git_ignored_in_the_users_folder(env, monkeypatch):
    from core import chat_originals

    originals = env.repo.parent / "originals"
    originals.mkdir()
    (originals / ("a" * 64)).write_bytes(b"data")
    monkeypatch.setattr(chat_originals, "originals_dir", lambda: originals)
    _use_repo(env)
    env.tools.materialize_sandbox_attachments("project-p1", [("a" * 64, "notes.txt")])
    copies = env.repo / env.tools._ATTACHMENTS_DIR
    assert (copies / ".gitignore").read_text() == "*\n"
    # Idempotent, and never over a file of the user's.
    (copies / ".gitignore").write_text("mine\n")
    env.tools.materialize_sandbox_attachments("project-p1", [("a" * 64, "notes.txt")])
    assert (copies / ".gitignore").read_text() == "mine\n"


def test_windows_cmd_isolated_keeps_cmd_in_auto_for_the_users_folder(env, monkeypatch):
    from core.inference import os_sandbox

    seen = []

    def stop(plan, **kw):
        seen.append((plan.argv[0], plan.requested_mode, kw.get("user_folder")))
        raise os_sandbox.SandboxUnavailableError("stop here")

    monkeypatch.setattr(env.tools, "_terminal_profile", lambda keep_host = False: "cmd_isolated")
    monkeypatch.setattr(env.tools, "_windows_system_cmd", lambda: "cmd.exe", raising = False)
    monkeypatch.setattr(env.tools, "_prepare_tool_launch", stop)
    env.tools.execute_tool("terminal", {"command": "dir"}, session_id = "project-p1")
    _use_repo(env)
    env.tools.execute_tool("terminal", {"command": "dir"}, session_id = "project-p1")
    # Managed: isolated cmd forces Required. Chosen folder: the same cmd.exe in Auto, run with software safeguards.
    assert seen == [("cmd.exe", "required", False), ("cmd.exe", "auto", True)]


def test_cmd_isolated_stays_required_when_the_call_resolves_to_the_managed_folder(env, monkeypatch):
    from core.inference import os_sandbox

    seen = []

    def stop(plan, **kw):
        seen.append((plan.requested_mode, kw.get("user_folder")))
        raise os_sandbox.SandboxUnavailableError("stop here")

    _use_repo(env)
    managed = os.path.realpath(env.project["sandboxPath"])
    # The folder was cleared or went away by the time this call resolved its workdir.
    monkeypatch.setattr(env.tools, "_get_workdir", lambda _sid: managed)
    monkeypatch.setattr(env.tools, "_terminal_profile", lambda keep_host = False: "cmd_isolated")
    monkeypatch.setattr(env.tools, "_windows_system_cmd", lambda: "cmd.exe", raising = False)
    monkeypatch.setattr(env.tools, "_prepare_tool_launch", stop)
    env.tools.execute_tool("terminal", {"command": "dir"}, session_id = "project-p1")
    assert seen == [("required", False)]


def test_a_linked_attachment_directory_is_never_written_through(env, monkeypatch, tmp_path):
    from core import chat_originals

    outside = tmp_path / "outside"
    outside.mkdir()
    try:
        (env.repo / env.tools._ATTACHMENTS_DIR).symlink_to(outside, target_is_directory = True)
    except OSError:
        pytest.skip("symlinks unavailable")
    originals = env.repo.parent / "originals"
    originals.mkdir()
    (originals / ("a" * 64)).write_bytes(b"data")
    monkeypatch.setattr(chat_originals, "originals_dir", lambda: originals)
    _use_repo(env)
    env.tools.materialize_sandbox_attachments("project-p1", [("a" * 64, "notes.txt")])
    assert list(outside.iterdir()) == []


def test_project_delete_never_touches_the_users_folder(env):
    _use_repo(env)
    project = studio_db.get_chat_project("p1")
    studio_db.delete_project_workspace(project)
    assert not os.path.exists(project["rootPath"])
    assert (env.repo / "main.py").read_text() == "print('hi')\n"


def test_other_accounts_never_get_a_host_folder(env, monkeypatch):
    _use_repo(env)
    monkeypatch.setattr(env.tools, "is_owner_context", lambda: False)
    assert env.tools._get_project_workdir("project-p1") is None


def test_agents_md_is_read_from_the_users_folder(env, monkeypatch):
    from core import agents_md

    monkeypatch.setattr(agents_md, "agents_md_enabled", lambda: True)
    (env.repo / "AGENTS.md").write_text("Use tabs.\n")
    assert "Use tabs." not in agents_md.agents_md_text(studio_db.get_chat_project("p1"))
    _use_repo(env)
    assert "Use tabs." in agents_md.agents_md_text(studio_db.get_chat_project("p1"))


def test_the_prompt_names_the_users_folder_exactly_when_the_tools_run_there(env, monkeypatch):
    """The nudge says the cwd is the user's project, where a model otherwise answered "What
    project/files?"; it must not say so for the managed folder, a replaced folder, another
    account or a plain chat."""
    runs_there = env.tools.session_runs_in_user_folder
    assert not runs_there("project-p1")
    assert not runs_there("thread-1")
    assert not runs_there(None)

    _use_repo(env)
    assert runs_there("project-p1")
    assert env.tools._get_workdir("project-p1") == os.path.realpath(env.repo)

    with monkeypatch.context() as patch:
        patch.setattr(env.tools, "is_owner_context", lambda: False)
        assert not runs_there("project-p1")

    env.repo.rename(env.repo.with_name("repo-moved"))
    env.repo.mkdir()
    assert not runs_there("project-p1")


def test_the_route_reads_the_folder_from_the_requests_session(env):
    from models.inference import ChatCompletionRequest, ChatCountTokensRequest
    from routes.inference import _tools_run_in_user_folder

    _use_repo(env)
    base = {
        "model": "test-model",
        "messages": [{"role": "user", "content": "What files are in my project?"}],
    }
    code = [t for t in env.tools.ALL_TOOLS if t["function"]["name"] == "terminal"]
    web = [t for t in env.tools.ALL_TOOLS if t["function"]["name"] == "web_search"]
    for request_type in (ChatCompletionRequest, ChatCountTokensRequest):
        project = request_type(**base, session_id = "project-p1")
        assert asyncio.run(_tools_run_in_user_folder(project, code))
        assert not asyncio.run(_tools_run_in_user_folder(request_type(**base), code))
        # Nothing can look in the folder, so the project row is not read at all.
        assert not asyncio.run(_tools_run_in_user_folder(project, web))


def test_add_to_project_lands_where_the_tools_run(env, tmp_path):
    from core.inference import gallery_projects

    image = tmp_path / "gen-1.png"
    image.write_bytes(b"png")
    _use_repo(env)
    added = gallery_projects.copy_into_project(image, "p1", "images")
    assert added["path"] == os.path.join(os.path.realpath(env.repo), "images", "gen-1.png")
    (env.repo / "images" / "gen-2.png").write_bytes(b"mine")
    other = tmp_path / "gen-2.png"
    other.write_bytes(b"generated")
    assert gallery_projects.copy_into_project(other, "p1", "images")["already"] is True
    assert (env.repo / "images" / "gen-2.png").read_bytes() == b"mine"


def test_the_library_does_not_list_the_users_folder(env):
    from core import library

    assert any(s.project_id == "p1" for s in library._sandbox_sessions())
    _use_repo(env)
    assert not any(s.project_id == "p1" for s in library._sandbox_sessions())
    assert not library._sandbox_session_eligible("project-p1")


def _grant(path):
    return SimpleNamespace(canonical_path = path)


def test_route_sets_and_clears_the_folder(env, monkeypatch):
    from routes import chat_history
    from utils import native_path_leases

    monkeypatch.setattr(
        native_path_leases, "verify_native_path_lease", lambda lease, **_: _grant(env.repo)
    )
    body = chat_history.ChatProjectWorkingFolder(nativePathLease = "lease")
    saved = chat_history.set_project_working_folder("p1", body, current_subject = "u")
    assert saved.workingFolder == os.path.realpath(env.repo)
    cleared = chat_history.clear_project_working_folder("p1", current_subject = "u")
    assert cleared.workingFolder is None
    assert (env.repo / "main.py").exists()


def test_route_refuses_studios_own_folders_and_other_accounts(env, monkeypatch, tmp_path):
    from routes import chat_history
    from utils import native_path_leases
    from utils.paths.storage_roots import project_workspaces_root, shared_project_workspaces_root

    body = chat_history.ChatProjectWorkingFolder(nativePathLease = "lease")
    monkeypatch.delenv("UNSLOTH_STUDIO_PROJECTS_HOME")
    monkeypatch.setenv(
        "UNSLOTH_STUDIO_DOCUMENTS_HOME", str(tmp_path.parent / f"{tmp_path.name}-docs")
    )
    other_account = shared_project_workspaces_root() / "Accounts" / ("b" * 32) / "Projects" / "x"
    other_account.mkdir(parents = True)
    project_workspaces_root().mkdir(parents = True, exist_ok = True)
    for reserved in (project_workspaces_root(), other_account, tmp_path):
        monkeypatch.setattr(
            native_path_leases,
            "verify_native_path_lease",
            lambda lease, _p = reserved, **_: _grant(_p),
        )
        with pytest.raises(HTTPException) as exc:
            chat_history.set_project_working_folder("p1", body, current_subject = "u")
        assert exc.value.status_code == 400
    assert studio_db.get_chat_project("p1")["workingFolder"] is None

    monkeypatch.setattr(chat_history, "is_owner_context", lambda: False)
    with pytest.raises(HTTPException) as exc:
        chat_history.set_project_working_folder("p1", body, current_subject = "u")
    assert exc.value.status_code == 403


def test_route_refuses_the_shared_temp_root(env, monkeypatch):
    from routes import chat_history
    from utils import native_path_leases
    from utils.paths import storage_roots

    monkeypatch.setattr(
        native_path_leases,
        "verify_native_path_lease",
        lambda lease, **_: _grant(env.repo),
    )
    monkeypatch.setattr(storage_roots, "shared_tmp_root", lambda: env.repo / "unsloth-studio")
    body = chat_history.ChatProjectWorkingFolder(nativePathLease = "lease")
    with pytest.raises(HTTPException) as exc:
        chat_history.set_project_working_folder("p1", body, current_subject = "u")
    assert exc.value.status_code == 400


@pytest.mark.skipif(
    os.name == "nt" or (hasattr(os, "geteuid") and os.geteuid() == 0),
    reason = "needs a POSIX read-only directory, which root can still write",
)
def test_route_refuses_a_read_only_folder(env, monkeypatch):
    from routes import chat_history
    from utils import native_path_leases

    monkeypatch.setattr(
        native_path_leases,
        "verify_native_path_lease",
        lambda lease, **_: _grant(env.repo),
    )
    os.chmod(env.repo, 0o555)
    try:
        body = chat_history.ChatProjectWorkingFolder(nativePathLease = "lease")
        with pytest.raises(HTTPException) as exc:
            chat_history.set_project_working_folder("p1", body, current_subject = "u")
        assert exc.value.status_code == 400
        assert "not writable" in exc.value.detail
    finally:
        os.chmod(env.repo, 0o755)


def test_route_refuses_a_bad_grant(env, monkeypatch):
    from routes import chat_history
    from utils import native_path_leases

    def refuse(lease, **_):
        raise native_path_leases.NativePathLeaseError("Native path grant was already used.")

    monkeypatch.setattr(native_path_leases, "verify_native_path_lease", refuse)
    body = chat_history.ChatProjectWorkingFolder(nativePathLease = "lease")
    with pytest.raises(HTTPException) as exc:
        chat_history.set_project_working_folder("p1", body, current_subject = "u")
    assert exc.value.status_code == 400