Run the container as a non-root user (item from review: Dockerfile hardening)

The image ran as root with no USER directive - if a scraping dependency
or a malicious response ever led to arbitrary code execution, that code
ran as root inside the container. Also dropped a redundant
`pip install playwright` (already pulled in by requirements.txt).

- Dockerfile: added `useradd -m -u 1000 user` + `USER user`, following
Hugging Face Spaces' own documented convention for custom Docker Spaces
(this app deploys to a HF Space).
- app.py: api_lifespan now launches Chromium with `args=["--no-sandbox"]`.
Chromium's own internal sandbox needs privileges a non-root container
user doesn't have and fails to launch at all without this - the
container itself remains the isolation boundary. Added a test (written
first, confirmed failing, then made to pass) asserting the launch call
carries this flag.

Validated end-to-end rather than by inspection alone, since this is the
one change here with real risk of breaking the live deployment: started
dockerd in this sandbox, built the image, ran it, and confirmed from the
container logs that Chromium starts successfully as the non-root user and
a real /serp/search_bing request drives it all the way to a live page
navigation (it only fails on a TLS interception specific to this sandbox's
network, unrelated to the sandbox/permissions change). 86 tests pass.

Dockerfile

@@ -7,12 +7,19 @@ RUN pip install --no-cache-dir -r requirements.txt
 
 ENV PLAYWRIGHT_BROWSERS_PATH=0
 
-RUN pip install --no-cache-dir playwright && \
-    playwright install-deps chromium && \
+RUN playwright install-deps chromium && \
     playwright install chromium
 
 COPY . .
 
+# Hugging Face Spaces' documented convention for custom Docker Spaces: a
+# non-root user with a fixed UID
+# (https://huggingface.co/docs/hub/spaces-sdks-docker#permissions). Chromium
+# is launched with --no-sandbox (see api_lifespan in app.py) since its own
+# internal sandbox needs privileges this non-root user doesn't have.
+RUN useradd -m -u 1000 user && chown -R user:user /app
+USER user
+
 EXPOSE 7860
 
 CMD ["python", "./app.py"]

app.py

@@ -73,7 +73,12 @@ async def api_lifespan(app: FastAPI):
     global playwright, pw_browser
     try:
         playwright = await async_playwright().start()
-        pw_browser = await playwright.chromium.launch(headless=True)
+        # --no-sandbox: the container runs as a non-root user (see the
+        # Dockerfile), and Chromium's own internal sandbox needs privileges
+        # a non-root container user doesn't have - without this it fails to
+        # launch at all. The container itself is still the isolation
+        # boundary against a compromised renderer.
+        pw_browser = await playwright.chromium.launch(headless=True, args=["--no-sandbox"])
         logging.info("Playwright browser started.")
     except Exception as e:
         logging.warning(f"Playwright unavailable, browser-based endpoints will fail: {e}")

tests/test_app.py

@@ -194,3 +194,47 @@ async def test_ops_keyword_search_flattens_results(client, monkeypatch):
     data = resp.json()
     assert data["error"] is None
     assert {r["title"] for r in data["results"]} == {"OPS a", "OPS b"}
+
+
+# ------------------------------------- api_lifespan -------------------------------------
+
+
+async def test_api_lifespan_launches_chromium_without_a_sandbox(monkeypatch):
+    """The container runs as a non-root user (see the Dockerfile), and
+    Chromium's own internal sandbox needs privileges a non-root container
+    user doesn't have - so it must be launched with --no-sandbox, or it
+    fails to start at all in that environment.
+    """
+    launch_calls = []
+
+    class FakeBrowser:
+        async def close(self):
+            pass
+
+    class FakeChromium:
+        async def launch(self, **kwargs):
+            launch_calls.append(kwargs)
+            return FakeBrowser()
+
+    class FakePlaywright:
+        chromium = FakeChromium()
+
+        async def stop(self):
+            pass
+
+    class FakePlaywrightContextManager:
+        async def start(self):
+            return FakePlaywright()
+
+    # Reset via monkeypatch (not a plain assignment) so its automatic
+    # teardown restores whatever these module globals held before this test,
+    # regardless of what api_lifespan reassigns them to while it runs.
+    monkeypatch.setattr(app_module, "pw_browser", None)
+    monkeypatch.setattr(app_module, "playwright", None)
+    monkeypatch.setattr(app_module, "async_playwright", lambda: FakePlaywrightContextManager())
+
+    async with app_module.api_lifespan(app_module.app):
+        pass
+
+    assert launch_calls[0]["headless"] is True
+    assert "--no-sandbox" in launch_calls[0].get("args", [])