0xallam
6e5d96af34
Phase 2.1 — sandbox dispatch helper:
- strix/tools/_sandbox_dispatch.py: post_to_sandbox() centralizes the
host->container HTTP wire format. Connect=10s, read=150s timeouts mirror
legacy executor.py. 50 MB response cap (C18) prevents OOM from a runaway
tool. All errors surface as {"error": str} so the model can recover
instead of the run dying.
Phase 2.2 — C6 lock-protected JSONL writes:
- strix/tools/notes/notes_actions.py: notes.jsonl appends are now wrapped
in _notes_lock so concurrent agents can't interleave half-written lines.
Regression test in test_notes_jsonl_concurrency.py verifies 1000 parallel
writes produce exactly 1000 valid JSON lines.
Phase 2.3 — thin-slice SDK wrappers (think + todo + notes):
- strix/tools/_legacy_adapter.py: LegacyAgentStateAdapter shim — exposes
just enough surface (.agent_id) for legacy tools that close over
agent_state, sourced from ctx.context['agent_id'].
- strix/tools/thinking/thinking_sdk_tools.py: 1 tool (think).
- strix/tools/todo/todo_sdk_tools.py: 6 tools (create/list/update/done/
pending/delete) with bulk-form preserved.
- strix/tools/notes/notes_sdk_tools.py: 5 tools (create/list/get/update/
delete) with asyncio.to_thread around the lock-protected file I/O.
Tests: 22 new tests pass (10 sandbox dispatch + 2 concurrency + 10 SDK
local). Full suite still green.
Per-file ruff ignores added for SDK wrapper files: TC002 (RunContextWrapper
must be runtime-importable because the SDK calls get_type_hints() to
derive the JSON schema) and PLR0911 (sandbox dispatch's 10 short-circuit
returns are intentional, each a distinct documented failure mode).
Refs: PLAYBOOK.md §3.4, AUDIT_R3.md C6/C18.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
80 lines
2.6 KiB
Python
80 lines
2.6 KiB
Python
"""C6 regression test — concurrent notes JSONL writes must produce valid JSONL.
|
|
|
|
This test would fail before the C6 fix (AUDIT_R2 §1.1, applied in Phase 2.2):
|
|
the legacy ``_append_note_event`` opened the file and called ``f.write``
|
|
without holding ``_notes_lock``, so two threads writing simultaneously
|
|
could interleave bytes mid-line and corrupt the JSONL.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import threading
|
|
from collections.abc import Iterator
|
|
from pathlib import Path
|
|
from typing import Any
|
|
from unittest.mock import patch
|
|
|
|
import pytest
|
|
|
|
from strix.tools.notes.notes_actions import _append_note_event
|
|
|
|
|
|
@pytest.fixture
|
|
def notes_path(tmp_path: Path) -> Iterator[Path]:
|
|
"""Point ``_get_notes_jsonl_path`` at a tmp file for the test."""
|
|
target = tmp_path / "notes" / "notes.jsonl"
|
|
target.parent.mkdir(parents=True, exist_ok=True)
|
|
|
|
with patch(
|
|
"strix.tools.notes.notes_actions._get_notes_jsonl_path",
|
|
return_value=target,
|
|
):
|
|
yield target
|
|
|
|
|
|
def test_concurrent_note_writes_yield_valid_jsonl(notes_path: Path) -> None:
|
|
"""C6 fix: 50 threads x 20 events = 1000 lines, all valid JSON.
|
|
|
|
Without the lock, byte-level interleaving on the file produces
|
|
fragments like ``{"timesta{"timestamp"...`` that fail json.loads.
|
|
"""
|
|
|
|
def writer(thread_idx: int) -> None:
|
|
for i in range(20):
|
|
note: dict[str, Any] = {
|
|
"title": f"thread-{thread_idx}-note-{i}",
|
|
"content": "x" * 200, # non-trivial body to widen the race
|
|
"category": "general",
|
|
}
|
|
_append_note_event(
|
|
op="create",
|
|
note_id=f"t{thread_idx}-i{i}",
|
|
note=note,
|
|
)
|
|
|
|
threads = [threading.Thread(target=writer, args=(t,)) for t in range(50)]
|
|
for t in threads:
|
|
t.start()
|
|
for t in threads:
|
|
t.join()
|
|
|
|
lines = notes_path.read_text(encoding="utf-8").splitlines()
|
|
assert len(lines) == 1000, f"expected 1000 lines, got {len(lines)}"
|
|
for line in lines:
|
|
# raises if the line is malformed JSON
|
|
event = json.loads(line)
|
|
assert event["op"] == "create"
|
|
assert "note_id" in event
|
|
|
|
|
|
def test_single_writer_still_works(notes_path: Path) -> None:
|
|
"""Sanity: serial writes still produce a valid JSONL log."""
|
|
_append_note_event("create", "n1", {"title": "first"})
|
|
_append_note_event("update", "n1", {"title": "first updated"})
|
|
_append_note_event("delete", "n1")
|
|
|
|
events = [json.loads(line) for line in notes_path.read_text().splitlines()]
|
|
assert [e["op"] for e in events] == ["create", "update", "delete"]
|
|
assert all(e["note_id"] == "n1" for e in events)
|