Skip to content

Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)

Python

Add Code sessions powered by Codex (#1695)

Ali Khokhard601599b0af9
diff --git a/e2e/__init__.py b/e2e/__init__.py
new file mode 100644
index 00000000..02fcf9b0
--- /dev/null
+++ b/e2e/__init__.py
@@ -0,0 +1 @@
+"""Browser tests for the local Admin application."""
diff --git a/e2e/code_support.py b/e2e/code_support.py
new file mode 100644
index 00000000..e82eb088
--- /dev/null
+++ b/e2e/code_support.py
@@ -0,0 +1,42 @@
+"""Explicit barriers for Code browser tests, on the application's own loop."""
+
+import asyncio
+from collections.abc import Coroutine
+from unittest.mock import patch
+
+from free_claude_code.application.code_sessions import CodeService
+from free_claude_code.runtime.code_sessions_sqlite import SQLiteCodeStore
+from tests.code_sessions_support import FakeHarness
+
+
+class CodeControl:
+ def __init__(self, directory):
+ self.harness = FakeHarness()
+ self.service = CodeService(
+ SQLiteCodeStore(directory / "code.db", directory / "code.lock"),
+ self.harness,
+ )
+ self.loop: asyncio.AbstractEventLoop | None = None
+
+ def run[T](self, work: Coroutine[object, object, T]) -> T:
+ assert self.loop is not None
+ return asyncio.run_coroutine_threadsafe(work, self.loop).result(timeout=10)
+
+ def connection(self):
+ self.run(self.harness.started.wait())
+ return self.harness.connections[-1]
+
+ async def hold_send(self):
+ self.admission = asyncio.Event()
+ original = self.service._store.admit_run
+
+ async def admit(session, run, item, expected_revision):
+ await self.admission.wait()
+ return await original(session, run, item, expected_revision)
+
+ self.admission_patch = patch.object(self.service._store, "admit_run", admit)
+ self.admission_patch.start()
+
+ async def release_send(self):
+ self.admission.set()
+ self.admission_patch.stop()
diff --git a/e2e/conftest.py b/e2e/conftest.py
index 53a65a1b..340a480f 100644
--- a/e2e/conftest.py
+++ b/e2e/conftest.py
@@ -13,6 +13,7 @@ import pytest
import uvicorn
from playwright.sync_api import Page
+from e2e.code_support import CodeControl
from free_claude_code.api.app import create_app
from free_claude_code.api.ports import ApiServices
from free_claude_code.application.chat import (
@@ -228,11 +229,17 @@ class _ModelListingProvider(BaseProvider):
yield ""
+def code_control(tmp_path):
+ return CodeControl(tmp_path / "code")
+
+
@pytest.fixture
def admin_base_url(
request: pytest.FixtureRequest,
monkeypatch: pytest.MonkeyPatch,
tmp_path: Path,
+ code_control: CodeControl,
) -> Iterator[str]:
"""Serve one fully isolated Admin application on an OS-assigned port."""
@@ -397,6 +404,7 @@ def admin_base_url(
configuration=ConfigurationService(ManagedConfigStore()),
transcriber=None,
chat_service=chat,
+ code_service=code_control.service,
)
app = RuntimeASGIApp(
create_app(
@@ -405,6 +413,7 @@ def admin_base_url(
admin=runtime,
tasks=runtime,
chat=chat,
+ code=code_control.service,
)
),
runtime,
@@ -441,17 +450,21 @@ def admin_base_url(
)
)
+ async def serve() -> None:
+ code_control.loop = asyncio.get_running_loop()
+ await server.serve(sockets=[listener])
+
def run_server() -> None:
if sys.platform == "win32":
# This HTTP-only fixture owns no subprocess transports. A browser
# reset can interrupt Proactor socket cleanup on Python 3.14.0;
# use the selector loop here, leaving Playwright's loop unchanged.
asyncio.run(
- server.serve(sockets=[listener]),
+ serve(),
loop_factory=asyncio.SelectorEventLoop,
)
else:
- server.run(sockets=[listener])
+ asyncio.run(serve())
thread = threading.Thread(
target=run_server,
diff --git a/e2e/test_chat_sessions.py b/e2e/test_chat_sessions.py
index ce010756..65380978 100644
--- a/e2e/test_chat_sessions.py
+++ b/e2e/test_chat_sessions.py
@@ -78,7 +78,7 @@ def test_chat_navigation_create_and_browser_history(
expect(page.locator(".action-bar")).to_be_hidden()
page.get_by_role("button", name="Chats", exact=False).click()
expect(page).to_have_url(f"{admin_base_url}/admin/chat")
- expect(page.locator(".chat-session-card")).to_have_count(1)
+ expect(page.locator(".session-card")).to_have_count(1)
page.go_back()
expect(page.get_by_role("textbox", name="Message", exact=True)).to_be_visible()
page.go_forward()
@@ -163,7 +163,7 @@ def test_model_refresh_updates_chat_bootstrap(
card.get_by_role("button", name="Refresh models", exact=True).click()
expect(card.locator(".provider-check-result")).to_have_text("3 models available")
page.get_by_role("button", name="Chat Sessions").click()
- page.locator(".chat-session-card").click()
+ page.locator(".session-card").click()
expect(page.get_by_role("combobox", name="Selected model")).to_have_value(target)
page.get_by_role("textbox", name="Message", exact=True).fill("still available")
@@ -259,14 +259,14 @@ def test_delayed_older_page_cannot_cross_into_another_chat(
expect(page.get_by_text("B only", exact=True)).to_be_visible()
page.get_by_role("button", name="Chats", exact=False).click()
- page.locator(".chat-session-card", has_text="[delay-older-page] Chat A").click()
+ page.locator(".session-card", has_text="[delay-older-page] Chat A").click()
load_older = page.get_by_role("button", name="Load older messages")
expect(load_older).to_be_visible()
with page.expect_request(lambda request: "/turns?before=" in request.url):
load_older.click()
page.get_by_role("button", name="Chats", exact=False).click()
- page.locator(".chat-session-card", has_text="B only").click()
+ page.locator(".session-card", has_text="B only").click()
expect(page.get_by_text("B only", exact=True)).to_be_visible()
page.wait_for_timeout(1_000)
expect(page.get_by_text("A OLD LEAK", exact=True)).to_have_count(0)
@@ -288,7 +288,7 @@ def test_out_of_order_library_search_keeps_latest_results(
)
assert renamed.ok
page.get_by_role("button", name="Chat Sessions").click()
- expect(page.locator(".chat-session-card")).to_have_count(2)
+ expect(page.locator(".session-card")).to_have_count(2)
search = page.get_by_role("searchbox", name="Search chats")
with page.expect_request(lambda request: "query=race-old" in request.url):
@@ -296,16 +296,10 @@ def test_out_of_order_library_search_keeps_latest_results(
with page.expect_response(lambda response: "query=race-new" in response.url):
search.fill("race-new")
- expect(
- page.locator(".chat-session-card", has_text="race-new result")
- ).to_be_visible()
+ expect(page.locator(".session-card", has_text="race-new result")).to_be_visible()
page.wait_for_timeout(1_000)
- expect(
- page.locator(".chat-session-card", has_text="race-new result")
- ).to_be_visible()
- expect(
- page.locator(".chat-session-card", has_text="race-old result")
- ).to_have_count(0)
+ expect(page.locator(".session-card", has_text="race-new result")).to_be_visible()
+ expect(page.locator(".session-card", has_text="race-old result")).to_have_count(0)
def test_double_load_more_appends_each_session_once(
@@ -320,15 +314,15 @@ def test_double_load_more_appends_each_session_once(
)
assert created.ok
page.get_by_role("button", name="Chat Sessions").click()
- expect(page.locator(".chat-session-card")).to_have_count(25)
+ expect(page.locator(".session-card")).to_have_count(25)
more = page.get_by_role("button", name="Load more")
expect(more).to_be_visible()
more.evaluate("button => { button.click(); button.click(); }")
- expect(page.locator(".chat-session-card")).to_have_count(26, timeout=3_000)
+ expect(page.locator(".session-card")).to_have_count(26, timeout=3_000)
page.wait_for_timeout(750)
- expect(page.locator(".chat-session-card")).to_have_count(26)
+ expect(page.locator(".session-card")).to_have_count(26)
def test_chat_streams_thinking_and_persists_answer(
@@ -340,7 +334,9 @@ def test_chat_streams_thinking_and_persists_answer(
page.get_by_role("textbox", name="Message", exact=True).fill("hello")
page.get_by_role("button", name="Send").click()
expect(page.get_by_text("E2E answer")).to_be_visible()
- expect(page.locator(".chat-thinking summary", has_text="Thinking")).to_be_visible()
+ expect(
+ page.locator(".session-thinking summary", has_text="Thinking")
+ ).to_be_visible()
expect(page.get_by_role("button", name="Regenerate")).to_be_visible()
expect(page.locator("#chatContextMeter")).to_contain_text("Context:")
@@ -405,7 +401,7 @@ def test_fragmented_stream_does_not_rebuild_transcript_per_delta(
page.get_by_role("button", name="Send").click()
expect(page.get_by_role("button", name="Regenerate")).to_be_visible(timeout=10_000)
- expect(page.locator(".assistant-message .chat-markdown").last).to_contain_text(
+ expect(page.locator(".assistant-message .session-markdown").last).to_contain_text(
"abcd" * 20
)
render_count = page.evaluate("window.__chatTranscriptRenderCount")
@@ -445,7 +441,7 @@ def test_provider_failure_appears_only_in_assistant_reply(
expect(page.get_by_role("button", name="Retry")).to_be_visible()
expect(
- page.locator(".assistant-message .chat-generation-status.failed")
+ page.locator(".assistant-message .session-generation-status.failed")
).to_have_text("E2E provider failed")
expect(page.locator("#chatNotice")).to_be_hidden()
expect(page.get_by_text("E2E provider failed", exact=True)).to_have_count(1)
@@ -619,7 +615,7 @@ def test_two_sessions_run_concurrently_across_navigation(
expect(page.get_by_role("button", name="Stop")).to_be_visible()
page.get_by_role("button", name="Chats", exact=False).click()
- expect(page.locator(".chat-session-status", has_text="Thinking…")).to_have_count(2)
+ expect(page.locator(".session-status", has_text="Thinking…")).to_have_count(2)
page.goto(first_url)
expect(page.get_by_text("E2E answer", exact=True)).to_be_visible()
@@ -648,14 +644,14 @@ def test_library_card_tracks_background_operation_and_durable_summary(
message.fill("[slow] live library preview")
message.press("Enter")
- card = other.locator(".chat-session-card", has_text="Library observer")
+ card = other.locator(".session-card", has_text="Library observer")
expect(card).to_be_visible(timeout=3_000)
expect(card.locator("p")).to_have_text("[slow] live library preview")
- expect(card.locator(".chat-session-status")).to_have_text("Thinking…")
+ expect(card.locator(".session-status")).to_have_text("Thinking…")
page.get_by_role("button", name="Stop").click()
expect(page.get_by_role("button", name="Retry")).to_be_visible()
- expect(card.locator(".chat-session-status")).to_have_count(0, timeout=3_000)
+ expect(card.locator(".session-status")).to_have_count(0, timeout=3_000)
expect(card.locator("p")).to_have_text("[slow] live library preview")
expect(card.locator("span").first).to_contain_text("just now")
finally:
@@ -888,7 +884,7 @@ def test_failed_regeneration_replaces_the_reply_without_a_page_notice(
expect(page.get_by_text("E2E answer", exact=True)).to_have_count(0)
expect(page.get_by_text("Partial replacement", exact=True)).to_be_visible()
expect(
- page.locator(".assistant-message .chat-generation-status.failed")
+ page.locator(".assistant-message .session-generation-status.failed")
).to_have_text("E2E provider failed")
expect(page.locator("#chatNotice")).to_be_hidden()
expect(page.get_by_text("E2E provider failed", exact=True)).to_have_count(1)
@@ -1002,7 +998,7 @@ def test_chat_composer_is_one_compact_surface_and_grows_to_six_lines(
) -> None:
page.set_viewport_size({"width": 1_258, "height": 566})
_new_chat(page, admin_base_url)
- composer = page.locator(".chat-composer")
+ composer = page.locator(".session-composer")
message = page.get_by_role("textbox", name="Message", exact=True)
surface = composer.evaluate(
@@ -1063,12 +1059,12 @@ def test_chat_uses_desktop_width_with_one_responsive_gutter(
page.reload()
expect(page.get_by_text("E2E answer")).to_be_visible()
- layout = page.locator(".chat-session-shell").evaluate(
+ layout = page.locator(".session-shell").evaluate(
"""shell => {
const main = document.querySelector(".main").getBoundingClientRect();
const shellBox = shell.getBoundingClientRect();
- const composer = shell.querySelector(".chat-composer").getBoundingClientRect();
- const transcript = shell.querySelector(".chat-transcript").getBoundingClientRect();
+ const composer = shell.querySelector(".session-composer").getBoundingClientRect();
+ const transcript = shell.querySelector(".session-transcript").getBoundingClientRect();
const user = shell.querySelector(".user-message").getBoundingClientRect();
const assistant = shell.querySelector(".assistant-message").getBoundingClientRect();
return {
@@ -1115,7 +1111,7 @@ def test_chat_rename_prompt_and_delete(
page.on("dialog", lambda dialog: dialog.accept())
page.get_by_role("button", name="Delete").click()
expect(page).to_have_url(f"{admin_base_url}/admin/chat")
- expect(page.locator(".chat-session-card")).to_have_count(0)
+ expect(page.locator(".session-card")).to_have_count(0)
def test_delayed_title_save_cannot_restore_chat_after_back_navigation(
diff --git a/e2e/test_code_sessions.py b/e2e/test_code_sessions.py
new file mode 100644
index 00000000..2d3ffb71
--- /dev/null
+++ b/e2e/test_code_sessions.py
@@ -0,0 +1,944 @@
+import re
+import uuid
+
+import pytest
+from playwright.sync_api import expect
+
+from e2e.test_chat_sessions import _new_chat
+from free_claude_code.application.code_sessions.models import (
+ HarnessEvent,
+ PromptRequest,
+)
+
+
+def create_session(page, base_url, directory):
+ page.goto(f"{base_url}/admin/code")
+ page.get_by_role("button", name="New code session", exact=True).click()
+ page.get_by_role("textbox", name="Folder", exact=True).fill(str(directory))
+ expect(page.get_by_role("combobox", name="Harness", exact=True)).to_have_value(
+ "codex"
+ )
+ page.get_by_role("button", name="Create session", exact=True).click()
+ expect(page).to_have_url(re.compile(r"/admin/code/[0-9a-f-]+$"))
+ expect(page.get_by_role("textbox", name="Message", exact=True)).to_be_enabled()
+ return page.url
+
+
+def send(page, text):
+ page.get_by_role("textbox", name="Message", exact=True).fill(text)
+ page.get_by_role("button", name="Send", exact=True).click()
+ expect(page.get_by_role("button", name="Stop", exact=True)).to_be_visible()
+
+
+def test_code_streams_survive_refresh_and_all_viewers_leaving(
+ page, context, admin_base_url, tmp_path, code_control
+):
+ url = create_session(page, admin_base_url, tmp_path)
+ send(page, "Inspect this project")
+ connection = code_control.connection()
+ code_control.run(
+ connection.text(
+ "turn-1", "reason", "Reading the files", complete=True, kind="reasoning"
+ )
+ )
+ code_control.run(
+ connection.text(
+ "turn-1", "command", "directory output", complete=True, kind="tool"
+ )
+ )
+ code_control.run(connection.text("turn-1", "reply", "First finding", complete=True))
+ expect(page.get_by_text("First finding", exact=True)).to_be_visible()
+ page.locator("summary").filter(has_text="Thinking").click()
+ expect(page.get_by_text("Reading the files", exact=True)).to_be_visible()
+ expect(page.get_by_role("button", name="Regenerate", exact=True)).to_have_count(0)
+ expect(page.get_by_role("button", name="Edit message", exact=True)).to_have_count(0)
+ second = context.new_page()
+ try:
+ second.goto(url)
+ expect(second.get_by_text("First finding", exact=True)).to_be_visible()
+ page.goto("about:blank")
+ second.close()
+ code_control.run(
+ connection.text("turn-1", "reply", "Final finding", complete=True)
+ )
+ code_control.run(connection.finish("turn-1"))
+ page.goto(url)
+ expect(page.get_by_text("Final finding", exact=True)).to_be_visible()
+ page.get_by_role("textbox", name="Message", exact=True).fill("Follow up")
+ expect(page.get_by_role("button", name="Send", exact=True)).to_be_enabled()
+ page.reload()
+ expect(page.get_by_text("Final finding", exact=True)).to_be_visible()
+ assert len(connection.inputs) == 1
+ finally:
+ if not second.is_closed():
+ second.close()
+
+
+def test_prompt_claim_syncs_tabs_and_stop_keeps_output(
+ page, context, admin_base_url, tmp_path, code_control
+):
+ url = create_session(page, admin_base_url, tmp_path)
+ send(page, "Run a command")
+ connection = code_control.connection()
+ code_control.run(
+ connection.text("turn-1", "reply", "Output before approval", complete=True)
+ )
+ code_control.run(connection.prompt(0))
+ second = context.new_page()
+ try:
+ second.goto(url)
+ expect(second.get_by_role("button", name="Allow", exact=True)).to_be_enabled()
+ page.get_by_role("button", name="Allow", exact=True).click()
+ expect(second.get_by_role("button", name="Allow", exact=True)).to_be_disabled()
+ page.get_by_role("button", name="Stop", exact=True).click()
+ page.get_by_role("textbox", name="Message", exact=True).fill("Follow up")
+ expect(page.get_by_role("button", name="Send", exact=True)).to_be_enabled()
+ expect(second.get_by_text("Output before approval", exact=True)).to_be_visible()
+ assert len(connection.answers) == 1
+ finally:
+ second.close()
+
+
+def test_old_detail_cannot_replace_streamed_output(
+ page, admin_base_url, tmp_path, code_control
+):
+ url = create_session(page, admin_base_url, tmp_path)
+ send(page, "Keep the latest output")
+ connection = code_control.connection()
+ code_control.run(connection.text("turn-1", "reply", "Old output", complete=True))
+ code_control.run(connection.prompt(0))
+ expect(page.get_by_text("Old output", exact=True)).to_be_visible()
+ page.add_init_script("""(() => {
+ const original = window.fetch;
+ window.fetch = async (...args) => {
+ const result = await original(...args);
+ if (/\\/api\\/code\\/sessions\\/[0-9a-f-]+$/.test(String(args[0]))) {
+ window.detailCaptured = true;
+ await new Promise(resolve => { window.releaseDetail = resolve; });
+ }
+ return result;
+ };
+ })();""")
+ page.goto(url)
+ page.wait_for_function("window.detailCaptured === true")
+ code_control.run(connection.text("turn-1", "reply", "Newest output", complete=True))
+ code_control.run(connection.resolve(0))
+ code_control.run(connection.finish("turn-1"))
+ page.evaluate("window.releaseDetail()")
+ expect(page.get_by_text("Newest output", exact=True)).to_be_visible()
+ expect(page.get_by_text("Old output", exact=True)).to_have_count(0)
+ expect(page.get_by_role("button", name="Send", exact=True)).to_be_visible()
+ expect(page.get_by_role("button", name="Allow", exact=True)).to_be_disabled()
+
+
+def test_competing_tabs_keep_the_rejected_draft(
+ page, context, admin_base_url, tmp_path, code_control
+):
+ url = create_session(page, admin_base_url, tmp_path)
+ second = context.new_page()
+ try:
+ second.goto(url)
+ first_input = page.get_by_role("textbox", name="Message", exact=True)
+ other_input = second.get_by_role("textbox", name="Message", exact=True)
+ first_input.fill("First tab")
+ other_input.fill("Second tab draft")
+ expect(second.get_by_role("button", name="Send", exact=True)).to_be_enabled()
+ code_control.run(code_control.hold_send())
+ page.get_by_role("button", name="Send", exact=True).click()
+ second.get_by_role("button", name="Send", exact=True).click()
+ code_control.run(code_control.release_send())
+ expect(page.get_by_role("button", name="Stop", exact=True)).to_be_visible()
+ expect(second.get_by_role("button", name="Stop", exact=True)).to_be_visible()
+ expect(first_input).to_have_value("")
+ expect(other_input).to_have_value("Second tab draft")
+ second.reload()
+ expect(second.get_by_role("textbox", name="Message", exact=True)).to_have_value(
+ "Second tab draft"
+ )
+ assert (
+ sum(
+ len(connection.inputs)
+ for connection in code_control.harness.connections
+ )
+ == 1
+ )
+ finally:
+ code_control.run(code_control.release_send())
+ second.close()
+
+
+def test_lost_send_response_keeps_later_typing_and_does_not_replay(
+ page, admin_base_url, tmp_path, code_control
+):
+ create_session(page, admin_base_url, tmp_path)
+ page.evaluate("""() => {
+ const original = window.fetch;
+ window.fetch = async (...args) => {
+ const result = await original(...args);
+ if (String(args[0]).endsWith('/turns')) {
+ window.sendCaptured = true;
+ await new Promise((resolve, reject) => { window.loseSend = () => reject(new TypeError('Connection lost')); });
+ }
+ return result;
+ };
+ }""")
+ send(page, "Run once")
+ page.wait_for_function("window.sendCaptured === true")
+ draft = page.get_by_role("textbox", name="Message", exact=True)
+ draft.fill("Keep my next message")
+ page.evaluate("window.loseSend()")
+ connection = code_control.connection()
+ code_control.run(connection.finish("turn-1"))
+ page.reload()
+ expect(page.get_by_role("textbox", name="Message", exact=True)).to_have_value(
+ "Keep my next message"
+ )
+ expect(page.get_by_role("button", name="Send", exact=True)).to_be_enabled()
+ assert len(connection.inputs) == 1
+
+
+def test_rename_and_delete_sync_library_without_touching_project(
+ page, context, admin_base_url, tmp_path, code_control
+):
+ url = create_session(page, admin_base_url, tmp_path)
+ project = tmp_path / "project.txt"
+ project.write_text("unchanged")
+ second = context.new_page()
+ try:
+ second.goto(url)
+ page.get_by_role("textbox", name="Code title", exact=True).fill("My project")
+ page.get_by_role("textbox", name="Code title", exact=True).press("Enter")
+ expect(
+ second.get_by_role("textbox", name="Code title", exact=True)
+ ).to_have_value("My project")
+ page.get_by_role("button", name="Delete", exact=True).click()
+ page.get_by_role("button", name="Delete session", exact=True).click()
+ expect(page).to_have_url(f"{admin_base_url}/admin/code")
+ expect(second).to_have_url(f"{admin_base_url}/admin/code")
+ expect(second.locator(".session-card")).to_have_count(0)
+ assert project.read_text() == "unchanged"
+ finally:
+ second.close()
+
+
+def test_question_input_survives_streaming_and_secret_answer_is_not_stored(
+ page, admin_base_url, tmp_path, code_control
+):
+ control_feed(page)
+ create_session(page, admin_base_url, tmp_path)
+ send(page, "Ask me a question")
+ connection = code_control.connection()
+ prompt = PromptRequest(
+ 7,
+ "questions",
+ {
+ "title": "Codex needs your input",
+ "questions": [
+ {
+ "id": "destination",
+ "label": "Which destination?",
+ "header": "Destination",
+ "options": [
+ {
+ "label": "Default",
+ "description": "Use the current destination",
+ }
+ ],
+ "allow_other": True,
+ "secret": True,
+ }
+ ],
+ },
+ {"question": "destination"},
+ "turn-1",
+ )
+
+ async def ask():
+ connection.requests[7] = prompt
+ await connection.sink(
+ HarnessEvent(
+ connection.generation,
+ connection.thread_id,
+ "prompt",
+ turn_id="turn-1",
+ prompt=prompt,
+ )
+ )
+
+ code_control.run(ask())
+ secret = page.get_by_label("Your answer", exact=True)
+ secret.fill("private-answer")
+ expect(secret).to_have_attribute("type", "password")
+ code_control.run(
+ connection.text("turn-1", "stream", "Still checking", complete=True)
+ )
+ expect(page.get_by_text("Still checking", exact=True)).to_be_visible()
+ expect(secret).to_have_value("private-answer")
+ page.evaluate("window.codeFeed.onerror(new Event('error'))")
+ expect(
+ page.get_by_role("button", name="Submit answers", exact=True)
+ ).to_be_enabled()
+ expect(secret).to_have_value("private-answer")
+ page.get_by_role("button", name="Submit answers", exact=True).click()
+ expect(
+ page.get_by_role("button", name="Submit answers", exact=True)
+ ).to_be_disabled()
+ code_control.run(code_control.harness.answered.wait())
+ assert connection.answers == [(7, {"answers": {"destination": ["private-answer"]}})]
+ assert "private-answer" not in page.evaluate("JSON.stringify(sessionStorage)")
+ detail = code_control.run(
+ code_control.service.get_detail(page.url.rsplit("/", 1)[1])
+ )
+ assert all(
+ "private-answer" not in value.model_dump_json() for value in detail.prompts
+ )
+
+
+def delete_from_other_client(code_control, session_id):
+ async def remove():
+ detail = await code_control.service.get_detail(session_id)
+ await code_control.service.delete_session(session_id, detail.session.revision)
+ await code_control.service.wait_idle(session_id)
+
+ code_control.run(remove())
+
+
+def hold_deleted_detail(page, code_control, session_id):
+ page.evaluate("window.dropCodeEvents = ['session.deleted']")
+ delete_from_other_client(code_control, session_id)
+ endpoint = f"/admin/api/code/sessions/{session_id}"
+ hold_code_reads(page, endpoint)
+ page.evaluate("window.replayCodeReady()")
+ page.wait_for_function(
+ "path => window.codeReadHolds.some(held => held.path === path && held.status === 404)",
+ arg=endpoint,
+ )
+
+
[email protected]("source", ["event", "detail404"])
+def test_hidden_code_removal_preserves_chat_and_deleted_history(
+ page, admin_base_url, tmp_path, code_control, source
+):
+ control_feed(page)
+ url = create_session(page, admin_base_url, tmp_path)
+ session_id = url.rsplit("/", 1)[1]
+ if source == "detail404":
+ hold_deleted_detail(page, code_control, session_id)
+ page.get_by_role("button", name="Chat Sessions", exact=True).click()
+ page.get_by_role("button", name="New chat", exact=True).click()
+ expect(page).to_have_url(re.compile(r"/admin/chat/[0-9a-f-]+$"))
+ chat_url = page.url
+ composer = page.locator("#chatComposer")
+ composer.fill("Keep this Chat draft")
+ composer.evaluate("input => input.setSelectionRange(2, 7)")
+ history_length = page.evaluate("history.length")
+ if source == "event":
+ delete_from_other_client(code_control, session_id)
+ page.wait_for_function("id => window.lastCodeDeleted === id", arg=session_id)
+ else:
+ page.evaluate("window.releaseCodeReads()")
+ expect(page.locator("#codeLibrary")).to_have_count(1)
+ expect(page).to_have_url(chat_url)
+ assert page.evaluate("history.length") == history_length
+ expect(page.locator("#view-chat")).to_be_visible()
+ expect(page.locator('.nav-link[data-view="chat"]')).to_have_attribute(
+ "aria-current", "page"
+ )
+ expect(composer).to_be_focused()
+ expect(composer).to_have_value("Keep this Chat draft")
+ assert composer.evaluate("input => [input.selectionStart, input.selectionEnd]") == [
+ 2,
+ 7,
+ ]
+
+ # The old Code entry remains in history until it is visited and replaced.
+ reads = []
+ endpoint = f"/admin/api/code/sessions/{session_id}"
+ page.on("request", lambda request: reads.append(request.url))
+ page.go_back()
+ expect(page).to_have_url(f"{admin_base_url}/admin/chat")
+ page.go_back()
+ expect(page).to_have_url(f"{admin_base_url}/admin/code")
+ expect(page.locator("#codeNew")).to_be_enabled()
+ expect(page.locator("#codeLibrary .session-card")).to_have_count(0)
+ assert not any(request.endswith(endpoint) for request in reads)
+ assert page.evaluate("history.length") == history_length
+ page.go_forward()
+ expect(page).to_have_url(f"{admin_base_url}/admin/chat")
+ page.go_forward()
+ expect(page).to_have_url(chat_url)
+ expect(composer).to_have_value("Keep this Chat draft")
+ page.reload()
+ expect(page).to_have_url(chat_url)
+ expect(composer).to_have_value("Keep this Chat draft")
+
+
[email protected]("source", ["event", "detail404", "returned_detail404"])
+def test_visible_code_removal_replaces_history(
+ page, admin_base_url, tmp_path, code_control, source
+):
+ control_feed(page)
+ url = create_session(page, admin_base_url, tmp_path)
+ session_id = url.rsplit("/", 1)[1]
+ if source != "event":
+ hold_deleted_detail(page, code_control, session_id)
+ if source == "returned_detail404":
+ page.get_by_role("button", name="Chat Sessions", exact=True).click()
+ page.go_back()
+ expect(page).to_have_url(url)
+ expect(page.locator("#view-code")).to_be_visible()
+ history_length = page.evaluate("history.length")
+ if source == "event":
+ delete_from_other_client(code_control, session_id)
+ page.wait_for_function("id => window.lastCodeDeleted === id", arg=session_id)
+ else:
+ page.evaluate("window.releaseCodeReads()")
+ expect(page).to_have_url(f"{admin_base_url}/admin/code")
+ expect(page.locator("#codeNotice")).to_contain_text("deleted")
+ expect(page.locator("#codeNew")).to_be_enabled()
+ assert page.evaluate("history.length") == history_length
+ if source == "returned_detail404":
+ page.go_forward()
+ expect(page).to_have_url(f"{admin_base_url}/admin/chat")
+ page.go_back()
+ expect(page).to_have_url(f"{admin_base_url}/admin/code")
+ reads = []
+ page.on("request", lambda request: reads.append(request.url))
+ page.go_back()
+ expect(page).to_have_url(f"{admin_base_url}/admin/code")
+ expect(page.locator("#codeNew")).to_be_enabled()
+ assert not any(request.endswith(f"/sessions/{session_id}") for request in reads)
+
+
[email protected]("source", ["event", "detail404"])
+def test_code_removal_does_not_redirect_another_code_session(
+ page, admin_base_url, tmp_path, code_control, source
+):
+ control_feed(page)
+ url = create_session(page, admin_base_url, tmp_path)
+ session_id = url.rsplit("/", 1)[1]
+ other = code_control.run(
+ code_control.service.create_session(str(uuid.uuid4()), str(tmp_path))
+ )
+ if source == "detail404":
+ hold_deleted_detail(page, code_control, session_id)
+ page.get_by_role("button", name="← Code sessions", exact=True).click()
+ page.locator(f'#codeLibrary [data-id="{other.id}"]').click()
+ other_url = f"{admin_base_url}/admin/code/{other.id}"
+ expect(page).to_have_url(other_url)
+ page.locator("#codeComposer").fill("Keep B's draft")
+ history_length = page.evaluate("history.length")
+ if source == "event":
+ delete_from_other_client(code_control, session_id)
+ page.wait_for_function("id => window.lastCodeDeleted === id", arg=session_id)
+ else:
+ page.evaluate("window.releaseCodeReads()")
+ expect(page.locator("#codeSend")).to_be_enabled()
+ expect(page).to_have_url(other_url)
+ expect(page.locator("#codeComposer")).to_have_value("Keep B's draft")
+ assert page.evaluate("history.length") == history_length
+
+
+def control_feed(page):
+ page.add_init_script("""(() => {
+ const Native = window.EventSource;
+ window.EventSource = class extends Native {
+ constructor(...args) {
+ super(...args);
+ this.isCode = String(args[0]).includes('/api/code/events');
+ if (this.isCode) window.codeFeed = this;
+ if (String(args[0]).includes('/api/chat/events')) window.chatFeed = this;
+ }
+ addEventListener(type, listener, ...options) {
+ return super.addEventListener(type, event => {
+ if (this.isCode && window.dropCodeEvents?.includes(type)) return;
+ if (this.isCode && type === 'feed.ready')
+ window.replayCodeReady = () => listener(event);
+ listener(event);
+ if (this.isCode && type === 'run.updated')
+ window.lastCodeRun = JSON.parse(event.data).run;
+ if (this.isCode && type === 'session.deleted')
+ window.lastCodeDeleted = JSON.parse(event.data).session_id;
+ }, ...options);
+ }
+ };
+ })();""")
+
+
+def hold_code_reads(page, endpoint=None):
+ page.evaluate(
+ """endpoint => {
+ const original = window.fetch;
+ window.codeReadHolds = [];
+ window.holdCodeReads = true;
+ window.fetch = async (...args) => {
+ const response = await original(...args);
+ const path = new URL(String(args[0]), location.origin).pathname;
+ if (window.holdCodeReads && path.startsWith('/admin/api/code/') &&
+ (!endpoint || path === endpoint) &&
+ (!args[1]?.method || args[1].method === 'GET'))
+ await new Promise(resolve => window.codeReadHolds.push({path, status: response.status, resolve}));
+ return response;
+ };
+ window.releaseCodeReads = () => {
+ window.holdCodeReads = false;
+ for (const held of window.codeReadHolds.splice(0)) held.resolve();
+ };
+ }""",
+ endpoint,
+ )
+
+
+def send_from_other_client(page, url, text):
+ endpoint = url.replace("/admin/code/", "/admin/api/code/sessions/")
+ detail = page.request.get(endpoint).json()
+ response = page.request.post(
+ f"{endpoint}/turns",
+ data={
+ "operation_id": str(uuid.uuid4()),
+ "expected_revision": detail["session"]["revision"],
+ "expected_epoch": detail["epoch"],
+ "text": text,
+ },
+ )
+ assert response.ok, response.text()
+ return response.json()["id"]
+
+
+def test_hidden_chat_cannot_change_code_control_state(
+ page, admin_base_url, tmp_path, code_control
+):
+ control_feed(page)
+ _new_chat(page, admin_base_url)
+ chat_id = page.url.rsplit("/", 1)[1]
+ expect(page.locator("#chatModel")).to_be_enabled()
+ page.get_by_role("button", name="Code sessions", exact=True).click()
+ page.get_by_role("button", name="New code session", exact=True).click()
+ page.get_by_role("textbox", name="Folder", exact=True).fill(str(tmp_path))
+ page.get_by_role("button", name="Create session", exact=True).click()
+ send(page, "Keep working")
+ connection = code_control.connection()
+ controls = page.locator(
+ "#codeRoot .session-model-control input, "
+ "#codeRoot .session-model-control button, #codeReasoning, #codeDelete"
+ )
+ assert controls.count() == 4
+ for control in controls.all():
+ expect(control).to_be_disabled()
+ endpoint = f"{admin_base_url}/admin/api/chat/sessions/{chat_id}"
+ session = page.request.get(endpoint).json()["session"]
+ response = page.request.patch(
+ endpoint,
+ data={"expected_revision": session["revision"], "title": "Hidden update"},
+ )
+ assert response.ok
+ expect(page.locator("#chatRoot .session-title")).to_have_value("Hidden update")
+ for control in controls.all():
+ expect(control).to_be_disabled()
+ expect(page.locator("#codeRoot .session-title")).to_be_enabled()
+
+ code_control.run(connection.finish("turn-1"))
+ for control in controls.all():
+ expect(control).to_be_enabled()
+ page.evaluate("window.chatFeed.dispatchEvent(new Event('error'))")
+ expect(page.locator("#chatModel")).to_be_disabled()
+ for control in controls.all():
+ expect(control).to_be_enabled()
+ expect(page.locator("#codeRoot .session-title")).to_be_enabled()
+
+
+def test_model_default_clears_effort_when_all_choices_disappear(
+ page, context, admin_base_url, tmp_path, code_control
+):
+ url = create_session(page, admin_base_url, tmp_path)
+ effort = page.locator("#codeReasoning")
+ effort.select_option("high")
+ expect(effort).to_be_enabled()
+ page.locator("#codeComposer").fill("Preserve this draft")
+ code_control.harness.efforts = ()
+ code_control.harness.default_effort = None
+ page.evaluate("window.CodeSessions.refresh()")
+ expect(page.locator("#codeComposerStatus")).to_contain_text("unavailable")
+ expect(effort).to_have_value("high")
+ expect(effort.locator("option:checked")).to_have_text("high (unavailable)")
+ expect(page.locator("#codeSend")).to_be_disabled()
+ expect(effort).to_be_enabled()
+ patches = []
+ page.on(
+ "request",
+ lambda request: (
+ patches.append(request.post_data_json)
+ if request.method == "PATCH" and "/api/code/sessions/" in request.url
+ else None
+ ),
+ )
+ with page.expect_response(
+ lambda response: (
+ response.request.method == "PATCH" and "/api/code/sessions/" in response.url
+ )
+ ) as reset:
+ effort.select_option("")
+ assert reset.value.json()["reasoning_effort"] is None
+ assert len(patches) == 1 and patches[0]["reasoning_effort"] is None
+ expect(effort).to_be_disabled()
+ expect(page.locator("#codeComposerStatus")).not_to_contain_text("unavailable")
+ expect(page.locator("#codeSend")).to_be_enabled()
+ page.reload()
+ expect(effort).to_have_value("")
+ expect(effort).to_be_disabled()
+ expect(page.locator("#codeComposer")).to_have_value("Preserve this draft")
+ second = context.new_page()
+ try:
+ second.goto(url)
+ expect(second.locator("#codeReasoning")).to_have_value("")
+ expect(second.locator("#codeModel")).to_have_value("provider/model")
+ page.locator("#codeSend").click()
+ connection = code_control.connection()
+ assert connection.efforts == [None]
+ assert connection.inputs[0][1:] == ("Preserve this draft", "provider/model")
+ finally:
+ second.close()
+
+
[email protected]("status", ["completed", "failed"])
+def test_library_reconnect_retires_missed_completion_and_loads_real_outcome(
+ page, admin_base_url, tmp_path, code_control, status
+):
+ control_feed(page)
+ create_session(page, admin_base_url, tmp_path)
+ send(page, "Cached task")
+ connection = code_control.connection()
+ code_control.run(
+ connection.text("turn-1", "reply", "Preserved output", complete=True)
+ )
+ expect(page.get_by_text("Preserved output", exact=True)).to_be_visible()
+ page.locator("#codeComposer").fill("Next draft")
+ page.get_by_role("button", name="← Code sessions", exact=True).click()
+ card = page.locator("#codeLibrary .session-card")
+ expect(card).to_contain_text("Running")
+ page.evaluate("window.dropCodeEvents = ['run.updated', 'session.updated']")
+ code_control.run(
+ connection.finish(
+ "turn-1", status, "Actual failure" if status == "failed" else None
+ )
+ )
+ page.evaluate(
+ "window.dropCodeEvents = []; void window.codeFeed.onerror(new Event('error'))"
+ )
+ expect(page.locator("#codeNew")).to_be_enabled()
+ expect(card).not_to_contain_text("Running")
+ hold_code_reads(page)
+ card.click()
+ page.wait_for_function(
+ "window.codeReadHolds.some(held => /\\/sessions\\/[0-9a-f-]+$/.test(held.path))"
+ )
+ expect(page.locator("#codeSend")).to_be_disabled()
+ expect(page.locator("#codeModel")).to_be_disabled()
+ expect(page.get_by_text("Preserved output", exact=True)).to_be_visible()
+ expect(page.locator("#codeComposer")).to_have_value("Next draft")
+ page.evaluate("window.releaseCodeReads()")
+ expect(page.locator("#codeSend")).to_be_enabled()
+ expect(page.locator(".code-run")).to_have_count(1)
+ outcome = page.locator(".code-outcome")
+ if status == "failed":
+ expect(outcome.locator(".session-generation-status")).to_have_text(
+ "Actual failure"
+ )
+ expect(outcome).to_be_visible()
+ else:
+ expect(outcome).to_be_hidden()
+
+
[email protected]("snapshot_active", [False, True])
+def test_new_run_survives_delayed_reconnect_reads(
+ page, admin_base_url, tmp_path, code_control, snapshot_active
+):
+ control_feed(page)
+ url = create_session(page, admin_base_url, tmp_path)
+ send(page, "First run")
+ connection = code_control.connection()
+ page.get_by_role("button", name="← Code sessions", exact=True).click()
+ expect(page.locator("#codeLibrary .session-card")).to_contain_text("Running")
+ if not snapshot_active:
+ page.evaluate("window.dropCodeEvents = ['run.updated', 'session.updated']")
+ code_control.run(connection.finish("turn-1"))
+ hold_code_reads(page)
+ page.evaluate(
+ "window.dropCodeEvents = []; void window.codeFeed.onerror(new Event('error'))"
+ )
+ page.wait_for_function(
+ "window.codeReadHolds.some(held => held.path === '/admin/api/code/sessions')"
+ )
+ if snapshot_active:
+ expect(page.locator("#codeLibrary .session-card")).to_contain_text("Running")
+ code_control.run(connection.finish("turn-1"))
+ run_id = send_from_other_client(page, url, "Newer run")
+ code_control.run(code_control.harness.wait_inputs(2))
+ page.wait_for_function(
+ "id => window.lastCodeRun?.id === id && window.lastCodeRun.status === 'running'",
+ arg=run_id,
+ )
+ expect(page.locator("#codeLibrary .session-card")).to_contain_text("Running")
+ page.evaluate("window.releaseCodeReads()")
+ expect(page.locator("#codeNew")).to_be_enabled()
+ expect(page.locator("#codeLibrary .session-card")).to_contain_text("Running")
+
+
[email protected]("source", ["sse", "detail"])
+def test_stale_ready_snapshot_preserves_newer_activity(
+ page, admin_base_url, tmp_path, code_control, source
+):
+ control_feed(page)
+ url = create_session(page, admin_base_url, tmp_path)
+ send(page, "First run")
+ connection = code_control.connection()
+ code_control.run(connection.finish("turn-1"))
+ expect(page.locator("#codeStop")).to_be_hidden()
+ page.get_by_role("button", name="← Code sessions", exact=True).click()
+ page.evaluate("window.codeFeed.onerror(new Event('error'))")
+ expect(page.locator("#codeNew")).to_be_enabled()
+ if source == "detail":
+ page.evaluate(
+ "window.dropCodeEvents = ['run.updated', 'session.updated', 'item.updated']"
+ )
+ run_id = send_from_other_client(page, url, "Newer run")
+ code_control.run(code_control.harness.wait_inputs(2))
+ if source == "detail":
+ page.locator("#codeLibrary .session-card").click()
+ expect(page.locator("#codeStop")).to_be_visible()
+ expect(page.get_by_text("Newer run", exact=True)).to_be_visible()
+ page.get_by_role("button", name="← Code sessions", exact=True).click()
+ else:
+ page.wait_for_function(
+ "id => window.lastCodeRun?.id === id && window.lastCodeRun.status === 'running'",
+ arg=run_id,
+ )
+ expect(page.locator("#codeLibrary .session-card")).to_contain_text("Running")
+ hold_code_reads(page)
+ page.evaluate("window.replayCodeReady()")
+ page.wait_for_function("window.codeReadHolds.length >= 2")
+ expect(page.locator("#codeLibrary .session-card")).to_contain_text("Running")
+ page.evaluate("window.releaseCodeReads()")
+ expect(page.locator("#codeNew")).to_be_enabled()
+ expect(page.locator("#codeLibrary .session-card")).to_contain_text("Running")
+
+
[email protected]("endpoint", ["sessions", "bootstrap"])
+def test_first_http_sync_failure_recovers_without_reloading(
+ page, admin_base_url, endpoint
+):
+ page.add_init_script(
+ """(endpoint => {
+ const original = window.fetch;
+ window.fetch = async (...args) => {
+ if (!window.failedCodeLoad && new URL(String(args[0]), location.origin).pathname === `/admin/api/code/${endpoint}`) {
+ window.failedCodeLoad = true;
+ throw new TypeError('Initial snapshot failed');
+ }
+ return original(...args);
+ };
+ })("""
+ + repr(endpoint)
+ + ");"
+ )
+ page.goto(f"{admin_base_url}/admin/code")
+ expect(
+ page.get_by_role("button", name="New code session", exact=True)
+ ).to_be_enabled()
+ assert page.evaluate("window.failedCodeLoad")
+ expect(page.locator("#codeNotice")).to_be_hidden()
+
+
+def test_unavailable_feed_shows_reason_and_clears_it_on_recovery(
+ page, admin_base_url, code_control
+):
+ async def availability(available):
+ code_control.service._accepting = available
+ code_control.service._message = (
+ None if available else "Code storage is unavailable"
+ )
+
+ code_control.run(availability(False))
+ page.goto(f"{admin_base_url}/admin/code")
+ expect(page.locator("#codeNotice")).to_contain_text("Code storage is unavailable")
+ expect(page.locator("#codeNew")).to_be_disabled()
+ code_control.run(availability(True))
+ expect(page.locator("#codeNew")).to_be_enabled()
+ expect(page.locator("#codeNotice")).to_be_hidden()
+
+
+def test_reconnect_retires_out_of_page_prompt_without_discarding_live_form_input(
+ page, admin_base_url, tmp_path, code_control
+):
+ control_feed(page)
+ create_session(page, admin_base_url, tmp_path)
+ send(page, "Work")
+ connection = code_control.connection()
+ code_control.run(connection.prompt(0, turn_id=None))
+ expect(page.get_by_role("button", name="Allow", exact=True)).to_be_enabled()
+ page.evaluate("window.dropCodeEvents = ['prompt.updated']")
+ code_control.run(connection.resolve(0))
+ for index in range(55):
+ code_control.run(
+ connection.text("turn-1", str(index), f"Line {index}", complete=True)
+ )
+ code_control.run(connection.finish("turn-1"))
+ page.get_by_role("textbox", name="Message", exact=True).fill("Keep draft")
+ page.evaluate(
+ "window.dropCodeEvents = []; void window.codeFeed.onerror(new Event('error'))"
+ )
+ expect(page.get_by_role("button", name="Send", exact=True)).to_be_enabled()
+ expect(page.get_by_role("button", name="Allow", exact=True)).to_be_disabled()
+ expect(page.get_by_text("No longer active", exact=True)).to_be_visible()
+ expect(page.get_by_role("textbox", name="Message", exact=True)).to_have_value(
+ "Keep draft"
+ )
+
+
+def test_failed_reply_stays_after_its_output_once_and_not_in_composer(
+ page, admin_base_url, tmp_path, code_control
+):
+ url = create_session(page, admin_base_url, tmp_path)
+ send(page, "First")
+ connection = code_control.connection()
+ code_control.run(
+ connection.text(
+ "turn-1", "reasoning", "Reasoning so far", kind="reasoning", complete=True
+ )
+ )
+ code_control.run(
+ connection.text("turn-1", "tool", "Tool so far", kind="tool", complete=True)
+ )
+ code_control.run(connection.text("turn-1", "reply", "Partial reply", complete=True))
+ code_control.run(
+ connection.finish("turn-1", "failed", "Provider refused the request")
+ )
+ expect(
+ page.locator(".code-outcome").filter(has_text="Provider refused the request")
+ ).to_have_count(1)
+ expect(page.locator("#codeComposerStatus")).not_to_contain_text("Provider refused")
+ expect(page.locator("#codeNotice")).to_be_hidden()
+ send(page, "Second")
+ code_control.run(connection.finish("turn-2"))
+ page.goto(url)
+ expect(page.locator(".code-run")).to_have_count(2)
+ expect(page.locator(".code-run").first).to_contain_text("Partial reply")
+ expect(page.locator(".code-run").first.locator(".code-outcome")).to_contain_text(
+ "Provider refused"
+ )
+ expect(page.locator(".code-run").last).to_contain_text("Second")
+
+
[email protected]("refresh_first", [True, False])
+def test_model_effort_picker_syncs_tabs_and_keeps_missing_selection(
+ page, context, admin_base_url, tmp_path, code_control, refresh_first
+):
+ code_control.harness.configurations["provider/other"] = "other"
+ url = create_session(page, admin_base_url, tmp_path)
+ second = context.new_page()
+ try:
+ second.goto(url)
+ page.get_by_role("combobox", name="Selected model", exact=True).fill(
+ "provider/other"
+ )
+ page.get_by_role("option", name="provider/other", exact=True).click()
+ expect(second.locator("#codeModel")).to_have_value("provider/other")
+ page.locator("#codeReasoning").select_option("high")
+ expect(second.locator("#codeReasoning")).to_have_value("high")
+ send(page, "Use choice")
+ connection = code_control.connection()
+ assert connection.inputs[0][2] == "provider/other"
+ assert connection.efforts == ["high"]
+ expect(page.locator("#codeModel")).to_be_disabled()
+ expect(second.locator("#codeReasoning")).to_be_disabled()
+ code_control.run(connection.finish("turn-1"))
+ page.locator("#codeReasoning").select_option("")
+ expect(second.locator("#codeReasoning")).to_have_value("")
+ page.get_by_role("textbox", name="Message", exact=True).fill("Preserve me")
+ code_control.harness.configurations.pop("provider/other")
+ if refresh_first:
+ page.evaluate("window.CodeSessions.refresh()")
+ else:
+ page.locator("#codeSend").click()
+ expect(page.locator("#codeNotice")).to_contain_text("unavailable")
+ expect(page.locator("#codeModel")).to_have_value("provider/other")
+ expect(page.locator("#codeSend")).to_be_disabled()
+ expect(page.locator("#codeComposer")).to_have_value("Preserve me")
+ expect(page.locator("#codeComposerStatus")).to_contain_text("unavailable")
+ finally:
+ second.close()
+
+
+def test_library_reconnect_removes_missed_deletion_and_searches_beyond_first_page(
+ page, admin_base_url, tmp_path, code_control
+):
+ control_feed(page)
+
+ async def seed():
+ first = await code_control.service.create_session(
+ str(uuid.uuid4()), str(tmp_path)
+ )
+ await code_control.service.update_settings(
+ first.id, first.revision, {"title": "Needle project"}
+ )
+ for _ in range(26):
+ await code_control.service.create_session(str(uuid.uuid4()), str(tmp_path))
+ return first.id
+
+ # Start the isolated service before seeding it.
+ page.goto(f"{admin_base_url}/admin/code")
+ expect(page.locator("#codeNew")).to_be_enabled()
+ session_id = code_control.run(seed())
+ page.get_by_role("searchbox", name="Search titles and folders").fill("Needle")
+ expect(page.locator(".session-card")).to_have_count(1)
+ expect(page.locator(".session-card")).to_contain_text("Needle project")
+ page.evaluate("window.dropCodeEvents = ['session.deleted']")
+
+ async def remove_seed():
+ detail = await code_control.service.get_detail(session_id)
+ await code_control.service.delete_session(session_id, detail.session.revision)
+ await code_control.service.wait_idle(session_id)
+
+ code_control.run(remove_seed())
+ page.evaluate(
+ "window.dropCodeEvents = []; void window.codeFeed.onerror(new Event('error'))"
+ )
+ expect(page.locator(".session-card")).to_have_count(0)
+ expect(page.get_by_text("No matching sessions.", exact=True)).to_be_visible()
+
+
[email protected]("width,height", [(1440, 1000), (390, 844)])
+def test_code_composer_uses_chat_geometry_and_preserves_focus(
+ page, admin_base_url, tmp_path, code_control, width, height
+):
+ page.set_viewport_size({"width": width, "height": height})
+ create_session(page, admin_base_url, tmp_path)
+ composer = page.locator("#codeComposer")
+ composer.fill("a draft\nwith a second line")
+ composer.evaluate("input => input.setSelectionRange(2, 6)")
+ expected = composer.evaluate(
+ "input => { const s=getComputedStyle(input); return [s.minHeight,s.maxHeight,s.padding,s.lineHeight,s.resize]; }"
+ )
+ page.locator("#codeModel").click()
+ page.keyboard.press("Escape")
+ composer.focus()
+ composer.evaluate("input => input.setSelectionRange(2, 6)")
+ page.evaluate("window.CodeSessions.refresh()")
+ expect(composer).to_be_focused()
+ assert composer.evaluate("input => [input.selectionStart,input.selectionEnd]") == [
+ 2,
+ 6,
+ ]
+ assert (
+ page.locator("#codeComposer").bounding_box()["y"]
+ + page.locator("#codeComposer").bounding_box()["height"]
+ <= height
+ )
+ page.goto(f"{admin_base_url}/admin/chat")
+ page.get_by_role("button", name="New chat", exact=True).click()
+ chat = page.locator("#chatComposer")
+ expect(chat).to_be_visible()
+ actual = chat.evaluate(
+ "input => { const s=getComputedStyle(input); return [s.minHeight,s.maxHeight,s.padding,s.lineHeight,s.resize]; }"
+ )
+ assert actual == expected
diff --git a/pyproject.toml b/pyproject.toml
index 5d4b8363..64c04730 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
[project]
name = "free-claude-code"
-version = "5.22.10"
+version = "5.23.2"
description = "Local proxy connecting coding agents to OpenAI-compatible AI providers"
readme = "README.md"
requires-python = ">=3.14.0"
diff --git a/src/free_claude_code/api/admin_routes.py b/src/free_claude_code/api/admin_routes.py
index 07ad3924..64fb14da 100644
--- a/src/free_claude_code/api/admin_routes.py
+++ b/src/free_claude_code/api/admin_routes.py
@@ -45,6 +45,10 @@ _ADMIN_ASSET_FILENAMES = frozenset(
"app-icon.svg",
"chat_sessions.css",
"chat_sessions.js",
+ "code_sessions.css",
+ "code_sessions.js",
+ "session_layout.css",
+ "session_ui.js",
"model_combobox.js",
}
)
diff --git a/src/free_claude_code/api/admin_static/admin.js b/src/free_claude_code/api/admin_static/admin.js
index 21f7e065..447dde16 100644
--- a/src/free_claude_code/api/admin_static/admin.js
+++ b/src/free_claude_code/api/admin_static/admin.js
@@ -6,7 +6,7 @@ const state = {
modelOptions: [],
modelComboboxes: new Set(),
authPollers: new Map(),
- activeView: window.location.pathname.startsWith("/admin/chat") ? "chat" : "providers",
+ activeView: sessionViewFromPath(),
};
const MASKED_SECRET = "********";
@@ -40,8 +40,19 @@ const VIEW_GROUPS = [
sections: [],
containerId: "chatRoot",
},
+ {
+ id: "code",
+ label: "Code sessions",
+ title: "Code sessions",
+ sections: [],
+ containerId: "codeRoot",
+ },
];
+function sessionViewFromPath() {
+ return ["chat", "code"].find((id) => window.location.pathname.startsWith(`/admin/${id}`)) || "providers";
+}
+
const byId = (id) => document.getElementById(id);
function sourceLabel(source) {
@@ -107,6 +118,7 @@ async function load() {
hydrateModelOptions(),
refreshLocalStatus(),
window.ChatSessions ? window.ChatSessions.initialize(api) : Promise.resolve(),
+ window.CodeSessions.initialize(api),
]);
updateDirtyState();
showMessage("");
@@ -138,10 +150,11 @@ function setActiveView(viewId, { scroll = false } = {}) {
state.activeView = activeView.id;
byId("pageTitle").textContent = activeView.title;
const chatActive = activeView.id === "chat";
- document.querySelector(".app-shell").classList.toggle("chat-active", chatActive);
- document.querySelector(".main").classList.toggle("chat-main", chatActive);
- document.querySelector(".topbar").hidden = chatActive;
- document.querySelector(".action-bar").hidden = chatActive;
+ const sessionActive = chatActive || activeView.id === "code";
+ document.querySelector(".app-shell").classList.toggle("session-active", sessionActive);
+ document.querySelector(".main").classList.toggle("session-main", sessionActive);
+ document.querySelector(".topbar").hidden = sessionActive;
+ document.querySelector(".action-bar").hidden = sessionActive;
document.querySelectorAll(".nav-link").forEach((link) => {
const selected = link.dataset.view === activeView.id;
@@ -165,14 +178,15 @@ function setActiveView(viewId, { scroll = false } = {}) {
if (chatActive && window.ChatSessions) {
window.ChatSessions.activate(window.location.pathname);
}
+ if (activeView.id === "code") window.CodeSessions.activate(window.location.pathname);
}
function navigateToView(viewId) {
- if (viewId === "chat") {
- if (window.location.pathname !== "/admin/chat") {
- window.history.pushState({}, "", "/admin/chat");
+ if (["chat", "code"].includes(viewId)) {
+ if (window.location.pathname !== `/admin/${viewId}`) {
+ window.history.pushState({}, "", `/admin/${viewId}`);
}
- } else if (window.location.pathname.startsWith("/admin/chat")) {
+ } else if (sessionViewFromPath() !== "providers") {
window.history.pushState({}, "", "/admin");
}
setActiveView(viewId, { scroll: true });
@@ -951,7 +965,7 @@ function showCredentialErrors(checks) {
function setApplying(applying) {
state.applying = applying;
- VIEW_GROUPS.filter((view) => view.id !== "chat").forEach((view) => {
+ VIEW_GROUPS.filter((view) => !["chat", "code"].includes(view.id)).forEach((view) => {
byId(`view-${view.id}`).inert = applying || !!state.restart;
});
if (applying) state.modelComboboxes.forEach((combobox) => combobox.close());
@@ -1167,6 +1181,7 @@ async function loadModelOptions(refresh = false) {
});
setModelOptions(result.models);
if (refresh && window.ChatSessions) await window.ChatSessions.refresh();
+ if (refresh && window.CodeSessions) await window.CodeSessions.refresh();
return result;
}
@@ -1224,9 +1239,7 @@ document.addEventListener("pointerdown", (event) => {
});
window.addEventListener("popstate", () => {
- const viewId = window.location.pathname.startsWith("/admin/chat")
- ? "chat"
- : "providers";
+ const viewId = sessionViewFromPath();
setActiveView(viewId, { scroll: false });
});
diff --git a/src/free_claude_code/api/admin_static/chat_sessions.css b/src/free_claude_code/api/admin_static/chat_sessions.css
index fddca482..0d87e7a5 100644
--- a/src/free_claude_code/api/admin_static/chat_sessions.css
+++ b/src/free_claude_code/api/admin_static/chat_sessions.css
@@ -1,221 +1,8 @@
-.main.chat-main {
- height: 100vh;
- padding: 0;
- overflow: hidden;
-}
-
-.chat-main .admin-views,
-.chat-main .admin-view,
-.chat-root,
-.chat-session-shell {
- height: 100%;
- min-height: 0;
-}
-
-.chat-root {
- padding: 36px clamp(16px, 3vw, 42px) 16px;
-}
-
-.chat-library-header,
-.chat-header-row,
-.chat-controls,
-.chat-composer-actions,
-.chat-dialog-actions,
-.chat-message-label {
+.chat-dialog-actions {
display: flex;
align-items: center;
}
-.chat-library-header,
-.chat-header-row,
-.chat-composer-actions,
-.chat-message-label {
- justify-content: space-between;
-}
-
-.chat-library-header {
- gap: 24px;
- margin: 0 auto 24px;
- max-width: 920px;
-}
-
-.chat-library-header h2 {
- margin: 0;
- font-size: 30px;
-}
-
-.chat-library-header p,
-.chat-session-card p {
- color: var(--muted);
-}
-
-.chat-library-header p {
- margin: 7px 0 0;
-}
-
-.chat-search,
-.chat-session-list,
-.chat-load-more,
-.chat-notice {
- width: 100%;
- max-width: 920px;
- margin-left: auto;
- margin-right: auto;
-}
-
-.chat-search,
-.chat-load-more {
- display: block;
-}
-
-.chat-search {
- min-height: 44px;
- margin-bottom: 16px;
- border: 1px solid var(--line-strong);
- border-radius: var(--radius-md);
- background: var(--input);
- padding: 10px 14px;
-}
-
-.chat-session-list {
- display: grid;
- gap: 10px;
-}
-
-.chat-session-card {
- display: grid;
- width: 100%;
- gap: 7px;
- border: 1px solid var(--line);
- border-radius: var(--radius-md);
- background: var(--panel);
- padding: 17px 19px;
- text-align: left;
- cursor: pointer;
-}
-
-.chat-session-card:hover {
- border-color: var(--accent-border);
- background: var(--card-hover);
-}
-
-.chat-session-card p {
- overflow: hidden;
- margin: 0;
- text-overflow: ellipsis;
- white-space: nowrap;
-}
-
-.chat-session-card span,
-.chat-muted {
- color: var(--muted);
- font-size: 12px;
-}
-
-.chat-session-card .chat-session-status {
- color: var(--accent);
- font-weight: 700;
-}
-
-.chat-load-more {
- margin-top: 18px;
-}
-
-.chat-session-shell {
- display: grid;
- grid-template-areas:
- "header"
- "notice"
- "transcript"
- "composer";
- grid-template-rows: auto auto minmax(0, 1fr) auto;
- position: relative;
-}
-
-.chat-session-header {
- grid-area: header;
- padding-bottom: 16px;
- border-bottom: 1px solid var(--line);
-}
-
-.chat-header-row {
- gap: 12px;
-}
-
-.chat-title {
- flex: 1;
- min-width: 0;
- border: 1px solid transparent;
- border-radius: var(--radius-sm);
- background: transparent;
- padding: 7px 10px;
- color: var(--text-strong);
- font-size: 19px;
- font-weight: 700;
-}
-
-.chat-title:hover,
-.chat-title:focus {
- border-color: var(--line-strong);
- background: var(--input);
-}
-
-.chat-back-button {
- border: 0;
- background: transparent;
- color: var(--muted);
- cursor: pointer;
-}
-
-.chat-back-button:hover {
- color: var(--text);
-}
-
-.chat-controls {
- flex-wrap: wrap;
- gap: 10px;
- margin-top: 14px;
-}
-
-.chat-control {
- display: grid;
- gap: 5px;
- color: var(--muted);
- font-size: 11px;
- font-weight: 700;
- letter-spacing: 0.04em;
- text-transform: uppercase;
-}
-
-.chat-control select,
-.chat-model-input {
- min-height: 38px;
- border: 1px solid var(--line-strong);
- border-radius: var(--radius-sm);
- background: var(--input);
- padding: 7px 10px;
- color: var(--text);
- text-transform: none;
-}
-
-.chat-model-control {
- flex: 1 1 360px;
- max-width: 520px;
-}
-
-.chat-model-control .model-combobox input[type="text"] {
- width: 100%;
- padding-right: 44px;
-}
-
-.chat-model-control .model-combobox {
- text-transform: none;
-}
-
-.chat-model-control .model-combobox-toggle {
- height: 38px;
-}
-
.chat-context-meter {
align-self: end;
min-height: 38px;
@@ -231,108 +18,11 @@
color: var(--warn);
}
-.chat-controls > button {
- align-self: end;
-}
-
-.chat-notice {
- grid-area: notice;
- margin-top: 12px;
- margin-bottom: 10px;
- border: 1px solid var(--line);
- border-radius: var(--radius-sm);
- padding: 9px 12px;
- color: var(--muted);
- font-size: 13px;
-}
-
-.chat-notice.error {
- border-color: var(--error-border);
- background: var(--error-bg);
- color: var(--error);
-}
-
-.chat-transcript {
- grid-area: transcript;
- min-height: 0;
- overflow-y: auto;
- overscroll-behavior: contain;
- padding: 24px 0 30px;
- scroll-behavior: auto;
-}
-
-.chat-message {
- max-width: 1120px;
- margin: 0 0 22px;
- border-radius: var(--radius-lg);
-}
-
-.user-message {
- margin-left: auto;
- max-width: min(680px, 88%);
- background: var(--panel-strong);
- padding: 14px 17px;
-}
-
-.assistant-message {
- padding: 2px 4px;
-}
-
-.chat-message-label {
- gap: 12px;
- margin-bottom: 8px;
- color: var(--muted);
- font-size: 12px;
- font-weight: 700;
-}
-
.chat-fallback-label {
color: var(--info);
font-weight: 500;
}
-.chat-message-plain,
-.chat-markdown {
- overflow-wrap: anywhere;
- line-height: 1.65;
- white-space: pre-wrap;
-}
-
-.chat-markdown {
- white-space: normal;
-}
-
-.chat-markdown > :first-child {
- margin-top: 0;
-}
-
-.chat-markdown > :last-child {
- margin-bottom: 0;
-}
-
-.chat-markdown pre {
- overflow-x: auto;
- border: 1px solid var(--line);
- border-radius: var(--radius-sm);
- background: var(--input);
- padding: 13px;
-}
-
-.chat-markdown code {
- border-radius: 4px;
- background: var(--input);
- padding: 0.12em 0.3em;
-}
-
-.chat-markdown pre code {
- padding: 0;
-}
-
-.chat-markdown a {
- color: var(--info);
-}
-
-.chat-thinking,
.chat-compaction {
margin: 12px 0;
border-left: 2px solid var(--line-strong);
@@ -340,7 +30,6 @@
color: var(--muted);
}
-.chat-thinking summary,
.chat-compaction summary {
cursor: pointer;
font-size: 13px;
@@ -355,102 +44,6 @@
padding: 12px 15px;
}
-.chat-generation-status {
- margin-top: 12px;
- border: 1px solid var(--warn-border);
- border-radius: var(--radius-sm);
- background: var(--warn-bg);
- padding: 9px 11px;
- color: var(--warn);
- font-size: 13px;
-}
-
-.chat-generation-status.failed {
- border-color: var(--error-border);
- background: var(--error-bg);
- color: var(--error);
-}
-
-.chat-message-actions {
- display: flex;
- gap: 8px;
- margin-top: 12px;
-}
-
-.chat-composer {
- grid-area: composer;
- margin: 8px 0 0;
- border: 1px solid var(--line-strong);
- border-radius: var(--radius-lg);
- background: var(--input);
- padding: 10px 12px 9px;
-}
-
-.chat-composer:focus-within {
- border-color: var(--accent);
- background: var(--input-focus);
- box-shadow: 0 0 0 3px rgba(16, 185, 129, 0.15);
-}
-
-.chat-composer textarea {
- display: block;
- width: 100%;
- min-height: calc(3em + 8px);
- max-height: calc(9em + 8px);
- resize: none;
- overflow-y: hidden;
- border: 0;
- border-radius: 0;
- background: transparent;
- padding: 4px 2px;
- line-height: 1.5;
- outline: none;
-}
-
-.chat-composer-actions {
- gap: 12px;
- margin-top: 4px;
-}
-
-.chat-composer-status {
- color: var(--muted);
- font-size: 12px;
-}
-
-.chat-older {
- display: block;
- margin: 0 auto 24px;
-}
-
-.chat-empty {
- display: grid;
- place-items: center;
- gap: 8px;
- min-height: 220px;
- color: var(--muted);
- text-align: center;
-}
-
-.chat-empty h3,
-.chat-empty p {
- margin: 0;
-}
-
-.chat-transcript-empty {
- min-height: 100%;
-}
-
-.danger-button {
- min-height: 38px;
- border: 1px solid var(--error-border);
- border-radius: var(--radius-sm);
- background: var(--error-bg);
- padding: 8px 13px;
- color: var(--error);
- cursor: pointer;
- font-weight: 700;
-}
-
.chat-prompt-dialog {
width: min(680px, calc(100vw - 32px));
border: 1px solid var(--line-strong);
@@ -484,118 +77,13 @@
}
@media (max-width: 900px) {
- .app-shell.chat-active {
- height: 100dvh;
- min-height: 0;
- overflow: hidden;
- }
-
- .app-shell.chat-active .sidebar {
- flex: 0 0 auto;
- }
-
- .main.chat-main {
- flex: 1 1 0;
- height: auto;
- min-height: 0;
- }
-
- .chat-root {
- padding: 24px 20px 12px;
- }
-
- .chat-controls {
- display: grid;
- grid-template-columns: 1fr 1fr;
- }
-
- .chat-model-control,
.chat-context-meter {
grid-column: 1 / -1;
}
-
- .chat-model-control {
- max-width: none;
- }
}
@media (max-width: 700px) {
- .chat-main .admin-views,
- .chat-main .admin-view,
- .chat-root,
- .chat-session-shell {
- height: 100%;
- min-height: 0;
- }
-
- .chat-root {
- padding: 16px 12px 8px;
- }
-
- .chat-session-shell {
- grid-template-rows: auto auto minmax(0, 1fr) auto;
- }
-
- .chat-library-header {
- align-items: flex-start;
- }
-
- .chat-header-row {
- flex-wrap: wrap;
- }
-
- .chat-title {
- order: 3;
- flex-basis: 100%;
- }
-
- .chat-controls {
- grid-template-columns: 1fr;
- }
-
- .chat-model-control,
.chat-context-meter {
grid-column: auto;
}
-
- .chat-transcript {
- padding-left: 0;
- padding-right: 0;
- }
-
- .chat-composer {
- margin-left: 0;
- margin-right: 0;
- }
-}
-
-@media (max-width: 600px) {
- .app-shell.chat-active .sidebar {
- padding: 10px 12px;
- gap: 8px;
- }
-
- .app-shell.chat-active .brand {
- flex-direction: row;
- justify-content: flex-start;
- text-align: left;
- }
-
- .app-shell.chat-active .brand-mark {
- width: 34px;
- height: 34px;
- }
-
- .app-shell.chat-active .section-nav {
- grid-template-columns: repeat(4, minmax(0, 1fr));
- gap: 4px;
- }
-
- .app-shell.chat-active .nav-link {
- justify-content: center;
- min-height: 34px;
- padding: 6px 4px;
- text-align: center;
- font-size: 11px;
- }
}
diff --git a/src/free_claude_code/api/admin_static/chat_sessions.js b/src/free_claude_code/api/admin_static/chat_sessions.js
index c1480772..48694e14 100644
--- a/src/free_claude_code/api/admin_static/chat_sessions.js
+++ b/src/free_claude_code/api/admin_static/chat_sessions.js
@@ -60,27 +60,21 @@
"operation.failed",
];
+ const UI = window.SessionUI;
+ const {
+ node,
+ button,
+ nearBottom,
+ resizeComposer,
+ focusIsUnclaimed: composerFocusIsUnclaimed,
+ } = UI;
const root = () => document.getElementById("chatRoot");
- function node(tag, className = "", text = "") {
- const element = document.createElement(tag);
- if (className) element.className = className;
- if (text) element.textContent = text;
- return element;
- }
-
- function button(label, className, action) {
- const element = node("button", className, label);
- element.type = "button";
- element.addEventListener("click", action);
- return element;
- }
-
function setNotice(message, kind = "") {
const area = document.getElementById("chatNotice");
if (!area) return;
area.textContent = message;
- area.className = `chat-notice ${kind}`.trim();
+ area.className = `session-notice ${kind}`.trim();
area.hidden = !message;
}
@@ -158,7 +152,9 @@
state.feedLastId = cursor;
state.feedStatus = "synchronizing";
refreshFeedState();
- const snapshotOperationIds = installActiveSnapshot(snapshot.active_operations);
+ const snapshotOperationIds = installActiveSnapshot(
+ snapshot.active_operations,
+ );
if (!snapshotOperationIds) {
restartEventFeed();
return;
@@ -296,7 +292,9 @@
}
function upsertLibrarySummary(summary) {
- state.libraryItems = state.libraryItems.filter((item) => item.id !== summary.id);
+ state.libraryItems = state.libraryItems.filter(
+ (item) => item.id !== summary.id,
+ );
if (matchesLibraryQuery(summary)) state.libraryItems.push(summary);
sortLibraryItems();
}
@@ -417,12 +415,12 @@
function validOperationSnapshot(snapshot) {
return Boolean(
snapshot &&
- typeof snapshot.session_id === "string" &&
- typeof snapshot.operation_id === "string" &&
- validOperationKind(snapshot.kind) &&
- ["generating", "compacting"].includes(snapshot.phase) &&
- Number.isInteger(snapshot.operation_sequence) &&
- Array.isArray(snapshot.segments),
+ typeof snapshot.session_id === "string" &&
+ typeof snapshot.operation_id === "string" &&
+ validOperationKind(snapshot.kind) &&
+ ["generating", "compacting"].includes(snapshot.phase) &&
+ Number.isInteger(snapshot.operation_sequence) &&
+ Array.isArray(snapshot.segments),
);
}
@@ -496,7 +494,8 @@
const active = state.activeOperations.get(payload.session_id);
const pending = state.pendingCommands.get(payload.session_id);
const matchingActive = active?.id === payload.operation_id ? active : null;
- const matchingPending = pending?.id === payload.operation_id ? pending : null;
+ const matchingPending =
+ pending?.id === payload.operation_id ? pending : null;
if (isTerminalEvent(type, payload.kind)) {
if (
matchingActive &&
@@ -560,7 +559,10 @@
} else if (type === "compaction.started") {
operation.phase = "compacting";
operation.status = "Compacting…";
- } else if (type === "compaction.completed" && operation.action !== "compact") {
+ } else if (
+ type === "compaction.completed" &&
+ operation.action !== "compact"
+ ) {
operation.phase = "generating";
operation.status = "Thinking…";
}
@@ -647,7 +649,9 @@
state.draftOperationId = null;
state.draftSubmittedText = "";
try {
- const stored = JSON.parse(sessionStorage.getItem(draftKey(sessionId)) || "null");
+ const stored = JSON.parse(
+ sessionStorage.getItem(draftKey(sessionId)) || "null",
+ );
if (!stored || typeof stored !== "object") return;
if (typeof stored.text === "string") state.draft = stored.text;
if (typeof stored.operationId === "string") {
@@ -809,18 +813,22 @@
}
function routedSessionId(path) {
- return path.match(/^\/admin\/chat\/([0-9a-f-]+)$/i)?.[1].toLowerCase() || null;
+ return (
+ path.match(/^\/admin\/chat\/([0-9a-f-]+)$/i)?.[1].toLowerCase() || null
+ );
}
function renderLoading() {
state.modelComboboxes.clear();
const container = root();
- container.replaceChildren(node("div", "chat-empty", "Loading Chat Sessions…"));
+ container.replaceChildren(
+ node("div", "session-empty", "Loading Chat Sessions…"),
+ );
}
function renderUnavailable() {
state.modelComboboxes.clear();
- const container = node("section", "chat-empty");
+ const container = node("section", "session-empty");
container.append(
node("h3", "", "Chat Sessions unavailable"),
node(
@@ -845,37 +853,24 @@
function renderLibraryShell() {
state.modelComboboxes.clear();
- const header = node("header", "chat-library-header");
- const copy = node("div");
- copy.append(
- node("h2", "", "Chat Sessions"),
- node("p", "", "Talk directly to any configured FCC model."),
+ const create = button("New chat", "primary-button", createSession);
+ create.dataset.testid = "chat-new";
+ create.disabled = !mutationsReady();
+ const header = UI.libraryHeader(
+ "Chat Sessions",
+ "Talk directly to any configured FCC model.",
+ create,
);
- const newButton = button("New chat", "primary-button", createSession);
- newButton.dataset.testid = "chat-new";
- newButton.disabled = !mutationsReady();
- header.append(copy, newButton);
-
- const search = node("input", "chat-search");
- search.type = "search";
- search.placeholder = "Search chats";
- search.value = state.libraryQuery;
- search.setAttribute("aria-label", "Search chats");
- let timer = null;
- search.addEventListener("input", () => {
- window.clearTimeout(timer);
- timer = window.setTimeout(() => {
- state.libraryQuery = search.value;
- loadLibrary(true, state.routeVersion);
- }, 200);
+ const search = UI.search("Search chats", state.libraryQuery, (value) => {
+ state.libraryQuery = value;
+ loadLibrary(true, state.routeVersion);
});
-
- const notice = node("div", "chat-notice");
+ const notice = node("div", "session-notice");
notice.id = "chatNotice";
notice.hidden = true;
- const list = node("div", "chat-session-list");
+ const list = node("div", "session-list");
list.id = "chatSessionList";
- const more = button("Load more", "secondary-button chat-load-more", () =>
+ const more = button("Load more", "secondary-button session-load-more", () =>
loadLibrary(false, state.routeVersion),
);
more.id = "chatLoadMore";
@@ -897,7 +892,7 @@
state.libraryItems = [];
state.libraryCursor = null;
state.libraryLoadMore = null;
- list.replaceChildren(node("div", "chat-empty", "Loading chats…"));
+ list.replaceChildren(node("div", "session-empty", "Loading chats…"));
} else {
state.libraryLoadMore = loadMore;
const more = document.getElementById("chatLoadMore");
@@ -920,7 +915,8 @@
page.sessions.forEach((session) => {
if (state.deletedSessions.has(session.id)) return;
const current = reduceSessionSummary(session);
- if (current && matchesLibraryQuery(current)) merged.set(current.id, current);
+ if (current && matchesLibraryQuery(current))
+ merged.set(current.id, current);
});
state.libraryItems = [...merged.values()].filter(matchesLibraryQuery);
sortLibraryItems();
@@ -945,23 +941,24 @@
list.appendChild(
node(
"div",
- "chat-empty",
+ "session-empty",
state.libraryQuery ? "No matching chats." : "Start your first chat.",
),
);
}
state.libraryItems.forEach((session) => {
- const item = button("", "chat-session-card", () => openSession(session.id));
- const heading = node("strong", "", session.title);
- const preview = node("p", "", session.preview || "No messages yet");
- const meta = node("span", "", `${session.model} · ${relativeTime(session.updated_at)}`);
- item.append(heading, preview, meta);
+ const item = UI.card(
+ session.title,
+ session.preview || "No messages yet",
+ `${session.model} · ${relativeTime(session.updated_at)}`,
+ () => openSession(session.id),
+ );
const active = state.activeOperations.get(session.id);
if (active) {
item.appendChild(
node(
"span",
- "chat-session-status",
+ "session-status",
active.action === "compact" ? "Compacting…" : "Thinking…",
),
);
@@ -1000,7 +997,8 @@
return;
}
const refreshingVisibleSession =
- state.session?.id === id && Boolean(document.getElementById("chatTranscript"));
+ state.session?.id === id &&
+ Boolean(document.getElementById("chatTranscript"));
if (!refreshingVisibleSession) renderLoading();
try {
const detail = await state.api(`/admin/api/chat/sessions/${id}`);
@@ -1023,7 +1021,7 @@
}
} catch (error) {
if (version !== state.routeVersion) return;
- const empty = node("section", "chat-empty");
+ const empty = node("section", "session-empty");
empty.append(
node("h3", "", "Could not open this chat"),
node("p", "", error.message),
@@ -1067,22 +1065,20 @@
function renderSession({ followLatest = true, scrollTop = 0 } = {}) {
const session = state.session;
if (!session) return;
- const previousTitle = document.querySelector(".chat-title");
+ const previousTitle = root().querySelector(".session-title");
if (previousTitle instanceof HTMLInputElement) {
state.retiredTitleInputs.add(previousTitle);
}
state.modelComboboxes.clear();
- const shell = node("div", "chat-session-shell");
const header = renderSessionHeader(session);
- const notice = node("div", "chat-notice");
+ const notice = node("div", "session-notice");
notice.id = "chatNotice";
notice.hidden = true;
- const scroller = node("div", "chat-transcript");
+ const scroller = node("div", "session-transcript");
scroller.id = "chatTranscript";
scroller.setAttribute("aria-label", "Conversation");
const composer = renderComposer();
- shell.append(header, notice, scroller, composer);
- root().replaceChildren(shell);
+ root().replaceChildren(UI.shell(header, notice, scroller, composer));
renderTranscript();
refreshComposerState();
if (followLatest) {
@@ -1102,28 +1098,7 @@
}
function renderSessionHeader(session) {
- const header = node("header", "chat-session-header");
- const top = node("div", "chat-header-row");
- top.appendChild(button("← Chats", "chat-back-button", goLibrary));
- const title = node("input", "chat-title");
- title.value = session.title;
- title.maxLength = 200;
- title.setAttribute("aria-label", "Chat title");
- title.addEventListener("blur", () => {
- if (
- title.isConnected &&
- !state.retiredTitleInputs.has(title) &&
- title.value !== state.session?.title
- )
- void updateSession({ title: title.value });
- });
- title.addEventListener("keydown", (event) => {
- if (event.key === "Enter") title.blur();
- });
- top.appendChild(title);
- top.appendChild(button("Delete", "danger-button", deleteSession));
-
- const controls = node("div", "chat-controls");
+ const controls = node("div", "session-controls");
const compact = button("Compact now", "secondary-button", compactSession);
compact.id = "chatCompact";
controls.append(
@@ -1133,65 +1108,49 @@
compact,
button("System prompt", "secondary-button", editSystemPrompt),
);
- header.append(top, controls);
- return header;
+ return UI.header(
+ "← Chats",
+ goLibrary,
+ session.title,
+ "Chat title",
+ (title) => {
+ if (
+ !state.retiredTitleInputs.has(title) &&
+ title.value !== state.session?.title
+ )
+ void updateSession({ title: title.value });
+ },
+ [button("Delete", "danger-button", deleteSession)],
+ controls,
+ );
}
function renderModelControl(session) {
- const group = node("div", "chat-control chat-model-control");
- const label = node("label", "", "Model");
- label.htmlFor = "chatModel";
- const input = node("input", "chat-model-input");
- input.id = "chatModel";
- input.type = "text";
- input.autocomplete = "off";
- input.value = session.model;
- input.setAttribute("aria-label", "Selected model");
- let committedModel = session.model;
- const availableModels = () =>
- (state.bootstrap?.models || []).map((option) => option.model_ref);
- const combobox = new window.FccModelCombobox(input, {
- listboxId: "chat-model-options",
- label: "model",
- values: availableModels,
- emptyMessage: () =>
- availableModels().length ? "No matching models." : "No models available.",
- registry: state.modelComboboxes,
- onSelect: (model) => {
- committedModel = model;
+ return UI.modelControl(
+ "chatModel",
+ session.model,
+ () => (state.bootstrap?.models || []).map((option) => option.model_ref),
+ state.modelComboboxes,
+ (model) => {
void updateSession({ model });
},
- onClose: () => {
- input.value = committedModel;
- },
- });
- group.append(label, combobox.element);
- return group;
+ ).group;
}
function renderReasoningControl(session) {
- const group = node("label", "chat-control");
- group.appendChild(node("span", "", "Thinking"));
- const select = node("select");
- select.id = "chatReasoning";
- [
- ["off", "Off"],
- ["low", "Low"],
- ["medium", "Medium"],
- ["high", "High"],
- ["xhigh", "Extra High"],
- ["max", "Max"],
- ].forEach(([value, label]) => {
- const option = node("option", "", label);
- option.value = value;
- select.appendChild(option);
- });
- select.value = session.reasoning;
- select.addEventListener("change", () =>
- updateSession({ reasoning: select.value }),
- );
- group.appendChild(select);
- return group;
+ return UI.reasoningControl(
+ "chatReasoning",
+ [
+ ["off", "Off"],
+ ["low", "Low"],
+ ["medium", "Medium"],
+ ["high", "High"],
+ ["xhigh", "Extra High"],
+ ["max", "Max"],
+ ],
+ session.reasoning,
+ (reasoning) => updateSession({ reasoning }),
+ ).group;
}
function renderContextMeter() {
@@ -1201,7 +1160,9 @@
return meter;
}
- function updateContextMeter(element = document.getElementById("chatContextMeter")) {
+ function updateContextMeter(
+ element = document.getElementById("chatContextMeter"),
+ ) {
if (!element) return;
const context = state.context;
if (!context || context.context_window_tokens === null) {
@@ -1215,74 +1176,33 @@
}
function renderComposer() {
- const wrapper = node("div", "chat-composer");
- const textarea = node("textarea");
- textarea.id = "chatComposer";
- textarea.rows = 2;
- textarea.placeholder = "Message this model";
- textarea.value = state.draft;
- textarea.setAttribute("aria-label", "Message");
- textarea.addEventListener("input", () => {
- state.draft = textarea.value;
- state.draftOperationId = null;
- state.draftSubmittedText = "";
- saveDraft();
- refreshComposerState();
- scheduleEstimate();
- });
- textarea.addEventListener("keydown", (event) => {
- if (event.key === "Enter" && !event.shiftKey) {
- event.preventDefault();
- if (!document.getElementById("chatSend")?.disabled) sendMessage();
- }
- });
- const actions = node("div", "chat-composer-actions");
- const status = node("span", "chat-composer-status");
- status.id = "chatComposerStatus";
- status.setAttribute("aria-live", "polite");
- const send = button("Send", "primary-button", sendMessage);
- send.id = "chatSend";
- const stop = button("Stop", "danger-button", stopOperation);
- stop.id = "chatStop";
- stop.hidden = true;
- actions.append(status, send, stop);
- wrapper.append(textarea, actions);
- return wrapper;
- }
-
- function resizeComposer(textarea) {
- textarea.style.height = "auto";
- textarea.style.height = `${textarea.scrollHeight}px`;
- textarea.style.overflowY =
- textarea.scrollHeight > textarea.clientHeight ? "auto" : "hidden";
- }
-
- function composerFocusIsUnclaimed() {
- const active = document.activeElement;
- return !active || active === document.body || active === document.documentElement;
+ return UI.composer(
+ "chat",
+ state.draft,
+ "Message this model",
+ (value) => {
+ state.draft = value;
+ state.draftOperationId = null;
+ state.draftSubmittedText = "";
+ saveDraft();
+ refreshComposerState();
+ scheduleEstimate();
+ },
+ sendMessage,
+ stopOperation,
+ );
}
function captureComposerSelection() {
- const textarea = document.getElementById("chatComposer");
- if (!textarea || document.activeElement !== textarea) return null;
- return {
- start: textarea.selectionStart,
- end: textarea.selectionEnd,
- direction: textarea.selectionDirection,
- };
+ return UI.captureSelection(document.getElementById("chatComposer"));
}
function restoreComposerSelection(selection) {
- const textarea = document.getElementById("chatComposer");
- if (!textarea || textarea.disabled || !selection) return;
- const start = Math.min(selection.start, textarea.value.length);
- const end = Math.min(selection.end, textarea.value.length);
- textarea.focus({ preventScroll: true });
- textarea.setSelectionRange(start, end, selection.direction);
+ UI.restoreSelection(document.getElementById("chatComposer"), selection);
}
function captureTitleEdit() {
- const input = document.querySelector(".chat-title");
+ const input = root().querySelector(".session-title");
if (
!(input instanceof HTMLInputElement) ||
document.activeElement !== input ||
@@ -1298,7 +1218,7 @@
}
function restoreTitleEdit(edit) {
- const input = document.querySelector(".chat-title");
+ const input = root().querySelector(".session-title");
if (!(input instanceof HTMLInputElement) || !edit) return;
input.value = edit.value;
input.focus({ preventScroll: true });
@@ -1314,12 +1234,20 @@
scroller.replaceChildren();
if (state.nextBefore) {
scroller.appendChild(
- button("Load older messages", "secondary-button chat-older", loadOlder),
+ button(
+ "Load older messages",
+ "secondary-button session-older",
+ loadOlder,
+ ),
);
}
if (!state.turns.length && !state.operation) {
scroller.appendChild(
- node("div", "chat-empty chat-transcript-empty", "Start the conversation."),
+ node(
+ "div",
+ "session-empty session-transcript-empty",
+ "Start the conversation.",
+ ),
);
return;
}
@@ -1348,10 +1276,10 @@
state.operation.userText &&
!operationHasTurn
) {
- const pending = node("article", "chat-message user-message");
+ const pending = node("article", "session-message user-message");
pending.append(
- node("div", "chat-message-label", "You"),
- node("div", "chat-message-plain", state.operation.userText),
+ node("div", "session-message-label", "You"),
+ node("div", "session-message-plain", state.operation.userText),
);
scroller.appendChild(pending);
}
@@ -1364,53 +1292,59 @@
}
function renderUserMessage(turn) {
- const message = node("article", "chat-message user-message");
- message.append(node("div", "chat-message-label", "You"));
- const body = node("div", "chat-message-plain", turn.user_text);
+ const message = UI.message("user", "You");
+ const body = node("div", "session-message-plain", turn.user_text);
message.appendChild(body);
return message;
}
function renderAssistantMessage(turn) {
const generation = turn.generation;
- const message = node("article", "chat-message assistant-message");
- const label = node("div", "chat-message-label", "Assistant");
+ const message = UI.message("assistant", "Assistant");
+ const label = message.firstElementChild;
if (
generation.actual_model &&
generation.actual_model !== generation.requested_model
) {
label.appendChild(
- node("span", "chat-fallback-label", `Answered by ${generation.actual_model}`),
+ node(
+ "span",
+ "chat-fallback-label",
+ `Answered by ${generation.actual_model}`,
+ ),
);
}
message.appendChild(label);
generation.segments.forEach((segment) => {
if (segment.kind === "thinking") {
- const details = document.createElement("details");
- details.className = "chat-thinking";
- details.appendChild(node("summary", "", "Thinking"));
- const content = node("div", "chat-markdown");
+ const details = UI.thinking();
+ const content = node("div", "session-markdown");
content.innerHTML = segment.html;
details.appendChild(content);
message.appendChild(details);
} else {
- const content = node("div", "chat-markdown");
+ const content = node("div", "session-markdown");
// The server renders this with raw HTML disabled and safe-link rules.
content.innerHTML = segment.html;
message.appendChild(content);
}
});
if (!generation.segments.length && generation.status === "running") {
- message.appendChild(node("p", "chat-muted", "Running in another tab…"));
+ message.appendChild(
+ node("p", "session-muted", "Running in another tab…"),
+ );
}
if (generation.status !== "completed" && generation.status !== "running") {
- const status = node("div", `chat-generation-status ${generation.status}`);
+ const status = node(
+ "div",
+ `session-generation-status ${generation.status}`,
+ );
status.textContent =
generation.error_message || `${capitalize(generation.status)} answer`;
message.appendChild(status);
}
if (turn === state.turns[state.turns.length - 1]) {
- const actions = node("div", "chat-message-actions");
+ const actions = node("div", "session-message-actions");
if (["failed", "stopped", "interrupted"].includes(generation.status)) {
actions.appendChild(button("Retry", "secondary-button", retryMessage));
}
@@ -1425,24 +1359,27 @@
}
function renderLiveAssistant(operation) {
- const message = node("article", "chat-message assistant-message live-message");
- message.appendChild(node("div", "chat-message-label", "Assistant"));
+ const message = node(
+ "article",
+ "session-message assistant-message live-message",
+ );
+ message.appendChild(node("div", "session-message-label", "Assistant"));
if (!operation.segments.length || operation.status !== "Thinking…") {
const status = node(
"p",
- "chat-muted chat-operation-status",
+ "session-muted chat-operation-status",
operation.status,
);
status.setAttribute("aria-live", "polite");
message.appendChild(status);
}
operation.segments.forEach((segment, ordinal) => {
- const content = node("div", "chat-message-plain");
+ const content = node("div", "session-message-plain");
content.dataset.liveSegment = String(ordinal);
content.appendChild(document.createTextNode(segment.text));
if (segment.kind === "thinking") {
const details = document.createElement("details");
- details.className = "chat-thinking";
+ details.className = "session-thinking";
details.open = true;
details.appendChild(node("summary", "", "Thinking"));
details.appendChild(content);
@@ -1458,7 +1395,7 @@
const details = document.createElement("details");
details.className = "chat-compaction";
details.appendChild(node("summary", "", "Earlier conversation compacted"));
- const summary = node("div", "chat-markdown");
+ const summary = node("div", "session-markdown");
summary.innerHTML = state.compaction.summary_html;
details.appendChild(summary);
return details;
@@ -1478,7 +1415,7 @@
return;
const request = { sessionId, before };
state.olderLoad = request;
- const button = scroller.querySelector(".chat-older");
+ const button = scroller.querySelector(".session-older");
if (button) button.disabled = true;
const oldHeight = scroller.scrollHeight;
const isCurrent = () =>
@@ -1514,16 +1451,13 @@
const expectedRevision = state.session.revision;
const routeVersion = state.routeVersion;
try {
- const session = await state.api(
- `/admin/api/chat/sessions/${sessionId}`,
- {
- method: "PATCH",
- body: JSON.stringify({
- expected_revision: expectedRevision,
- ...changes,
- }),
- },
- );
+ const session = await state.api(`/admin/api/chat/sessions/${sessionId}`, {
+ method: "PATCH",
+ body: JSON.stringify({
+ expected_revision: expectedRevision,
+ ...changes,
+ }),
+ });
if (
routeVersion !== state.routeVersion ||
state.session?.id !== sessionId ||
@@ -1536,7 +1470,10 @@
renderSessionPreservingScroll();
scheduleEstimate(true);
} catch (error) {
- if (routeVersion !== state.routeVersion || state.session?.id !== sessionId)
+ if (
+ routeVersion !== state.routeVersion ||
+ state.session?.id !== sessionId
+ )
return;
await reloadSession();
setNotice(error.message, "error");
@@ -1575,7 +1512,7 @@
node("h3", "", "System prompt"),
node(
"p",
- "chat-muted",
+ "session-muted",
"Shared by every Chat Session and applied on the next turn.",
),
);
@@ -1638,7 +1575,8 @@
async function updateEstimate(version) {
const session = state.session;
- if (!session || state.operation || version !== state.estimateVersion) return;
+ if (!session || state.operation || version !== state.estimateVersion)
+ return;
const textarea = document.getElementById("chatComposer");
const revision = session.revision;
const draft = textarea?.value || "";
@@ -1693,7 +1631,10 @@
if (latest?.generation?.status === "running") return "This chat is running";
const option = modelOption(state.session.model);
if (!option) return "Choose an available model";
- if (option.supports_reasoning === false && state.session.reasoning !== "off") {
+ if (
+ option.supports_reasoning === false &&
+ state.session.reasoning !== "off"
+ ) {
return "This model requires Thinking Off";
}
if (state.contextError) return state.contextError;
@@ -1731,15 +1672,15 @@
: state.operation
? ""
: blocked;
- document
+ root()
.querySelectorAll(
- ".chat-controls button, .chat-controls input, .chat-controls select",
+ ".session-controls button, .session-controls input, .session-controls select",
)
.forEach((control) => {
control.disabled = busy || !mutationsReady();
});
- document
- .querySelectorAll(".chat-header-row .danger-button, .chat-title")
+ root()
+ .querySelectorAll(".session-header-row .danger-button, .session-title")
.forEach((control) => {
control.disabled = !mutationsReady();
});
@@ -1807,7 +1748,9 @@
acknowledgement.operation_id !== operation.id ||
acknowledgement.kind !== action
) {
- throw new Error("The server returned an invalid operation acknowledgement.");
+ throw new Error(
+ "The server returned an invalid operation acknowledgement.",
+ );
}
operation.commandPending = false;
operation.serverObserved = true;
@@ -1920,10 +1863,6 @@
}
}
- function nearBottom(scroller) {
- return scroller.scrollHeight - scroller.scrollTop - scroller.clientHeight < 80;
- }
-
function scrollLatest(smooth) {
const scroller = document.getElementById("chatTranscript");
if (!scroller) return;
diff --git a/src/free_claude_code/api/admin_static/code_sessions.css b/src/free_claude_code/api/admin_static/code_sessions.css
new file mode 100644
index 00000000..5e67451f
--- /dev/null
+++ b/src/free_claude_code/api/admin_static/code_sessions.css
@@ -0,0 +1,101 @@
+.code-actions {
+ display: flex;
+ align-items: center;
+ gap: 12px;
+ flex-wrap: wrap;
+}
+.code-folder {
+ color: var(--muted);
+ overflow-wrap: anywhere;
+ margin: 10px 0 0;
+ font-size: 12px;
+}
+.code-notice {
+ color: var(--muted);
+ white-space: pre-wrap;
+}
+.code-notice:empty {
+ display: none;
+}
+.code-tool,
+.code-prompt {
+ border: 1px solid var(--line);
+ border-radius: var(--radius-md);
+ padding: 12px 16px;
+ background: var(--panel);
+}
+.code-tool summary {
+ cursor: pointer;
+ font-weight: 600;
+}
+.code-item-detail,
+.code-prompt pre {
+ white-space: pre-wrap;
+ overflow-wrap: anywhere;
+ margin: 10px 0;
+}
+.code-item[data-kind="tool"] .code-prose {
+ white-space: pre-wrap;
+ font-family: monospace;
+}
+.code-prompt {
+ margin: 12px 0;
+}
+.code-prompt fieldset {
+ border: 0;
+ padding: 0;
+ margin: 12px 0;
+ min-width: 0;
+}
+.code-prompt legend {
+ font-weight: 600;
+ margin-bottom: 8px;
+}
+.code-field {
+ display: grid;
+ gap: 6px;
+ margin: 12px 0;
+}
+.code-field small {
+ color: var(--muted);
+}
+.code-field input:not([type="checkbox"]):not([type="radio"]),
+.code-field select,
+.code-dialog input,
+.code-dialog select {
+ width: 100%;
+ min-height: 40px;
+ border: 1px solid var(--line-strong);
+ border-radius: var(--radius-md);
+ background: var(--input);
+ color: inherit;
+ padding: 8px;
+ font: inherit;
+}
+.code-choice {
+ display: flex;
+ gap: 8px;
+ align-items: baseline;
+ margin: 8px 0;
+ overflow-wrap: anywhere;
+}
+.code-dialog {
+ width: min(520px, calc(100vw - 32px));
+ max-height: 90dvh;
+ overflow: auto;
+ border: 1px solid var(--line-strong);
+ border-radius: var(--radius-lg);
+ background: var(--panel);
+ color: var(--text);
+ padding: 24px;
+}
+.code-dialog::backdrop {
+ background: #0008;
+}
+.code-dialog h3 {
+ margin-top: 0;
+}
+.code-dialog .code-actions {
+ justify-content: flex-end;
+ margin-top: 20px;
+}
diff --git a/src/free_claude_code/api/admin_static/code_sessions.js b/src/free_claude_code/api/admin_static/code_sessions.js
new file mode 100644
index 00000000..4a0055c0
--- /dev/null
+++ b/src/free_claude_code/api/admin_static/code_sessions.js
@@ -0,0 +1,1314 @@
+(() => {
+ "use strict";
+ const UI = window.SessionUI;
+ const modelComboboxes = new Set();
+ let modelControl,
+ reasoningControl,
+ catalog = [],
+ catalogLoaded = false,
+ settingsPending = false;
+ let visibleIds = [],
+ query = "",
+ libraryToken = 0,
+ listFlight = null,
+ listAgain = false,
+ retryTimer = null;
+ let syncNotice = "",
+ availabilityNotice = "";
+ const base = "/admin/api/code";
+ const activeStatuses = new Set(["preparing", "running", "stopping"]);
+ const records = new Map();
+ const deleted = new Set();
+ const sends = new Set();
+ let api,
+ root,
+ feed,
+ epoch,
+ connected = false,
+ synchronized = false;
+ let desiredPath = null,
+ selected = null,
+ rendered = null,
+ syncToken = 0,
+ viewToken = 0;
+ let nextCursor = null,
+ libraryLoading = false,
+ notice = "",
+ available = false;
+
+ function element(tag, text, className) {
+ const node = document.createElement(tag);
+ if (text !== undefined) node.textContent = text;
+ if (className) node.className = className;
+ return node;
+ }
+ function button(text, action, className = "secondary-button") {
+ const node = element("button", text, className);
+ node.type = "button";
+ node.addEventListener("click", action);
+ return node;
+ }
+ function saved(id) {
+ try {
+ return JSON.parse(sessionStorage.getItem(`fcc.code.${id}`)) || {};
+ } catch {
+ return {};
+ }
+ }
+ function save(id, value) {
+ try {
+ sessionStorage.setItem(`fcc.code.${id}`, JSON.stringify(value));
+ } catch {
+ /* This tab still works when browser storage is unavailable. */
+ }
+ }
+ function get(id) {
+ if (!records.has(id))
+ records.set(id, {
+ id,
+ session: null,
+ run: null,
+ version: -1,
+ cursor: -1,
+ items: new Map(),
+ prompts: new Map(),
+ activePrompts: new Map(),
+ runs: new Map(),
+ loaded: false,
+ nextBefore: null,
+ });
+ return records.get(id);
+ }
+ function busy(record) {
+ return activeStatuses.has(record?.run?.status);
+ }
+ function pending(record) {
+ return [...(record?.activePrompts.values() || [])].some(
+ (entry) => entry.active,
+ );
+ }
+
+ function ready(record) {
+ return synchronized && record?.loaded && record.session?.status === "ready";
+ }
+ function mergeEntries(target, entries, version) {
+ for (const value of entries || []) {
+ if ((target.get(value.id)?.version ?? -1) <= version)
+ target.set(value.id, { value, version });
+ }
+ }
+ function merge(data) {
+ if (data.epoch !== epoch) return;
+ const id = data.session_id || data.session?.id;
+ if (!id || deleted.has(id)) return;
+ const record = get(id),
+ version = data.version;
+ if (version >= record.version) {
+ if (!record.session || data.session.revision >= record.session.revision)
+ record.session = data.session;
+ if (
+ record.run?.id !== data.run?.id ||
+ !activeStatuses.has(data.run?.status)
+ )
+ record.runNotice = "";
+ record.run = data.run;
+ record.version = version;
+ record.cursor = Math.max(record.cursor, data.cursor || 0);
+ if (record.run) accepted(id, record.run.id);
+ }
+ mergeEntries(
+ record.runs,
+ [...(data.runs || []), ...(data.run ? [data.run] : [])],
+ version,
+ );
+ mergeEntries(record.items, data.item ? [data.item] : data.items, version);
+ const prompts = data.prompt ? [data.prompt] : data.prompts || [];
+ mergeEntries(record.prompts, prompts, version);
+ for (const prompt of prompts) {
+ if ((record.activePrompts.get(prompt.id)?.version ?? -1) <= version)
+ record.activePrompts.set(prompt.id, {
+ active: ["pending", "answering"].includes(prompt.status),
+ version,
+ });
+ }
+ if (data.active_prompt_ids) {
+ const active = new Set(data.active_prompt_ids);
+ for (const promptId of new Set([
+ ...record.activePrompts.keys(),
+ ...active,
+ ])) {
+ if ((record.activePrompts.get(promptId)?.version ?? -1) <= version)
+ record.activePrompts.set(promptId, {
+ active: active.has(promptId),
+ version,
+ });
+ }
+ }
+ }
+
+ function receive(type, event) {
+ const data = JSON.parse(event.data);
+ if (data.epoch !== epoch) return;
+ const previousRevision = records.get(data.session_id)?.session?.revision;
+ if (type === "session.deleted") {
+ removeDeletedSession(data.session_id, "Session deleted.");
+ } else {
+ merge(data);
+ if (type === "session.notice" && data.session_id === selected)
+ notice = data.message;
+ if (type === "run.notice") {
+ const record = records.get(data.session_id);
+ if (record && busy(record) && data.version >= record.version)
+ record.runNotice = data.will_retry
+ ? `Retrying… ${data.message}`
+ : data.message;
+ }
+ }
+ if (
+ !selected &&
+ (type === "session.deleted" ||
+ data.session?.revision !== previousRevision)
+ )
+ void refreshLibrary();
+ render();
+ }
+
+ async function list(cursor = null) {
+ const requestEpoch = epoch,
+ token = syncToken,
+ route = viewToken,
+ search = query,
+ request = ++libraryToken;
+ const params = new URLSearchParams({ query: search });
+ if (cursor) params.set("cursor", cursor);
+ const data = await api(`${base}/sessions?${params}`);
+ if (
+ requestEpoch !== epoch ||
+ data.epoch !== epoch ||
+ token !== syncToken ||
+ route !== viewToken ||
+ search !== query ||
+ request !== libraryToken
+ )
+ return;
+ const ids = cursor ? [...visibleIds] : [];
+ for (const session of data.sessions) {
+ if (deleted.has(session.id)) continue;
+ const record = get(session.id);
+ if (
+ (!record.session || session.revision >= record.session.revision) &&
+ record.cursor <= data.cursor
+ )
+ record.session = session;
+ if (!ids.includes(session.id)) ids.push(session.id);
+ }
+ visibleIds = ids;
+ nextCursor = data.next_cursor;
+ render();
+ }
+ async function refreshLibrary() {
+ listAgain = true;
+ if (listFlight) return listFlight;
+ listFlight = (async () => {
+ while (listAgain && !selected) {
+ listAgain = false;
+ try {
+ await list();
+ } catch (error) {
+ restart(error.message);
+ break;
+ }
+ }
+ })();
+ try {
+ await listFlight;
+ } finally {
+ listFlight = null;
+ }
+ }
+
+ async function detail(id, before = null) {
+ const requestEpoch = epoch,
+ token = viewToken,
+ connection = syncToken;
+ let data;
+ try {
+ data = await api(
+ `${base}/sessions/${id}${before ? `/items?before=${encodeURIComponent(before)}` : ""}`,
+ );
+ } catch (error) {
+ if (token !== viewToken || connection !== syncToken || selected !== id)
+ return;
+ if (error.status === 404) {
+ removeDeletedSession(id, "This session was deleted.");
+ render();
+ return;
+ }
+ throw error;
+ }
+ if (
+ requestEpoch !== epoch ||
+ data.epoch !== epoch ||
+ token !== viewToken ||
+ connection !== syncToken ||
+ selected !== id ||
+ deleted.has(id)
+ )
+ return;
+ merge(data);
+ const record = get(id);
+ record.loaded = true;
+ record.nextBefore = data.next_before;
+ render();
+ }
+ async function bootstrap() {
+ const token = syncToken;
+ try {
+ const data = await api(`${base}/bootstrap`);
+ if (token !== syncToken || (epoch && data.epoch !== epoch)) return;
+ available = data.available;
+ catalog = data.models;
+ catalogLoaded = true;
+ availabilityNotice = data.message || "";
+ } catch (error) {
+ if (token === syncToken) catalogLoaded = false;
+ throw error;
+ }
+ }
+
+ async function synchronize(readyData) {
+ const token = ++syncToken;
+ synchronized = false;
+ connected = true;
+ clearTimeout(retryTimer);
+ retryTimer = null;
+ if (epoch !== readyData.epoch) {
+ epoch = readyData.epoch;
+ records.clear();
+ deleted.clear();
+ rendered = null;
+ }
+ const included = new Set(
+ readyData.sessions.map((summary) => summary.session_id),
+ );
+ for (const record of records.values()) {
+ if (
+ !included.has(record.id) &&
+ busy(record) &&
+ record.cursor <= readyData.cursor
+ ) {
+ // The run is no longer active; detail supplies its actual outcome.
+ record.run = null;
+ record.runNotice = "";
+ record.loaded = false;
+ record.cursor = readyData.cursor;
+ }
+ }
+ for (const summary of readyData.sessions)
+ merge({ ...summary, cursor: readyData.cursor });
+ render();
+ try {
+ const results = await Promise.allSettled([
+ list(),
+ selected ? detail(selected) : Promise.resolve(),
+ bootstrap(),
+ ]);
+ if (token !== syncToken || !connected) return;
+ for (const result of results)
+ if (result.status === "rejected") throw result.reason;
+ synchronized = true;
+ syncNotice = "";
+ for (const id of records.keys()) if (saved(id).pending) void deliver(id);
+ } catch (error) {
+ if (token === syncToken) restart(error.message);
+ }
+ render();
+ }
+ function restart(message = "Reconnecting…") {
+ if (feed) feed.close();
+ feed = null;
+ connected = false;
+ synchronized = false;
+ ++syncToken;
+ syncNotice = message;
+ if (retryTimer === null)
+ retryTimer = setTimeout(() => {
+ retryTimer = null;
+ connect();
+ }, 1000);
+ render();
+ }
+
+ function connect() {
+ if (feed || retryTimer !== null) return;
+ const source = new EventSource(`${base}/events`);
+ feed = source;
+ source.addEventListener("feed.ready", (event) => {
+ if (feed === source) void synchronize(JSON.parse(event.data));
+ });
+ for (const type of [
+ "session.updated",
+ "session.deleted",
+ "run.updated",
+ "item.updated",
+ "prompt.updated",
+ "session.notice",
+ "run.notice",
+ ])
+ source.addEventListener(type, (event) => {
+ if (feed === source) receive(type, event);
+ });
+ const disconnected = async () => {
+ if (feed !== source) return;
+ restart();
+ // A stopped store cannot open its event feed. Read its availability
+ // so that the retry screen can explain why it is unavailable.
+ try {
+ await bootstrap();
+ render();
+ } catch {
+ /* The scheduled connection retries the reads. */
+ }
+ };
+ source.addEventListener("feed.resync_required", disconnected);
+ source.onerror = disconnected;
+ }
+
+ function replaceDeletedRoute(id) {
+ const view = root?.closest(".admin-view");
+ if (
+ !view ||
+ view.hidden ||
+ window.location.pathname !== `/admin/code/${id}`
+ )
+ return false;
+ history.replaceState({}, "", "/admin/code");
+ return true;
+ }
+ function removeDeletedSession(id, message) {
+ deleted.add(id);
+ records.delete(id);
+ visibleIds = visibleIds.filter((visibleId) => visibleId !== id);
+ const replaced = replaceDeletedRoute(id);
+ if (selected === id || replaced) {
+ activate("/admin/code");
+ notice = message;
+ }
+ }
+ function navigate(id) {
+ const path = id ? `/admin/code/${id}` : "/admin/code";
+ history.pushState({}, "", path);
+ activate(path);
+ }
+ function activate(path) {
+ desiredPath = path;
+ if (!api) return;
+ let id = /^\/admin\/code\/([0-9a-f-]+)$/.exec(path)?.[1] || null;
+ const missing = id !== null && deleted.has(id);
+ if (missing) {
+ replaceDeletedRoute(id);
+ desiredPath = "/admin/code";
+ id = null;
+ }
+ if (id !== selected || !rendered) {
+ selected = id;
+ ++viewToken;
+ rendered = null;
+ settingsPending = false;
+ notice = "";
+ render();
+ if (connected && epoch) {
+ const reading = id ? detail(id) : refreshLibrary();
+ const token = viewToken;
+ void reading.catch((error) => {
+ if (token === viewToken) restart(error.message);
+ });
+ }
+ }
+ if (missing) {
+ notice = "This session was deleted.";
+ render();
+ }
+ connect();
+ }
+
+ function accepted(id, operationId) {
+ const state = saved(id);
+ if (state.pending?.operation_id !== operationId) return;
+ const oldText = state.pending.text;
+ delete state.pending;
+ if (state.draft === oldText) state.draft = "";
+ save(id, state);
+ if (
+ selected === id &&
+ root?.querySelector("#codeComposer")?.value === oldText
+ )
+ root.querySelector("#codeComposer").value = "";
+ }
+ async function deliver(id) {
+ const command = saved(id).pending;
+ if (!command || sends.has(id) || !synchronized) return;
+ sends.add(id);
+ render();
+ try {
+ const receipt = await api(`${base}/sessions/${id}/turns`, {
+ method: "POST",
+ body: JSON.stringify(command),
+ });
+ accepted(id, receipt.id);
+ } catch (error) {
+ const state = saved(id);
+ if (state.pending?.operation_id === command.operation_id) {
+ if (error.status && error.status < 500) {
+ delete state.pending;
+ save(id, state);
+ }
+ if (selected === id) notice = error.message;
+ }
+ if (error.status === 400 || error.status === 409) {
+ try {
+ await bootstrap();
+ } catch (failure) {
+ restart(failure.message);
+ }
+ }
+ } finally {
+ sends.delete(id);
+ render();
+ }
+ }
+ function submit() {
+ const record = records.get(selected);
+ if (
+ !ready(record) ||
+ busy(record) ||
+ pending(record) ||
+ !available ||
+ settingsPending ||
+ selectionError(record)
+ )
+ return;
+ const state = saved(selected),
+ text = root.querySelector("#codeComposer").value;
+ if (!state.pending && !text.trim()) return;
+ state.draft = text;
+ state.pending ||= {
+ operation_id: crypto.randomUUID(),
+ expected_revision: record.session.revision,
+ expected_epoch: epoch,
+ text,
+ };
+ save(selected, state);
+ notice = "";
+ void deliver(selected);
+ }
+ async function stop() {
+ const record = records.get(selected);
+ if (!busy(record)) return;
+ const id = selected,
+ run = record.run.id;
+ try {
+ await api(`${base}/sessions/${id}/stop`, {
+ method: "POST",
+ body: JSON.stringify({ operation_id: run }),
+ });
+ } catch (error) {
+ if (selected === id) notice = error.message;
+ }
+ render();
+ }
+ function dialog(title, build, actionLabel, action) {
+ const node = element("dialog", undefined, "code-dialog"),
+ form = element("form");
+ const heading = element("h3", title),
+ error = element("p", "", "code-notice");
+ heading.id = `code-dialog-${crypto.randomUUID()}`;
+ node.setAttribute("aria-labelledby", heading.id);
+ form.append(heading);
+ const value = build(form);
+ const actions = element("div", undefined, "code-actions");
+ const cancel = button("Cancel", () => node.close());
+ const confirm = button(actionLabel, () => {}, "primary-button");
+ confirm.type = "submit";
+ actions.append(cancel, confirm);
+ form.append(error, actions);
+ node.append(form);
+ node.addEventListener("close", () => node.remove());
+ form.addEventListener("submit", async (event) => {
+ event.preventDefault();
+ confirm.disabled = true;
+ try {
+ await action(value);
+ node.close();
+ } catch (failure) {
+ error.textContent = failure.message;
+ confirm.disabled = false;
+ }
+ });
+ root.append(node);
+ node.showModal();
+ }
+ function newSession() {
+ const id = crypto.randomUUID();
+ dialog(
+ "New code session",
+ (form) => {
+ const harness = element("select");
+ harness.append(new Option("Codex", "codex"));
+ const folder = element("input");
+ folder.required = true;
+ folder.autocomplete = "off";
+ label(form, "Harness", harness);
+ label(form, "Folder", folder);
+ form.append(
+ element(
+ "p",
+ "Choose an existing folder on the computer running FCC.",
+ "code-notice",
+ ),
+ );
+ return folder;
+ },
+ "Create session",
+ async (folder) => {
+ await api(`${base}/sessions`, {
+ method: "POST",
+ body: JSON.stringify({
+ session_id: id,
+ harness: "codex",
+ cwd: folder.value,
+ }),
+ });
+ navigate(id);
+ },
+ );
+ }
+ async function updateSettings(changes) {
+ const id = selected,
+ record = records.get(id);
+ if (!ready(record) || settingsPending) return;
+ settingsPending = true;
+ notice = "";
+ renderControls();
+ try {
+ const session = await api(`${base}/sessions/${id}`, {
+ method: "PATCH",
+ body: JSON.stringify({
+ expected_revision: record.session.revision,
+ ...changes,
+ }),
+ });
+ if (
+ !deleted.has(id) &&
+ session.revision >= (records.get(id)?.session?.revision || 0)
+ )
+ get(id).session = session;
+ } catch (error) {
+ if (selected === id) {
+ notice = error.message;
+ try {
+ await detail(id);
+ } catch (failure) {
+ restart(failure.message);
+ }
+ }
+ } finally {
+ if (selected === id) {
+ settingsPending = false;
+ render();
+ }
+ }
+ }
+ function selectionError(record) {
+ if (!record?.session) return "";
+ if (!catalogLoaded) return "Model list unavailable. Reconnecting…";
+ const model = catalog.find((model) => model.id === record.session.model);
+ if (!model) return "Selected model is unavailable. Choose another model.";
+ if (
+ record.session.reasoning_effort &&
+ !model.reasoning_efforts.includes(record.session.reasoning_effort)
+ )
+ return "Selected thinking effort is unavailable. Choose another effort or Model default.";
+ return "";
+ }
+
+ function remove() {
+ const record = records.get(selected),
+ id = selected,
+ revision = record.session.revision;
+ if (record.session.status === "delete_uncertain") {
+ void api(`${base}/sessions/${id}?expected_revision=${revision}`, {
+ method: "DELETE",
+ }).catch((error) => {
+ notice = error.message;
+ render();
+ });
+ return;
+ }
+ dialog(
+ "Delete session?",
+ (form) => {
+ form.append(
+ element(
+ "p",
+ "This deletes the conversation from FCC and Codex history. Your project files stay in place.",
+ ),
+ );
+ },
+ "Delete session",
+ () =>
+ api(`${base}/sessions/${id}?expected_revision=${revision}`, {
+ method: "DELETE",
+ }),
+ );
+ }
+ function label(parent, title, input, description) {
+ const node = element("label", undefined, "code-field");
+ node.append(element("span", title), input);
+ if (description) node.append(element("small", description));
+ parent.append(node);
+ return node;
+ }
+ function shell() {
+ root.replaceChildren();
+ modelComboboxes.clear();
+ modelControl = reasoningControl = null;
+ const message = element("div", "", "session-notice");
+ message.id = "codeNotice";
+ message.setAttribute("role", "status");
+ if (selected) {
+ const id = selected,
+ record = get(id);
+ const controls = element("div", undefined, "session-controls");
+ modelControl = UI.modelControl(
+ "codeModel",
+ record.session?.model || "",
+ () => catalog.map((model) => model.id),
+ modelComboboxes,
+ (model) => {
+ void updateSettings({ model });
+ },
+ );
+ reasoningControl = UI.reasoningControl(
+ "codeReasoning",
+ [],
+ "",
+ (value) => {
+ void updateSettings({ reasoning_effort: value || null });
+ },
+ );
+ controls.append(modelControl.group, reasoningControl.group);
+ const deletion = button("Delete", remove, "danger-button");
+ deletion.id = "codeDelete";
+ const header = UI.header(
+ "← Code sessions",
+ () => navigate(null),
+ record.session?.title || "Code session",
+ "Code title",
+ (title) => {
+ if (
+ selected === id &&
+ title.value !== records.get(id)?.session?.title
+ )
+ void updateSettings({ title: title.value });
+ },
+ [deletion],
+ controls,
+ );
+ header.append(element("p", "", "code-folder"));
+ const transcript = element("div", undefined, "session-transcript");
+ transcript.id = "codeTranscript";
+ transcript.setAttribute("aria-label", "Conversation");
+ const older = button(
+ "Load older messages",
+ async () => {
+ const oldHeight = transcript.scrollHeight,
+ top = transcript.scrollTop;
+ older.disabled = true;
+ try {
+ await detail(id, records.get(id).nextBefore);
+ if (selected === id)
+ transcript.scrollTop = top + transcript.scrollHeight - oldHeight;
+ } catch (error) {
+ restart(error.message);
+ }
+ older.disabled = false;
+ render();
+ },
+ "secondary-button session-older",
+ );
+ older.id = "codeOlder";
+ transcript.append(
+ older,
+ element("div", undefined, "code-items"),
+ element("div", undefined, "code-prompts"),
+ );
+ const composer = UI.composer(
+ "code",
+ saved(id).draft || "",
+ "Ask Codex to work on this folder…",
+ (value) => {
+ save(id, { ...saved(id), draft: value });
+ renderControls();
+ },
+ submit,
+ () => {
+ void stop();
+ },
+ );
+ root.append(UI.shell(header, message, transcript, composer));
+ UI.resizeComposer(composer.querySelector("textarea"));
+ } else {
+ const create = button("New code session", newSession, "primary-button");
+ create.id = "codeNew";
+ const header = UI.libraryHeader(
+ "Code sessions",
+ "Work with Codex in a project folder.",
+ create,
+ );
+ const search = UI.search("Search titles and folders", query, (value) => {
+ query = value;
+ visibleIds = [];
+ nextCursor = null;
+ ++libraryToken;
+ render();
+ void refreshLibrary();
+ });
+ const more = button(
+ "Load more sessions",
+ async () => {
+ libraryLoading = true;
+ render();
+ try {
+ await list(nextCursor);
+ } catch (error) {
+ restart(error.message);
+ }
+ libraryLoading = false;
+ render();
+ },
+ "secondary-button session-load-more",
+ );
+ more.id = "codeMore";
+ const library = element("div", undefined, "session-list");
+ library.id = "codeLibrary";
+ const wrapper = element("div", undefined, "session-library");
+ wrapper.append(header, search, message, library, more);
+ root.append(wrapper);
+ }
+ rendered = selected || "library";
+ }
+
+ function render() {
+ if (!root) return;
+ if (rendered !== (selected || "library")) shell();
+ const message = root.querySelector("#codeNotice");
+ message.textContent =
+ notice ||
+ availabilityNotice ||
+ syncNotice ||
+ (!connected ? "Connecting…" : !synchronized ? "Synchronizing…" : "");
+ message.hidden = !message.textContent;
+ if (!selected) {
+ const library = root.querySelector("#codeLibrary");
+ for (const child of [...library.children])
+ if (!child.dataset.id || !visibleIds.includes(child.dataset.id))
+ child.remove();
+ for (const record of visibleIds
+ .map((id) => records.get(id))
+ .filter((record) => record?.session)
+ .sort(
+ (a, b) =>
+ b.session.updated_at - a.session.updated_at ||
+ b.id.localeCompare(a.id),
+ )) {
+ let card = library.querySelector(
+ `[data-id="${CSS.escape(record.id)}"]`,
+ );
+ if (!card) {
+ card = UI.card("", "", "", () => navigate(record.id));
+ card.dataset.id = record.id;
+ }
+ card.children[0].textContent = record.session.title;
+ card.children[1].textContent = record.session.cwd;
+ card.children[2].textContent = busy(record)
+ ? "Running"
+ : record.session.error || record.session.model;
+ library.append(card);
+ }
+ if (!library.children.length)
+ library.append(
+ element(
+ "div",
+ synchronized
+ ? query
+ ? "No matching sessions."
+ : "Start your first code session."
+ : "Loading sessions…",
+ "session-empty",
+ ),
+ );
+ root.querySelector("#codeNew").disabled = !synchronized;
+ const more = root.querySelector("#codeMore");
+ more.hidden = !nextCursor;
+ more.disabled = !synchronized || libraryLoading;
+ return;
+ }
+ const record = records.get(selected),
+ title = root.querySelector(".session-title");
+ if (record?.session) {
+ if (document.activeElement !== title) title.value = record.session.title;
+ root.querySelector(".code-folder").textContent = record.session.cwd;
+ }
+ const transcript = root.querySelector("#codeTranscript"),
+ bottom = UI.nearBottom(transcript),
+ items = root.querySelector(".code-items");
+ const runs = [...(record?.runs.values() || [])]
+ .map((entry) => entry.value)
+ .sort((a, b) => a.ordinal - b.ordinal);
+ for (const run of runs) {
+ const source = [...record.items.values()]
+ .map((entry) => entry.value)
+ .filter((item) => item.run_id === run.id)
+ .sort((a, b) => a.sequence - b.sequence);
+ if (!source.length) continue;
+ let group = items.querySelector(`[data-run-id="${CSS.escape(run.id)}"]`);
+ if (!group) {
+ group = element("div", undefined, "code-run");
+ group.dataset.runId = run.id;
+ group.dataset.ordinal = run.ordinal;
+ group.append(
+ element("div", undefined, "code-run-items"),
+ UI.message("assistant", "Codex"),
+ );
+ group.lastChild.classList.add("code-outcome");
+ group.lastChild.append(element("div", "", "session-generation-status"));
+ const next = [...items.children].find(
+ (child) => Number(child.dataset.ordinal) > run.ordinal,
+ );
+ items.insertBefore(group, next || null);
+ }
+ for (const item of source) renderItem(group.firstChild, item);
+ const outcome = group.querySelector(".code-outcome");
+ outcome.hidden = !["failed", "interrupted"].includes(run.status);
+ const status = outcome.querySelector(".session-generation-status");
+ status.className = `session-generation-status ${run.status}`;
+ status.textContent =
+ run.error ||
+ (run.status === "interrupted" ? "Turn stopped." : "This turn failed.");
+ }
+ const prompts = root.querySelector(".code-prompts");
+ for (const { value: prompt } of record?.prompts.values() || [])
+ renderPrompt(prompts, prompt);
+ if (bottom) transcript.scrollTop = transcript.scrollHeight;
+ root.querySelector("#codeOlder").hidden = !record?.nextBefore;
+ renderControls();
+ }
+
+ function renderControls() {
+ if (!selected || !root?.querySelector("#codeComposer")) return;
+ const record = records.get(selected),
+ isBusy = busy(record),
+ input = root.querySelector("#codeComposer");
+ const send = root.querySelector("#codeSend"),
+ stop = root.querySelector("#codeStop");
+ send.hidden = isBusy;
+ stop.hidden = !isBusy;
+ stop.disabled = !connected || record?.run?.stop_requested;
+ send.textContent = saved(selected).pending ? "Retry Send" : "Send";
+ send.disabled =
+ !ready(record) ||
+ !available ||
+ pending(record) ||
+ sends.has(selected) ||
+ settingsPending ||
+ !!selectionError(record) ||
+ (!input.value.trim() && !saved(selected).pending);
+ input.disabled = !record?.loaded || record?.session?.status !== "ready";
+ root.querySelector(".session-title").disabled =
+ !ready(record) || settingsPending;
+ const deletion = root.querySelector("#codeDelete");
+ deletion.textContent =
+ record?.session?.status === "delete_uncertain"
+ ? "Check deletion"
+ : "Delete";
+ deletion.disabled =
+ !synchronized ||
+ !record?.loaded ||
+ record.session?.status === "deleting" ||
+ isBusy ||
+ pending(record);
+ const disabled =
+ !ready(record) ||
+ isBusy ||
+ pending(record) ||
+ settingsPending ||
+ !catalogLoaded;
+ modelControl.update(record?.session?.model || "", disabled);
+ const model = catalog.find((model) => model.id === record?.session?.model),
+ effort = record?.session?.reasoning_effort;
+ const options = [
+ [
+ "",
+ model?.default_reasoning_effort
+ ? `Model default (${model.default_reasoning_effort})`
+ : "Model default",
+ ],
+ ...(model?.reasoning_efforts || []).map((value) => [value, value]),
+ ];
+ if (effort && !model?.reasoning_efforts.includes(effort))
+ options.push([effort, `${effort} (unavailable)`]);
+ reasoningControl.update(options, effort || "");
+ reasoningControl.select.disabled =
+ disabled || !model || (!model.reasoning_efforts.length && !effort);
+ root.querySelector("#codeComposerStatus").textContent =
+ record?.session?.error ||
+ selectionError(record) ||
+ (record?.session?.status !== "ready"
+ ? "Deleting…"
+ : record.run?.stop_requested && isBusy
+ ? "Stopping…"
+ : pending(record)
+ ? "Waiting for input"
+ : isBusy
+ ? record.runNotice || "Working…"
+ : "Codex");
+ for (const node of root.querySelectorAll(".code-prompt")) {
+ const prompt = record?.prompts.get(node.dataset.id)?.value;
+ for (const control of node.querySelectorAll("input, select, button"))
+ control.disabled =
+ !ready(record) ||
+ !record.activePrompts.get(node.dataset.id)?.active ||
+ prompt?.status !== "pending" ||
+ node.dataset.claiming === "true";
+ }
+ UI.resizeComposer(input);
+ }
+
+ function renderItem(parent, item) {
+ let node = parent.querySelector(`[data-id="${CSS.escape(item.id)}"]`);
+ if (!node) {
+ node = UI.message(
+ item.kind === "user" ? "user" : "assistant",
+ item.kind === "user" ? "You" : "Codex",
+ );
+ node.classList.add("code-item");
+ node.dataset.id = item.id;
+ node.dataset.kind = item.kind;
+ let content = node;
+ if (item.kind === "reasoning") {
+ content = UI.thinking();
+ node.append(content);
+ } else if (!["text", "user"].includes(item.kind)) {
+ content = element("details", undefined, "code-tool");
+ content.append(element("summary", item.title || "Tool"));
+ node.append(content);
+ }
+ content.append(
+ element(
+ "div",
+ "",
+ `code-prose ${item.kind === "user" ? "session-message-plain" : "session-markdown"}`,
+ ),
+ element("pre", "", "code-item-detail"),
+ );
+ node.dataset.sequence = item.sequence;
+ const next = [...parent.children].find(
+ (child) => Number(child.dataset.sequence) > item.sequence,
+ );
+ parent.insertBefore(node, next || null);
+ }
+ const content = node.querySelector(".code-prose"),
+ value = item.html ?? item.text;
+ if (node.codeText !== value) {
+ if (item.html != null) content.innerHTML = item.html;
+ else content.textContent = item.text;
+ node.codeText = value;
+ }
+ const detail = node.querySelector(".code-item-detail");
+ detail.textContent = item.detail;
+ detail.hidden = !item.detail;
+ }
+
+ function renderPrompt(parent, prompt) {
+ let node = parent.querySelector(`[data-id="${CSS.escape(prompt.id)}"]`);
+ if (!node) {
+ node = element("form", undefined, "code-prompt");
+ node.dataset.id = prompt.id;
+ node.append(
+ element("h3", prompt.form.title),
+ element("pre", prompt.form.detail || ""),
+ );
+ buildPrompt(node, prompt);
+ node.append(element("p", "", "code-prompt-state"));
+ parent.append(node);
+ }
+ node.querySelector(".code-prompt-state").textContent =
+ prompt.error ||
+ (!records.get(selected)?.activePrompts.get(prompt.id)?.active &&
+ ["pending", "answering"].includes(prompt.status)
+ ? "No longer active"
+ : "") ||
+ {
+ answering: "Answer sent…",
+ resolved: "Resolved",
+ expired: "No longer active",
+ }[prompt.status] ||
+ "";
+ }
+ function buildPrompt(form, prompt) {
+ const sessionId = selected,
+ actions = element("div", undefined, "code-actions");
+ let responseId = null,
+ submitting = false;
+ const answer = async (value) => {
+ if (
+ submitting ||
+ !ready(records.get(sessionId)) ||
+ !records.get(sessionId).activePrompts.get(prompt.id)?.active
+ )
+ return;
+ responseId ||= crypto.randomUUID();
+ submitting = true;
+ form.dataset.claiming = "true";
+ renderControls();
+ try {
+ await api(
+ `${base}/sessions/${sessionId}/prompts/${prompt.id}/responses`,
+ {
+ method: "POST",
+ body: JSON.stringify({ response_id: responseId, answer: value }),
+ },
+ );
+ } catch (error) {
+ form.querySelector(".code-prompt-state").textContent = error.message;
+ } finally {
+ submitting = false;
+ form.dataset.claiming = "false";
+ renderControls();
+ }
+ };
+ form.addEventListener("submit", (event) => event.preventDefault());
+ const choice = (text, value) =>
+ actions.append(
+ button(text, () => {
+ void answer(value);
+ }),
+ );
+ if (prompt.kind === "approval") {
+ for (const item of prompt.form.choices)
+ choice(item.label, { choice: item.id });
+ } else if (prompt.kind === "permissions") {
+ const checks = prompt.form.choices.map((item) => {
+ const input = element("input");
+ input.type = "checkbox";
+ input.value = item.id;
+ const label = element("label", undefined, "code-choice");
+ label.append(input, document.createTextNode(item.label));
+ form.append(label);
+ return input;
+ });
+ const scope = element("select");
+ scope.append(
+ new Option("This turn", "turn"),
+ new Option("This session", "session"),
+ );
+ label(form, "Allow for", scope);
+ actions.append(
+ button("Allow selected", () => {
+ void answer({
+ selected: checks
+ .filter((input) => input.checked)
+ .map((input) => input.value),
+ scope: scope.value,
+ });
+ }),
+ );
+ choice("Decline", { selected: [], scope: "turn" });
+ } else if (prompt.kind === "questions") {
+ const readers = prompt.form.questions.map((question) => {
+ const field = element("fieldset");
+ field.append(element("legend", question.label));
+ form.append(field);
+ if (question.options?.length) {
+ const name = `question-${crypto.randomUUID()}`,
+ radios = [];
+ for (const option of question.options) {
+ const radio = element("input");
+ radio.type = "radio";
+ radio.name = name;
+ radio.value = option.label;
+ radio.required = true;
+ const optionLabel = element("label", undefined, "code-choice");
+ optionLabel.append(
+ radio,
+ document.createTextNode(
+ option.label +
+ (option.description ? ` — ${option.description}` : ""),
+ ),
+ );
+ field.append(optionLabel);
+ radios.push(radio);
+ }
+ let other;
+ if (question.allow_other) {
+ const radio = element("input");
+ radio.type = "radio";
+ radio.name = name;
+ radio.value = "__other__";
+ radios.push(radio);
+ const otherLabel = element("label", undefined, "code-choice");
+ otherLabel.append(radio, document.createTextNode("Other"));
+ field.append(otherLabel);
+ other = element("input");
+ other.type = question.secret ? "password" : "text";
+ other.autocomplete = "off";
+ label(field, "Your answer", other);
+ other.addEventListener("input", () => {
+ radio.checked = true;
+ });
+ }
+ return () => [
+ question.id,
+ [
+ radios.find((radio) => radio.checked)?.value === "__other__"
+ ? other.value
+ : radios.find((radio) => radio.checked)?.value || "",
+ ],
+ ];
+ }
+ const input = element("input");
+ input.type = question.secret ? "password" : "text";
+ input.required = true;
+ input.autocomplete = "off";
+ label(field, question.header || "Your answer", input);
+ return () => [question.id, [input.value]];
+ });
+ actions.append(
+ button(
+ "Submit answers",
+ () => {
+ if (form.reportValidity())
+ void answer({
+ answers: Object.fromEntries(readers.map((read) => read())),
+ });
+ },
+ "primary-button",
+ ),
+ );
+ } else {
+ const readers = [];
+ if (prompt.kind === "url") {
+ try {
+ const url = new URL(prompt.form.url);
+ if (["https:", "http:"].includes(url.protocol)) {
+ const link = element("a", "Open tool request");
+ link.href = url.href;
+ link.target = "_blank";
+ link.rel = "noopener noreferrer";
+ form.append(link);
+ } else throw new Error();
+ } catch {
+ form.append(element("p", "This tool supplied an unsupported link."));
+ }
+ } else if (prompt.form.unsupported)
+ form.append(
+ element(
+ "p",
+ "This tool's form cannot be displayed. Decline or cancel this request.",
+ ),
+ );
+ else
+ for (const field of prompt.form.fields || []) {
+ const input = element(field.options?.length ? "select" : "input");
+ if (field.options?.length) {
+ input.multiple = field.type === "array";
+ if (!input.multiple) input.append(new Option("Choose…", ""));
+ field.options.forEach((option, index) =>
+ input.append(new Option(option.label, String(index))),
+ );
+ } else
+ input.type =
+ field.type === "boolean"
+ ? "checkbox"
+ : ["integer", "number"].includes(field.type)
+ ? "number"
+ : "text";
+ if (input.type === "number")
+ input.step = field.type === "integer" ? "1" : "any";
+ for (const [source, target] of [
+ ["minimum", "min"],
+ ["maximum", "max"],
+ ["minLength", "minLength"],
+ ["maxLength", "maxLength"],
+ ])
+ if (field[source] != null) input[target] = field[source];
+ input.required = field.required && field.type !== "boolean";
+ input.autocomplete = "off";
+ if (field.default != null && !field.options?.length) {
+ if (input.type === "checkbox") input.checked = field.default;
+ else input.value = field.default;
+ }
+ label(form, field.label, input, field.description);
+ readers.push(() => {
+ if (input.type === "checkbox") return [field.id, input.checked];
+ if (!input.value && !field.required) return null;
+ if (field.options?.length)
+ return [
+ field.id,
+ input.multiple
+ ? [...input.selectedOptions].map(
+ (option) => field.options[Number(option.value)].value,
+ )
+ : field.options[Number(input.value)].value,
+ ];
+ return [
+ field.id,
+ input.type === "number" ? Number(input.value) : input.value,
+ ];
+ });
+ }
+ if (!prompt.form.unsupported)
+ actions.append(
+ button(
+ "Submit",
+ () => {
+ if (form.reportValidity())
+ void answer({
+ action: "accept",
+ values: Object.fromEntries(
+ readers.map((read) => read()).filter(Boolean),
+ ),
+ });
+ },
+ "primary-button",
+ ),
+ );
+ choice("Decline", { action: "decline" });
+ choice("Cancel request", { action: "cancel" });
+ }
+ form.append(actions);
+ }
+ window.CodeSessions = {
+ initialize(client) {
+ api = client;
+ root = document.getElementById("codeRoot");
+ if (desiredPath) activate(desiredPath);
+ },
+ activate,
+ async refresh() {
+ if (!api || !epoch) return;
+ try {
+ await bootstrap();
+ render();
+ } catch (error) {
+ restart(error.message);
+ }
+ },
+ };
+ document.addEventListener("pointerdown", (event) => {
+ for (const combobox of modelComboboxes)
+ if (combobox.isOpen && !combobox.element.contains(event.target))
+ combobox.close();
+ });
+})();
diff --git a/src/free_claude_code/api/admin_static/index.html b/src/free_claude_code/api/admin_static/index.html
index ae93ce09..ced5e042 100644
--- a/src/free_claude_code/api/admin_static/index.html
+++ b/src/free_claude_code/api/admin_static/index.html
@@ -7,6 +7,8 @@
<link rel="icon" href="data:," />
<link rel="stylesheet" href="/admin/assets/__FCC_VERSION__/admin.css" />
<link rel="stylesheet" href="/admin/assets/__FCC_VERSION__/chat_sessions.css" />
+ <link rel="stylesheet" href="/admin/assets/__FCC_VERSION__/code_sessions.css" />
+ <link rel="stylesheet" href="/admin/assets/__FCC_VERSION__/session_layout.css" />
</head>
<body>
<div class="app-shell">
@@ -82,7 +84,10 @@
</section>
<section id="view-chat" class="admin-view" data-view="chat" hidden>
- <div id="chatRoot" class="chat-root" aria-live="off"></div>
+ <div id="chatRoot" class="chat-root session-root" aria-live="off"></div>
+ </section>
+ <section id="view-code" class="admin-view" data-view="code" hidden>
+ <div id="codeRoot" class="code-root session-root" aria-live="off"></div>
</section>
</div>
</main>
@@ -99,7 +104,9 @@
</footer>
</div>
<script src="/admin/assets/__FCC_VERSION__/model_combobox.js"></script>
+ <script src="/admin/assets/__FCC_VERSION__/session_ui.js"></script>
<script src="/admin/assets/__FCC_VERSION__/chat_sessions.js"></script>
+ <script src="/admin/assets/__FCC_VERSION__/code_sessions.js"></script>
<script src="/admin/assets/__FCC_VERSION__/admin.js"></script>
</body>
</html>
diff --git a/src/free_claude_code/api/admin_static/session_layout.css b/src/free_claude_code/api/admin_static/session_layout.css
new file mode 100644
index 00000000..2e196390
--- /dev/null
+++ b/src/free_claude_code/api/admin_static/session_layout.css
@@ -0,0 +1,532 @@
+.main.session-main {
+ height: 100dvh;
+ padding: 0;
+ overflow: hidden;
+}
+.session-main .admin-views,
+.session-main .admin-view,
+.session-root {
+ height: 100%;
+ min-height: 0;
+}
+.session-root {
+ padding: 36px clamp(16px, 3vw, 42px) 16px;
+}
+.session-library {
+ height: 100%;
+ overflow: auto;
+}
+.session-markdown table {
+ display: block;
+ overflow-x: auto;
+}
+@media (max-width: 900px) {
+ .app-shell.session-active {
+ height: 100dvh;
+ min-height: 0;
+ overflow: hidden;
+ }
+ .app-shell.session-active .sidebar {
+ flex: 0 0 auto;
+ }
+ .main.session-main {
+ flex: 1 1 0;
+ height: auto;
+ min-height: 0;
+ }
+ .session-root {
+ padding: 24px 20px 12px;
+ }
+}
+@media (max-width: 700px) {
+ .session-root {
+ padding: 16px 12px 8px;
+ }
+}
+@media (max-width: 600px) {
+ .app-shell.session-active .sidebar {
+ padding: 10px 12px;
+ gap: 8px;
+ }
+ .app-shell.session-active .brand {
+ flex-direction: row;
+ justify-content: flex-start;
+ text-align: left;
+ }
+ .app-shell.session-active .brand-mark {
+ width: 34px;
+ height: 34px;
+ }
+ .app-shell.session-active .section-nav {
+ grid-template-columns: repeat(5, minmax(0, 1fr));
+ gap: 4px;
+ }
+ .app-shell.session-active .nav-link {
+ justify-content: center;
+ min-height: 34px;
+ padding: 6px 4px;
+ text-align: center;
+ font-size: 11px;
+ }
+}
+
+.session-shell {
+ height: 100%;
+ min-height: 0;
+}
+
+.session-library-header,
+.session-header-row,
+.session-controls,
+.session-composer-actions,
+.session-message-label {
+ display: flex;
+ align-items: center;
+}
+
+.session-library-header,
+.session-header-row,
+.session-composer-actions,
+.session-message-label {
+ justify-content: space-between;
+}
+
+.session-library-header {
+ gap: 24px;
+ margin: 0 auto 24px;
+ max-width: 920px;
+}
+
+.session-library-header h2 {
+ margin: 0;
+ font-size: 30px;
+}
+
+.session-library-header p,
+.session-card p {
+ color: var(--muted);
+}
+
+.session-library-header p {
+ margin: 7px 0 0;
+}
+
+.session-search,
+.session-list,
+.session-load-more,
+.session-notice {
+ width: 100%;
+ max-width: 920px;
+ margin-left: auto;
+ margin-right: auto;
+}
+
+.session-search,
+.session-load-more {
+ display: block;
+}
+
+.session-search {
+ min-height: 44px;
+ margin-bottom: 16px;
+ border: 1px solid var(--line-strong);
+ border-radius: var(--radius-md);
+ background: var(--input);
+ padding: 10px 14px;
+}
+
+.session-list {
+ display: grid;
+ gap: 10px;
+}
+
+.session-card {
+ display: grid;
+ width: 100%;
+ gap: 7px;
+ border: 1px solid var(--line);
+ border-radius: var(--radius-md);
+ background: var(--panel);
+ padding: 17px 19px;
+ text-align: left;
+ cursor: pointer;
+}
+
+.session-card:hover {
+ border-color: var(--accent-border);
+ background: var(--card-hover);
+}
+
+.session-card p {
+ overflow: hidden;
+ margin: 0;
+ text-overflow: ellipsis;
+ white-space: nowrap;
+}
+
+.session-card span,
+.session-muted {
+ color: var(--muted);
+ font-size: 12px;
+}
+
+.session-card .session-status {
+ color: var(--accent);
+ font-weight: 700;
+}
+
+.session-load-more {
+ margin-top: 18px;
+}
+
+.session-shell {
+ display: grid;
+ grid-template-areas:
+ "header"
+ "notice"
+ "transcript"
+ "composer";
+ grid-template-rows: auto auto minmax(0, 1fr) auto;
+ position: relative;
+}
+
+.session-header {
+ grid-area: header;
+ padding-bottom: 16px;
+ border-bottom: 1px solid var(--line);
+}
+
+.session-header-row {
+ gap: 12px;
+}
+
+.session-title {
+ flex: 1;
+ min-width: 0;
+ border: 1px solid transparent;
+ border-radius: var(--radius-sm);
+ background: transparent;
+ padding: 7px 10px;
+ color: var(--text-strong);
+ font-size: 19px;
+ font-weight: 700;
+}
+
+.session-title:hover,
+.session-title:focus {
+ border-color: var(--line-strong);
+ background: var(--input);
+}
+
+.session-back-button {
+ border: 0;
+ background: transparent;
+ color: var(--muted);
+ cursor: pointer;
+}
+
+.session-back-button:hover {
+ color: var(--text);
+}
+
+.session-controls {
+ flex-wrap: wrap;
+ gap: 10px;
+ margin-top: 14px;
+}
+
+.session-control {
+ display: grid;
+ gap: 5px;
+ color: var(--muted);
+ font-size: 11px;
+ font-weight: 700;
+ letter-spacing: 0.04em;
+ text-transform: uppercase;
+}
+
+.session-control select,
+.session-model-input {
+ min-height: 38px;
+ border: 1px solid var(--line-strong);
+ border-radius: var(--radius-sm);
+ background: var(--input);
+ padding: 7px 10px;
+ color: var(--text);
+ text-transform: none;
+}
+
+.session-model-control {
+ flex: 1 1 360px;
+ max-width: 520px;
+}
+
+.session-model-control .model-combobox input[type="text"] {
+ width: 100%;
+ padding-right: 44px;
+}
+
+.session-model-control .model-combobox {
+ text-transform: none;
+}
+
+.session-model-control .model-combobox-toggle {
+ height: 38px;
+}
+
+.session-controls > button {
+ align-self: end;
+}
+
+.session-notice {
+ grid-area: notice;
+ margin-top: 12px;
+ margin-bottom: 10px;
+ border: 1px solid var(--line);
+ border-radius: var(--radius-sm);
+ padding: 9px 12px;
+ color: var(--muted);
+ font-size: 13px;
+}
+
+.session-notice.error {
+ border-color: var(--error-border);
+ background: var(--error-bg);
+ color: var(--error);
+}
+
+.session-transcript {
+ grid-area: transcript;
+ min-height: 0;
+ overflow-y: auto;
+ overscroll-behavior: contain;
+ padding: 24px 0 30px;
+ scroll-behavior: auto;
+}
+
+.session-message {
+ max-width: 1120px;
+ margin: 0 0 22px;
+ border-radius: var(--radius-lg);
+}
+
+.user-message {
+ margin-left: auto;
+ max-width: min(680px, 88%);
+ background: var(--panel-strong);
+ padding: 14px 17px;
+}
+
+.assistant-message {
+ padding: 2px 4px;
+}
+
+.session-message-label {
+ gap: 12px;
+ margin-bottom: 8px;
+ color: var(--muted);
+ font-size: 12px;
+ font-weight: 700;
+}
+
+.session-message-plain,
+.session-markdown {
+ overflow-wrap: anywhere;
+ line-height: 1.65;
+ white-space: pre-wrap;
+}
+
+.session-markdown {
+ white-space: normal;
+}
+
+.session-markdown > :first-child {
+ margin-top: 0;
+}
+
+.session-markdown > :last-child {
+ margin-bottom: 0;
+}
+
+.session-markdown pre {
+ overflow-x: auto;
+ border: 1px solid var(--line);
+ border-radius: var(--radius-sm);
+ background: var(--input);
+ padding: 13px;
+}
+
+.session-markdown code {
+ border-radius: 4px;
+ background: var(--input);
+ padding: 0.12em 0.3em;
+}
+
+.session-markdown pre code {
+ padding: 0;
+}
+
+.session-markdown a {
+ color: var(--info);
+}
+
+.session-thinking {
+ margin: 12px 0;
+ border-left: 2px solid var(--line-strong);
+ padding: 4px 0 4px 14px;
+ color: var(--muted);
+}
+
+.session-thinking summary {
+ cursor: pointer;
+ font-size: 13px;
+ font-weight: 700;
+}
+
+.session-generation-status {
+ margin-top: 12px;
+ border: 1px solid var(--warn-border);
+ border-radius: var(--radius-sm);
+ background: var(--warn-bg);
+ padding: 9px 11px;
+ color: var(--warn);
+ font-size: 13px;
+}
+
+.session-generation-status.failed {
+ border-color: var(--error-border);
+ background: var(--error-bg);
+ color: var(--error);
+}
+
+.session-message-actions {
+ display: flex;
+ gap: 8px;
+ margin-top: 12px;
+}
+
+.session-composer {
+ grid-area: composer;
+ margin: 8px 0 0;
+ border: 1px solid var(--line-strong);
+ border-radius: var(--radius-lg);
+ background: var(--input);
+ padding: 10px 12px 9px;
+}
+
+.session-composer:focus-within {
+ border-color: var(--accent);
+ background: var(--input-focus);
+ box-shadow: 0 0 0 3px rgba(16, 185, 129, 0.15);
+}
+
+.session-composer textarea {
+ display: block;
+ width: 100%;
+ min-height: calc(3em + 8px);
+ max-height: calc(9em + 8px);
+ resize: none;
+ overflow-y: hidden;
+ border: 0;
+ border-radius: 0;
+ background: transparent;
+ padding: 4px 2px;
+ line-height: 1.5;
+ outline: none;
+}
+
+.session-composer-actions {
+ gap: 12px;
+ margin-top: 4px;
+}
+
+.session-composer-status {
+ color: var(--muted);
+ font-size: 12px;
+}
+
+.session-older {
+ display: block;
+ margin: 0 auto 24px;
+}
+
+.session-empty {
+ display: grid;
+ place-items: center;
+ gap: 8px;
+ min-height: 220px;
+ color: var(--muted);
+ text-align: center;
+}
+
+.session-empty h3,
+.session-empty p {
+ margin: 0;
+}
+
+.session-transcript-empty {
+ min-height: 100%;
+}
+
+.danger-button {
+ min-height: 38px;
+ border: 1px solid var(--error-border);
+ border-radius: var(--radius-sm);
+ background: var(--error-bg);
+ padding: 8px 13px;
+ color: var(--error);
+ cursor: pointer;
+ font-weight: 700;
+}
+
+@media (max-width: 900px) {
+ .session-controls {
+ display: grid;
+ grid-template-columns: 1fr 1fr;
+ }
+
+ .session-model-control {
+ grid-column: 1 / -1;
+ }
+
+ .session-model-control {
+ max-width: none;
+ }
+}
+
+@media (max-width: 700px) {
+ .session-shell {
+ grid-template-rows: auto auto minmax(0, 1fr) auto;
+ }
+
+ .session-library-header {
+ align-items: flex-start;
+ }
+
+ .session-header-row {
+ flex-wrap: wrap;
+ }
+
+ .session-title {
+ order: 3;
+ flex-basis: 100%;
+ }
+
+ .session-controls {
+ grid-template-columns: 1fr;
+ }
+
+ .session-model-control {
+ grid-column: auto;
+ }
+
+ .session-transcript {
+ padding-left: 0;
+ padding-right: 0;
+ }
+
+ .session-composer {
+ margin-left: 0;
+ margin-right: 0;
+ }
+}
diff --git a/src/free_claude_code/api/admin_static/session_ui.js b/src/free_claude_code/api/admin_static/session_ui.js
new file mode 100644
index 00000000..3f6effdd
--- /dev/null
+++ b/src/free_claude_code/api/admin_static/session_ui.js
@@ -0,0 +1,233 @@
+(() => {
+ "use strict";
+ function node(tag, className = "", text = "") {
+ const element = document.createElement(tag);
+ if (className) element.className = className;
+ element.textContent = text;
+ return element;
+ }
+ function button(label, className, action) {
+ const element = node("button", className, label);
+ element.type = "button";
+ element.addEventListener("click", action);
+ return element;
+ }
+ function libraryHeader(title, description, create) {
+ const header = node("header", "session-library-header"),
+ copy = node("div");
+ copy.append(node("h2", "", title), node("p", "", description));
+ header.append(copy, create);
+ return header;
+ }
+ function search(label, value, onChange) {
+ const input = node("input", "session-search");
+ input.type = "search";
+ input.placeholder = label;
+ input.value = value;
+ input.setAttribute("aria-label", label);
+ let timer;
+ input.addEventListener("input", () => {
+ clearTimeout(timer);
+ timer = setTimeout(() => {
+ if (input.isConnected) onChange(input.value);
+ }, 200);
+ });
+ return input;
+ }
+ function card(title, preview, meta, action) {
+ const element = button("", "session-card", action);
+ element.append(
+ node("strong", "", title),
+ node("p", "", preview),
+ node("span", "", meta),
+ );
+ return element;
+ }
+ function shell(header, notice, transcript, composer) {
+ const element = node("div", "session-shell");
+ element.append(header, notice, transcript, composer);
+ return element;
+ }
+ function header(
+ backLabel,
+ back,
+ titleValue,
+ titleLabel,
+ onTitle,
+ actions,
+ controls,
+ ) {
+ const element = node("header", "session-header"),
+ row = node("div", "session-header-row");
+ const title = node("input", "session-title");
+ title.value = titleValue;
+ title.maxLength = 200;
+ title.setAttribute("aria-label", titleLabel);
+ title.addEventListener("blur", () => {
+ if (title.isConnected) onTitle(title);
+ });
+ title.addEventListener("keydown", (event) => {
+ if (event.key === "Enter" && !event.isComposing) title.blur();
+ });
+ row.append(
+ button(backLabel, "session-back-button", back),
+ title,
+ ...actions,
+ );
+ element.append(row, controls);
+ return element;
+ }
+ function modelControl(id, value, values, registry, onSelect) {
+ const group = node("div", "session-control session-model-control"),
+ label = node("label", "", "Model");
+ label.htmlFor = id;
+ const input = node("input", "session-model-input");
+ input.id = id;
+ input.type = "text";
+ input.autocomplete = "off";
+ input.value = value;
+ input.setAttribute("aria-label", "Selected model");
+ let committed = value;
+ const combobox = new window.FccModelCombobox(input, {
+ listboxId: `${id}-options`,
+ label: "model",
+ values,
+ registry,
+ emptyMessage: () =>
+ values().length ? "No matching models." : "No models available.",
+ onSelect: (model) => {
+ committed = model;
+ onSelect(model);
+ },
+ onClose: () => {
+ input.value = committed;
+ },
+ });
+ group.append(label, combobox.element);
+ return {
+ group,
+ input,
+ combobox,
+ update(model, disabled) {
+ committed = model;
+ if (!combobox.isOpen) input.value = model;
+ input.disabled = disabled;
+ combobox.toggle.disabled = disabled;
+ if (disabled) combobox.close();
+ },
+ };
+ }
+ function reasoningControl(id, options, value, onChange) {
+ const group = node("label", "session-control"),
+ select = node("select");
+ select.id = id;
+ const update = (choices, selected) => {
+ const signature = JSON.stringify(choices);
+ if (select.dataset.options !== signature) {
+ select.replaceChildren(
+ ...choices.map(([value, label]) => new Option(label, value)),
+ );
+ select.dataset.options = signature;
+ }
+ select.value = selected;
+ };
+ update(options, value);
+ select.addEventListener("change", () => onChange(select.value));
+ group.append(node("span", "", "Thinking"), select);
+ return { group, select, update };
+ }
+ function composer(id, draft, placeholder, onInput, onSend, onStop) {
+ const element = node("div", "session-composer"),
+ textarea = node("textarea");
+ textarea.id = `${id}Composer`;
+ textarea.rows = 2;
+ textarea.value = draft;
+ textarea.placeholder = placeholder;
+ textarea.setAttribute("aria-label", "Message");
+ const actions = node("div", "session-composer-actions"),
+ status = node("span", "session-composer-status");
+ status.id = `${id}ComposerStatus`;
+ status.setAttribute("aria-live", "polite");
+ const send = button("Send", "primary-button", onSend),
+ stop = button("Stop", "danger-button", onStop);
+ send.id = `${id}Send`;
+ stop.id = `${id}Stop`;
+ stop.hidden = true;
+ textarea.addEventListener("input", () => {
+ resizeComposer(textarea);
+ onInput(textarea.value);
+ });
+ textarea.addEventListener("keydown", (event) => {
+ if (event.key === "Enter" && !event.shiftKey && !event.isComposing) {
+ event.preventDefault();
+ if (!send.disabled && !send.hidden) onSend();
+ }
+ });
+ actions.append(status, send, stop);
+ element.append(textarea, actions);
+ return element;
+ }
+ function message(role, label) {
+ const element = node("article", `session-message ${role}-message`);
+ element.append(node("div", "session-message-label", label));
+ return element;
+ }
+ function thinking() {
+ const element = node("details", "session-thinking");
+ element.append(node("summary", "", "Thinking"));
+ return element;
+ }
+ function resizeComposer(textarea) {
+ textarea.style.height = "auto";
+ textarea.style.height = `${textarea.scrollHeight}px`;
+ textarea.style.overflowY =
+ textarea.scrollHeight > textarea.clientHeight ? "auto" : "hidden";
+ }
+ function nearBottom(scroller) {
+ return (
+ scroller.scrollHeight - scroller.scrollTop - scroller.clientHeight < 80
+ );
+ }
+ function captureSelection(input) {
+ if (!input || document.activeElement !== input) return null;
+ return {
+ start: input.selectionStart,
+ end: input.selectionEnd,
+ direction: input.selectionDirection,
+ };
+ }
+ function restoreSelection(input, selection) {
+ if (!input || input.disabled || !selection) return;
+ input.focus({ preventScroll: true });
+ input.setSelectionRange(
+ Math.min(selection.start, input.value.length),
+ Math.min(selection.end, input.value.length),
+ selection.direction,
+ );
+ }
+ function focusIsUnclaimed() {
+ const active = document.activeElement;
+ return (
+ !active || active === document.body || active === document.documentElement
+ );
+ }
+ window.SessionUI = {
+ node,
+ button,
+ libraryHeader,
+ search,
+ card,
+ shell,
+ header,
+ modelControl,
+ reasoningControl,
+ composer,
+ message,
+ thinking,
+ resizeComposer,
+ nearBottom,
+ captureSelection,
+ restoreSelection,
+ focusIsUnclaimed,
+ };
+})();
diff --git a/src/free_claude_code/api/app.py b/src/free_claude_code/api/app.py
index 45c16488..a61c9cb8 100644
--- a/src/free_claude_code/api/app.py
+++ b/src/free_claude_code/api/app.py
@@ -13,6 +13,13 @@ from free_claude_code.application.chat import (
ChatUnavailableError,
ChatValidationError,
)
+from free_claude_code.application.code_sessions import (
+ CodeConflictError,
+ CodeError,
+ CodeNotFoundError,
+ CodeUnavailableError,
+ CodeValidationError,
+)
from free_claude_code.application.errors import ApplicationError
from free_claude_code.core.anthropic import anthropic_error_payload
from free_claude_code.core.diagnostics import (
@@ -29,6 +36,7 @@ from free_claude_code.core.version import package_version
from .admin_cache import AdminNoStoreMiddleware, attach_admin_no_store
from .admin_routes import router as admin_router
from .chat_routes import router as chat_router
+from .code_sessions_routes import router as code_router
from .ports import ApiServices
from .request_errors import ordinary_application_error_response
from .request_ids import (
@@ -51,6 +59,7 @@ def create_app(services: ApiServices) -> FastAPI:
app.include_router(admin_router)
app.include_router(chat_router)
+ app.include_router(code_router)
app.include_router(router)
@app.exception_handler(ChatError)
@@ -74,6 +83,25 @@ def create_app(services: ApiServices) -> FastAPI:
attach_admin_no_store(response, path=request.url.path)
return response
+ @app.exception_handler(CodeError)
+ async def code_error_handler(request: Request, exc: CodeError):
+ if isinstance(exc, CodeNotFoundError):
+ status_code = 404
+ elif isinstance(exc, CodeConflictError):
+ status_code = 409
+ elif isinstance(exc, CodeValidationError):
+ status_code = 400
+ elif isinstance(exc, CodeUnavailableError):
+ status_code = 503
+ else:
+ status_code = 500
+ response = JSONResponse(
+ status_code=status_code,
+ content={"detail": str(exc), "code": type(exc).__name__},
+ )
+ attach_admin_no_store(response, path=request.url.path)
+ return response
+
@app.exception_handler(RequestValidationError)
async def validation_error_handler(request: Request, exc: RequestValidationError):
"""Log request shape for 422 debugging without content values."""
diff --git a/src/free_claude_code/api/chat_routes.py b/src/free_claude_code/api/chat_routes.py
index 0e3e67a0..d6e3cde8 100644
--- a/src/free_claude_code/api/chat_routes.py
+++ b/src/free_claude_code/api/chat_routes.py
@@ -13,11 +13,9 @@ from free_claude_code.application.chat import (
ChatApplicationPort,
ChatCompaction,
ChatContextEstimate,
- ChatEventOverflowError,
ChatModelOption,
ChatOperationAcknowledgement,
ChatPreferences,
- ChatPublishedEvent,
ChatReasoning,
ChatSession,
ChatSessionSummary,
@@ -25,12 +23,16 @@ from free_claude_code.application.chat import (
ChatUnavailableError,
ChatValidationError,
)
+from free_claude_code.application.session_events import (
+ EventOverflowError,
+ PublishedEvent,
+)
from free_claude_code.core.json_types import JsonObject
from .admin_routes import admin_page_response
from .admin_security import require_loopback_admin
-from .chat_markdown import render_chat_markdown
from .dependencies import get_services
+from .markdown import render_markdown
from .ports import ApiServices
router = APIRouter()
@@ -116,7 +118,7 @@ async def chat_events(
try:
async for event in subscription:
yield _sse_event(event)
- except ChatEventOverflowError as exc:
+ except EventOverflowError as exc:
yield ServerSentEvent(
event="feed.resync_required",
id=str(exc.cursor),
@@ -357,7 +359,7 @@ def _chat(services: ApiServices) -> ChatApplicationPort:
return services.chat
-def _sse_event(event: ChatPublishedEvent) -> ServerSentEvent:
+def _sse_event(event: PublishedEvent) -> ServerSentEvent:
return ServerSentEvent(
event=event.event,
id=str(event.id),
@@ -512,7 +514,7 @@ def _turn_payload(turn: ChatTurn) -> JsonObject:
"ordinal": segment.ordinal,
"kind": segment.kind.value,
"text": segment.text,
- "html": render_chat_markdown(segment.text),
+ "html": render_markdown(segment.text),
}
for segment in generation.segments
],
@@ -526,7 +528,7 @@ def _compaction_payload(compaction: ChatCompaction | None) -> JsonObject | None:
return {
"covered_through_sequence": compaction.covered_through_sequence,
"summary": compaction.summary,
- "summary_html": render_chat_markdown(compaction.summary),
+ "summary_html": render_markdown(compaction.summary),
"estimated_tokens": compaction.estimated_tokens,
"requested_model": compaction.requested_model,
"actual_model": compaction.actual_model,
diff --git a/src/free_claude_code/api/code_sessions_routes.py b/src/free_claude_code/api/code_sessions_routes.py
new file mode 100644
index 00000000..df5b97b2
--- /dev/null
+++ b/src/free_claude_code/api/code_sessions_routes.py
@@ -0,0 +1,350 @@
+"""Local Admin commands, snapshots and SSE for coding conversations."""
+
+import base64
+import json
+from collections.abc import AsyncIterator, Mapping
+from typing import Literal
+
+from fastapi import APIRouter, Depends, Query, Request
+from fastapi.sse import EventSourceResponse, ServerSentEvent
+from pydantic import BaseModel, ConfigDict, Field
+
+from free_claude_code.application.code_sessions import (
+ CodeApplicationPort,
+ CodeDetail,
+ CodeItem,
+ CodePrompt,
+ CodeRun,
+ CodeSession,
+ CodeUnavailableError,
+ CodeValidationError,
+)
+from free_claude_code.application.session_events import EventOverflowError
+from free_claude_code.core.json_types import JsonObject, JsonValue
+
+from .admin_routes import admin_page_response
+from .admin_security import require_loopback_admin
+from .dependencies import get_services
+from .markdown import render_markdown
+from .ports import ApiServices
+
+router = APIRouter(dependencies=[Depends(require_loopback_admin)])
+
+
+class CommandPayload(BaseModel):
+ model_config = ConfigDict(extra="forbid")
+
+
+class CreatePayload(CommandPayload):
+ session_id: str
+ cwd: str = Field(min_length=1, max_length=4096)
+ harness: Literal["codex"] = "codex"
+
+
+class SettingsPayload(CommandPayload):
+ expected_revision: int = Field(gt=0)
+ title: str | None = Field(default=None, min_length=1, max_length=200)
+ model: str | None = Field(default=None, min_length=1)
+ reasoning_effort: str | None = None
+
+
+class SendPayload(CommandPayload):
+ operation_id: str
+ expected_revision: int = Field(gt=0)
+ expected_epoch: str
+ text: str = Field(min_length=1, max_length=1_000_000)
+
+
+class StopPayload(CommandPayload):
+ operation_id: str
+
+
+class AnswerPayload(CommandPayload):
+ response_id: str
+ answer: JsonObject
+
+
+def _code(services: ApiServices) -> CodeApplicationPort:
+ if services.code is None:
+ raise CodeUnavailableError("Code sessions is unavailable in this FCC runtime.")
+ return services.code
+
+
[email protected]("/admin/code", include_in_schema=False)
[email protected]("/admin/code/{session_id}", include_in_schema=False)
+def code_page(request: Request, session_id: str | None = None):
+ return admin_page_response()
+
+
[email protected]("/admin/api/code/bootstrap")
+def bootstrap(services: ApiServices = Depends(get_services)) -> JsonObject:
+ code = _code(services)
+ available, message = code.availability()
+ catalog = code.catalog()
+ return {
+ "available": available,
+ "message": message,
+ "harnesses": [{"id": "codex", "name": "Codex"}],
+ "epoch": code.epoch,
+ "models": [model.model_dump(mode="json") for model in catalog.models],
+ "default_model": catalog.default_model,
+ }
+
+
[email protected]("/admin/api/code/events", response_class=EventSourceResponse)
+async def events(
+ services: ApiServices = Depends(get_services),
+) -> AsyncIterator[ServerSentEvent]:
+ subscription, ready = await _code(services).subscribe()
+ try:
+ summaries = ready.get("sessions")
+ if isinstance(summaries, list):
+ ready = {
+ **ready,
+ "sessions": [
+ _event_payload(value)
+ for value in summaries
+ if isinstance(value, Mapping)
+ ],
+ }
+ yield ServerSentEvent(
+ event="feed.ready", id=str(subscription.cursor), retry=1000, data=ready
+ )
+ try:
+ async for event in subscription:
+ yield ServerSentEvent(
+ event=event.event,
+ id=str(event.id),
+ data={**_event_payload(event.data), "cursor": event.id},
+ )
+ except EventOverflowError as exc:
+ yield ServerSentEvent(
+ event="feed.resync_required",
+ id=str(exc.cursor),
+ data={"cursor": exc.cursor},
+ )
+ finally:
+ await subscription.aclose()
+
+
[email protected]("/admin/api/code/sessions")
+async def list_sessions(
+ cursor: str | None = None,
+ query: str = Query(default="", max_length=4096),
+ limit: int = Query(default=25, ge=1, le=25),
+ services: ApiServices = Depends(get_services),
+) -> JsonObject:
+ code = _code(services)
+ snapshot_cursor = code.cursor
+ page = await code.list_sessions(_decode_cursor(cursor), limit, query)
+ return {
+ "sessions": [_session_payload(session) for session in page.sessions],
+ "next_cursor": _encode_cursor(page.next_cursor),
+ "epoch": code.epoch,
+ "cursor": snapshot_cursor,
+ }
+
+
[email protected]("/admin/api/code/sessions", status_code=201)
+async def create(
+ payload: CreatePayload, services: ApiServices = Depends(get_services)
+) -> JsonObject:
+ return _session_payload(
+ await _code(services).create_session(payload.session_id, payload.cwd)
+ )
+
+
[email protected]("/admin/api/code/sessions/{session_id}")
+async def detail(
+ session_id: str, services: ApiServices = Depends(get_services)
+) -> JsonObject:
+ return _detail_payload(await _code(services).get_detail(session_id))
+
+
[email protected]("/admin/api/code/sessions/{session_id}/items")
+async def older_items(
+ session_id: str,
+ before: str,
+ services: ApiServices = Depends(get_services),
+) -> JsonObject:
+ return _detail_payload(
+ await _code(services).get_detail(session_id, before=_decode_item_cursor(before))
+ )
+
+
[email protected]("/admin/api/code/sessions/{session_id}")
+async def update_settings(
+ session_id: str,
+ payload: SettingsPayload,
+ services: ApiServices = Depends(get_services),
+) -> JsonObject:
+ return _session_payload(
+ await _code(services).update_settings(
+ session_id,
+ payload.expected_revision,
+ payload.model_dump(exclude={"expected_revision"}, exclude_unset=True),
+ )
+ )
+
+
[email protected]("/admin/api/code/sessions/{session_id}", status_code=202)
+async def delete(
+ session_id: str,
+ expected_revision: int = Query(gt=0),
+ services: ApiServices = Depends(get_services),
+) -> JsonObject:
+ session = await _code(services).delete_session(session_id, expected_revision)
+ return {
+ "session_id": session_id,
+ "deleted": session is None,
+ "session": _session_payload(session) if session else None,
+ }
+
+
[email protected]("/admin/api/code/sessions/{session_id}/turns", status_code=202)
+async def send(
+ session_id: str, payload: SendPayload, services: ApiServices = Depends(get_services)
+) -> JsonObject:
+ return _run_payload(
+ await _code(services).send(
+ session_id,
+ payload.operation_id,
+ payload.expected_revision,
+ payload.text,
+ expected_epoch=payload.expected_epoch,
+ )
+ )
+
+
[email protected]("/admin/api/code/sessions/{session_id}/stop", status_code=202)
+async def stop(
+ session_id: str, payload: StopPayload, services: ApiServices = Depends(get_services)
+) -> JsonObject:
+ return _run_payload(await _code(services).stop(session_id, payload.operation_id))
+
+
+ "/admin/api/code/sessions/{session_id}/prompts/{prompt_id}/responses",
+ status_code=202,
+)
+async def answer(
+ session_id: str,
+ prompt_id: str,
+ payload: AnswerPayload,
+ services: ApiServices = Depends(get_services),
+) -> JsonObject:
+ return _prompt_payload(
+ await _code(services).answer(
+ session_id, prompt_id, payload.response_id, payload.answer
+ )
+ )
+
+
+def _session_payload(session: CodeSession) -> JsonObject:
+ return session.model_dump(
+ mode="json", exclude={"native_thread_id", "native_may_have_input", "auto_title"}
+ )
+
+
+def _run_payload(run: CodeRun) -> JsonObject:
+ return run.model_dump(mode="json", exclude={"native_turn_id", "submission_started"})
+
+
+def _item_payload(item: CodeItem) -> JsonObject:
+ return {
+ **item.model_dump(
+ mode="json", exclude={"raw", "native_turn_id", "native_item_id"}
+ ),
+ "html": render_markdown(item.text)
+ if item.kind in {"text", "reasoning"}
+ else None,
+ }
+
+
+def _prompt_payload(prompt: CodePrompt) -> JsonObject:
+ return prompt.model_dump(
+ mode="json",
+ exclude={"raw", "generation", "request_id", "native_turn_id", "native_item_id"},
+ )
+
+
+def _detail_payload(detail: CodeDetail) -> JsonObject:
+ return {
+ "session": _session_payload(detail.session),
+ "run": _run_payload(detail.run) if detail.run else None,
+ "runs": [_run_payload(run) for run in detail.runs],
+ "active_prompt_ids": list(detail.active_prompt_ids),
+ "items": [_item_payload(item) for item in detail.items],
+ "prompts": [_prompt_payload(prompt) for prompt in detail.prompts],
+ "epoch": detail.epoch,
+ "version": detail.version,
+ "cursor": detail.cursor,
+ "next_before": _encode_cursor(detail.next_before),
+ }
+
+
+def _event_payload(data: Mapping[str, JsonValue]) -> JsonObject:
+ result = dict(data)
+ if isinstance(data.get("session"), Mapping):
+ result["session"] = _session_payload(
+ CodeSession.model_validate(data["session"])
+ )
+ if isinstance(data.get("run"), Mapping):
+ result["run"] = _run_payload(CodeRun.model_validate(data["run"]))
+ if isinstance(data.get("item"), Mapping):
+ result["item"] = _item_payload(CodeItem.model_validate(data["item"]))
+ if isinstance(data.get("prompt"), Mapping):
+ result["prompt"] = _prompt_payload(CodePrompt.model_validate(data["prompt"]))
+ items = data.get("items")
+ if isinstance(items, list):
+ result["items"] = [
+ _item_payload(CodeItem.model_validate(value)) for value in items
+ ]
+ prompts = data.get("prompts")
+ runs = data.get("runs")
+ if isinstance(runs, list):
+ result["runs"] = [_run_payload(CodeRun.model_validate(value)) for value in runs]
+ if isinstance(prompts, list):
+ result["prompts"] = [
+ _prompt_payload(CodePrompt.model_validate(value)) for value in prompts
+ ]
+ return result
+
+
+def _encode_cursor(cursor: tuple[int, str] | tuple[int, int] | None) -> str | None:
+ return (
+ base64.urlsafe_b64encode(json.dumps(cursor).encode()).decode()
+ if cursor
+ else None
+ )
+
+
+def _decode_cursor(cursor: str | None) -> tuple[int, str] | None:
+ if cursor is None:
+ return None
+ try:
+ value = json.loads(base64.urlsafe_b64decode(cursor).decode())
+ if (
+ not isinstance(value, list)
+ or len(value) != 2
+ or type(value[0]) is not int
+ or not isinstance(value[1], str)
+ ):
+ raise ValueError
+ return value[0], value[1]
+ except ValueError, UnicodeError:
+ raise CodeValidationError("Invalid session page cursor.") from None
+
+
+def _decode_item_cursor(cursor: str) -> tuple[int, int]:
+ try:
+ value = json.loads(base64.urlsafe_b64decode(cursor).decode())
+ if (
+ not isinstance(value, list)
+ or len(value) != 2
+ or any(type(part) is not int or part < 1 for part in value)
+ ):
+ raise ValueError
+ return value[0], value[1]
+ except ValueError, UnicodeError:
+ raise CodeValidationError("Invalid transcript page cursor.") from None
diff --git a/src/free_claude_code/api/chat_markdown.py b/src/free_claude_code/api/markdown.py
similarity index 90%
rename from src/free_claude_code/api/chat_markdown.py
rename to src/free_claude_code/api/markdown.py
index 8747187f..6b0d6d8b 100644
--- a/src/free_claude_code/api/chat_markdown.py
+++ b/src/free_claude_code/api/markdown.py
@@ -1,4 +1,4 @@
-"""Safe Markdown rendering for locally stored model-authored Chat text."""
+"""Safe Markdown rendering for locally stored model-authored prose."""
from collections.abc import Sequence
from html import escape
@@ -20,7 +20,7 @@ def _safe_http_url(value: object) -> str | None:
return value
-class _ChatRenderer(RendererHTML):
+class _ProseRenderer(RendererHTML):
def link_open(
self,
tokens: Sequence[Token],
@@ -61,11 +61,11 @@ class _ChatRenderer(RendererHTML):
_MARKDOWN = MarkdownIt(
"commonmark",
{"html": False, "linkify": False},
- renderer_cls=_ChatRenderer,
+ renderer_cls=_ProseRenderer,
)
-def render_chat_markdown(value: str) -> str:
+def render_markdown(value: str) -> str:
"""Render model text without raw HTML or active remote images."""
return _MARKDOWN.render(value)
diff --git a/src/free_claude_code/api/ports.py b/src/free_claude_code/api/ports.py
index 7c45a37e..a0b89c4a 100644
--- a/src/free_claude_code/api/ports.py
+++ b/src/free_claude_code/api/ports.py
@@ -5,6 +5,7 @@ from dataclasses import dataclass
from typing import Protocol
from free_claude_code.application.chat import ChatApplicationPort
+from free_claude_code.application.code_sessions import CodeApplicationPort
from free_claude_code.application.connected_accounts import (
ConnectedAccountLoginMode,
ConnectedAccountStatus,
@@ -59,3 +60,4 @@ class ApiServices:
admin: AdminRuntimePort
tasks: TaskController
chat: ChatApplicationPort | None = None
+ code: CodeApplicationPort | None = None
diff --git a/src/free_claude_code/application/chat/__init__.py b/src/free_claude_code/application/chat/__init__.py
index 184ef44f..26f94c66 100644
--- a/src/free_claude_code/application/chat/__init__.py
+++ b/src/free_claude_code/application/chat/__init__.py
@@ -7,7 +7,6 @@ from .models import (
ChatConflictError,
ChatContextEstimate,
ChatError,
- ChatEventOverflowError,
ChatGeneration,
ChatModelOption,
ChatNotFoundError,
@@ -15,7 +14,6 @@ from .models import (
ChatOperationKind,
ChatOperationPhase,
ChatPreferences,
- ChatPublishedEvent,
ChatReasoning,
ChatSegment,
ChatSession,
@@ -40,7 +38,6 @@ __all__ = [
"ChatConflictError",
"ChatContextEstimate",
"ChatError",
- "ChatEventOverflowError",
"ChatEventSubscriptionPort",
"ChatGeneration",
"ChatModelOption",
@@ -49,7 +46,6 @@ __all__ = [
"ChatOperationKind",
"ChatOperationPhase",
"ChatPreferences",
- "ChatPublishedEvent",
"ChatReasoning",
"ChatSegment",
"ChatService",
diff --git a/src/free_claude_code/application/chat/models.py b/src/free_claude_code/application/chat/models.py
index b4ea5af9..83eb9acb 100644
--- a/src/free_claude_code/application/chat/models.py
+++ b/src/free_claude_code/application/chat/models.py
@@ -3,7 +3,6 @@
from dataclasses import dataclass
from enum import StrEnum
-from free_claude_code.core.json_types import JsonObject
from free_claude_code.core.model_capabilities import ModelInputModality
from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy
@@ -207,13 +206,6 @@ class ChatSessionDetail:
context_error: str | None
-@dataclass(frozen=True, slots=True)
-class ChatPublishedEvent:
- event: str
- id: int
- data: JsonObject
-
-
class ChatError(Exception):
"""Base class for application-owned Chat failures."""
@@ -232,11 +224,3 @@ class ChatConflictError(ChatError):
class ChatValidationError(ChatError):
"""The requested Chat operation cannot be executed as supplied."""
-
-
-class ChatEventOverflowError(ChatError):
- """One slow Chat observer must reconnect from a fresh snapshot."""
-
- def __init__(self, cursor: int) -> None:
- super().__init__("Chat event subscription overflowed.")
- self.cursor = cursor
diff --git a/src/free_claude_code/application/chat/ports.py b/src/free_claude_code/application/chat/ports.py
index fe132aaa..65b728f0 100644
--- a/src/free_claude_code/application/chat/ports.py
+++ b/src/free_claude_code/application/chat/ports.py
@@ -3,6 +3,8 @@
from collections.abc import AsyncIterator
from typing import Protocol
+from free_claude_code.application.session_events import PublishedEvent
+
from .models import (
ChatActiveOperation,
ChatCompaction,
@@ -11,7 +13,6 @@ from .models import (
ChatModelOption,
ChatOperationAcknowledgement,
ChatPreferences,
- ChatPublishedEvent,
ChatReasoning,
ChatSegment,
ChatSession,
@@ -173,7 +174,7 @@ class ChatEventSubscriptionPort(Protocol):
cursor: int
- def __aiter__(self) -> AsyncIterator[ChatPublishedEvent]: ...
+ def __aiter__(self) -> AsyncIterator[PublishedEvent]: ...
async def aclose(self) -> None: ...
diff --git a/src/free_claude_code/application/chat/service.py b/src/free_claude_code/application/chat/service.py
index 4d2cf64f..ed9090db 100644
--- a/src/free_claude_code/application/chat/service.py
+++ b/src/free_claude_code/application/chat/service.py
@@ -13,6 +13,7 @@ from loguru import logger
from free_claude_code.application.execution import ProviderExecutor
from free_claude_code.application.ports import RequestRuntimeLease, RequestRuntimePort
from free_claude_code.application.routing import ProviderModelTarget
+from free_claude_code.application.session_events import EventPublisher
from free_claude_code.config.model_refs import (
RETIRED_PROVIDER_IDS,
is_retired_model_ref,
@@ -33,7 +34,6 @@ from .context import (
PreparedChatRequest,
compaction_target_tokens,
)
-from .events import ChatEventPublisher
from .models import (
DEFAULT_CHAT_SYSTEM_PROMPT,
ChatActiveOperation,
@@ -118,7 +118,7 @@ class ChatService:
self._runtime = runtime
self._store = store
self._context = ChatContextBuilder(runtime)
- self._events = ChatEventPublisher()
+ self._events = EventPublisher()
self._active: dict[str, _ActiveOperation] = {}
self._deleting: set[str] = set()
self._active_lock = asyncio.Lock()
diff --git a/src/free_claude_code/application/code_sessions/__init__.py b/src/free_claude_code/application/code_sessions/__init__.py
new file mode 100644
index 00000000..bb6a8523
--- /dev/null
+++ b/src/free_claude_code/application/code_sessions/__init__.py
@@ -0,0 +1,33 @@
+"""Persistent native coding conversations owned by FCC."""
+
+from .models import (
+ CodeConflictError,
+ CodeDetail,
+ CodeError,
+ CodeItem,
+ CodeNotFoundError,
+ CodePage,
+ CodePrompt,
+ CodeRun,
+ CodeSession,
+ CodeUnavailableError,
+ CodeValidationError,
+)
+from .ports import CodeApplicationPort
+from .service import CodeService
+
+__all__ = [
+ "CodeApplicationPort",
+ "CodeConflictError",
+ "CodeDetail",
+ "CodeError",
+ "CodeItem",
+ "CodeNotFoundError",
+ "CodePage",
+ "CodePrompt",
+ "CodeRun",
+ "CodeService",
+ "CodeSession",
+ "CodeUnavailableError",
+ "CodeValidationError",
+]
diff --git a/src/free_claude_code/application/code_sessions/models.py b/src/free_claude_code/application/code_sessions/models.py
new file mode 100644
index 00000000..8d880285
--- /dev/null
+++ b/src/free_claude_code/application/code_sessions/models.py
@@ -0,0 +1,211 @@
+"""FCC-owned coding conversation state and harness-neutral events."""
+
+import time
+from dataclasses import dataclass, field
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from free_claude_code.core.json_types import JsonObject
+
+type RunStatus = Literal[
+ "preparing", "running", "stopping", "completed", "interrupted", "failed"
+]
+ACTIVE_RUN_STATUSES = frozenset({"preparing", "running", "stopping"})
+
+
+def now_ms() -> int:
+ return time.time_ns() // 1_000_000
+
+
+class Record(BaseModel):
+ model_config = ConfigDict(frozen=True, extra="forbid")
+
+
+class CodeSession(Record):
+ id: str
+ cwd: str
+ model: str
+ reasoning_effort: str | None = None
+ harness: Literal["codex"] = "codex"
+ title: str = "New code session"
+ auto_title: bool = True
+ native_thread_id: str | None = None
+ native_may_have_input: bool = False
+ revision: int = 1
+ status: Literal["ready", "deleting", "delete_uncertain"] = "ready"
+ error: str | None = None
+ created_at: int = Field(default_factory=now_ms)
+ updated_at: int = Field(default_factory=now_ms)
+
+
+class CodeRun(Record):
+ id: str
+ session_id: str
+ text: str
+ model: str
+ reasoning_effort: str | None = None
+ ordinal: int = 0
+ status: RunStatus = "preparing"
+ submission_started: bool = False
+ native_turn_id: str | None = None
+ stop_requested: bool = False
+ error: str | None = None
+ error_details: JsonObject = Field(default_factory=dict)
+ created_at: int = Field(default_factory=now_ms)
+ finished_at: int | None = None
+
+
+class CodeItem(Record):
+ id: str
+ session_id: str
+ sequence: int
+ run_id: str
+ native_turn_id: str | None = None
+ native_item_id: str | None = None
+ kind: str
+ title: str = ""
+ text: str = ""
+ detail: str = ""
+ complete: bool = False
+ raw: JsonObject = Field(default_factory=dict)
+
+
+class CodePrompt(Record):
+ id: str
+ session_id: str
+ generation: str
+ request_id: str | int
+ native_turn_id: str | None = None
+ native_item_id: str | None = None
+ kind: str
+ form: JsonObject
+ raw: JsonObject
+ status: Literal["pending", "answering", "resolved", "expired"] = "pending"
+ response_id: str | None = None
+ error: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class CodeDetail:
+ session: CodeSession
+ run: CodeRun | None
+ items: tuple[CodeItem, ...]
+ prompts: tuple[CodePrompt, ...]
+ epoch: str
+ version: int
+ cursor: int
+ next_before: tuple[int, int] | None = None
+ runs: tuple[CodeRun, ...] = ()
+ active_prompt_ids: tuple[str, ...] = ()
+
+
+@dataclass(frozen=True, slots=True)
+class CodeItemPage:
+ items: tuple[CodeItem, ...]
+ runs: tuple[CodeRun, ...]
+ next_before: tuple[int, int] | None = None
+
+
+class CodeModel(Record):
+ id: str
+ display_name: str
+ reasoning_efforts: tuple[str, ...] = ()
+ default_reasoning_effort: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class CodeCatalog:
+ default_model: str
+ models: tuple[CodeModel, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class CodePage:
+ sessions: tuple[CodeSession, ...]
+ next_cursor: tuple[int, str] | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class ItemUpdate:
+ turn_id: str
+ item_id: str
+ kind: str
+ text: str = ""
+ title: str = ""
+ detail: str = ""
+ raw: JsonObject = field(default_factory=dict)
+ complete: bool = False
+ client_id: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class PromptRequest:
+ request_id: str | int
+ kind: str
+ form: JsonObject
+ raw: JsonObject
+ turn_id: str | None = None
+ item_id: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class HarnessEvent:
+ generation: str
+ thread_id: str | None
+ kind: Literal[
+ "turn_started",
+ "turn_completed",
+ "item",
+ "prompt",
+ "resolved",
+ "error",
+ "closed",
+ ]
+ turn_id: str | None = None
+ item: ItemUpdate | None = None
+ prompt: PromptRequest | None = None
+ request_id: str | int | None = None
+ status: RunStatus = "completed"
+ message: str | None = None
+ will_retry: bool = False
+ error_details: JsonObject = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True)
+class NativeTurn:
+ id: str
+ items: tuple[ItemUpdate, ...] = ()
+ status: RunStatus = "completed"
+ error: str | None = None
+ error_details: JsonObject = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True)
+class NativeThread:
+ id: str
+ turns: tuple[NativeTurn, ...] = ()
+
+
+class CodeError(Exception):
+ """A user-facing failure of the coding session application."""
+
+
+class CodeConflictError(CodeError):
+ pass
+
+
+class CodeNotFoundError(CodeError):
+ pass
+
+
+class CodeValidationError(CodeError):
+ pass
+
+
+class CodeUnavailableError(CodeError):
+ pass
+
+
+class NativeHistoryMissing(CodeNotFoundError):
+ """The registered conversation no longer exists in native storage."""
diff --git a/src/free_claude_code/application/code_sessions/ports.py b/src/free_claude_code/application/code_sessions/ports.py
new file mode 100644
index 00000000..11ac946b
--- /dev/null
+++ b/src/free_claude_code/application/code_sessions/ports.py
@@ -0,0 +1,180 @@
+"""Persistence and native execution required by Code sessions."""
+
+from collections.abc import Awaitable, Callable, Sequence
+from typing import Protocol
+
+from free_claude_code.application.session_events import EventSubscription
+from free_claude_code.core.json_types import JsonObject
+
+from .models import (
+ CodeCatalog,
+ CodeDetail,
+ CodeItem,
+ CodeItemPage,
+ CodePage,
+ CodePrompt,
+ CodeRun,
+ CodeSession,
+ HarnessEvent,
+ NativeThread,
+)
+
+type EventSink = Callable[[HarnessEvent], Awaitable[None]]
+
+
+class HarnessConnection(Protocol):
+ generation: str
+ thread_id: str | None
+
+ def supports(self, selection: HarnessSelection) -> bool: ...
+
+ async def create_thread(self) -> NativeThread: ...
+
+ async def resume_thread(self, thread_id: str) -> NativeThread: ...
+
+ async def read_thread(self, thread_id: str) -> NativeThread: ...
+
+ async def start_turn(
+ self, text: str, selection: HarnessSelection, client_id: str
+ ) -> str: ...
+
+ async def interrupt(self, turn_id: str) -> None: ...
+
+ def prepare_answer(
+ self, request_id: str | int, answer: JsonObject
+ ) -> JsonObject: ...
+
+ async def respond(self, request_id: str | int, response: JsonObject) -> None: ...
+
+ async def delete_thread(self, thread_id: str) -> None: ...
+
+ async def close(self) -> None: ...
+
+
+class HarnessSelection(Protocol):
+ @property
+ def model(self) -> str: ...
+
+ @property
+ def reasoning_effort(self) -> str | None: ...
+
+ @property
+ def configuration_key(self) -> str: ...
+
+ async def open(self, cwd: str, sink: EventSink) -> HarnessConnection: ...
+
+
+class HarnessFactory(Protocol):
+ def availability(self) -> tuple[bool, str | None]: ...
+
+ def catalog(self) -> CodeCatalog: ...
+
+ def prepare(self, model: str, reasoning_effort: str | None) -> HarnessSelection: ...
+
+ async def open_history(self, cwd: str, sink: EventSink) -> HarnessConnection: ...
+
+
+class CodeStore(Protocol):
+ async def start(self) -> None: ...
+
+ async def close(self) -> None: ...
+
+ async def create(self, session: CodeSession) -> CodeSession: ...
+
+ async def get_session(self, session_id: str) -> CodeSession: ...
+
+ async def list_sessions(
+ self, cursor: tuple[int, str] | None, limit: int, query: str = ""
+ ) -> CodePage: ...
+
+ async def pending_deletions(self) -> tuple[CodeSession, ...]: ...
+
+ async def is_deleted(self, session_id: str) -> bool: ...
+
+ async def get_run(self, session_id: str, run_id: str) -> CodeRun | None: ...
+
+ async def runs(self, session_id: str) -> tuple[CodeRun, ...]: ...
+
+ async def latest_run(self, session_id: str) -> CodeRun | None: ...
+
+ async def items(
+ self, session_id: str, before: tuple[int, int] | None, limit: int | None
+ ) -> tuple[CodeItem, ...]: ...
+
+ async def prompts(self, session_id: str) -> tuple[CodePrompt, ...]: ...
+
+ async def item_page(
+ self, session_id: str, before: tuple[int, int] | None, limit: int | None
+ ) -> CodeItemPage: ...
+
+ async def update_settings(
+ self, session: CodeSession, expected_revision: int
+ ) -> CodeSession: ...
+
+ async def admit_run(
+ self, session: CodeSession, run: CodeRun, item: CodeItem, expected_revision: int
+ ) -> tuple[CodeSession, CodeRun]: ...
+
+ async def claim_prompt(
+ self, session_id: str, prompt_id: str, response_id: str, generation: str
+ ) -> CodePrompt: ...
+
+ async def save_progress(
+ self,
+ session: CodeSession,
+ expected_revision: int,
+ *,
+ run: CodeRun | None = None,
+ items: Sequence[CodeItem] = (),
+ prompts: Sequence[CodePrompt] = (),
+ ) -> None: ...
+
+ async def delete(self, session_id: str) -> None: ...
+
+
+class CodeApplicationPort(Protocol):
+ @property
+ def epoch(self) -> str: ...
+
+ @property
+ def cursor(self) -> int: ...
+
+ def availability(self) -> tuple[bool, str | None]: ...
+
+ def catalog(self) -> CodeCatalog: ...
+
+ async def create_session(self, session_id: str, cwd: str) -> CodeSession: ...
+
+ async def list_sessions(
+ self, cursor: tuple[int, str] | None = None, limit: int = 25, query: str = ""
+ ) -> CodePage: ...
+
+ async def get_detail(
+ self, session_id: str, *, before: tuple[int, int] | None = None
+ ) -> CodeDetail: ...
+
+ async def subscribe(self) -> tuple[EventSubscription, JsonObject]: ...
+
+ async def update_settings(
+ self, session_id: str, revision: int, changes: JsonObject
+ ) -> CodeSession: ...
+
+ async def send(
+ self,
+ session_id: str,
+ operation_id: str,
+ revision: int,
+ text: str,
+ *,
+ expected_epoch: str,
+ ) -> CodeRun: ...
+
+ async def stop(self, session_id: str, operation_id: str) -> CodeRun: ...
+
+ async def answer(
+ self, session_id: str, prompt_id: str, response_id: str, answer: JsonObject
+ ) -> CodePrompt: ...
+
+ async def delete_session(
+ self, session_id: str, revision: int
+ ) -> CodeSession | None: ...
diff --git a/src/free_claude_code/application/code_sessions/service.py b/src/free_claude_code/application/code_sessions/service.py
new file mode 100644
index 00000000..3aae0609
--- /dev/null
+++ b/src/free_claude_code/application/code_sessions/service.py
@@ -0,0 +1,1298 @@
+"""Server-owned coding sessions, independent of HTTP and browser lifetimes."""
+
+import asyncio
+import uuid
+from collections.abc import Coroutine, Sequence
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from loguru import logger
+
+from free_claude_code.application.session_events import (
+ EventPublisher,
+ EventSubscription,
+)
+from free_claude_code.core.json_types import JsonObject, JsonValue
+
+from .models import (
+ ACTIVE_RUN_STATUSES,
+ CodeCatalog,
+ CodeConflictError,
+ CodeDetail,
+ CodeItem,
+ CodeNotFoundError,
+ CodePage,
+ CodePrompt,
+ CodeRun,
+ CodeSession,
+ CodeUnavailableError,
+ CodeValidationError,
+ HarnessEvent,
+ ItemUpdate,
+ NativeHistoryMissing,
+ NativeThread,
+ RunStatus,
+ now_ms,
+)
+from .ports import CodeStore, HarnessConnection, HarnessFactory, HarnessSelection
+
+
+@dataclass(slots=True)
+class _Owner:
+ session: CodeSession
+ run: CodeRun | None
+ items: dict[str, CodeItem]
+ prompts: dict[str, CodePrompt]
+ runs: dict[str, CodeRun]
+ lock: asyncio.Lock = field(default_factory=asyncio.Lock)
+ finished: asyncio.Event = field(default_factory=asyncio.Event)
+ connection: HarnessConnection | None = None
+ generation: str | None = None
+ version: int = 0
+ sequence: int = 0
+ job: asyncio.Task[None] | None = None
+ flush_task: asyncio.Task[None] | None = None
+ interrupt_task: asyncio.Task[None] | None = None
+ interrupt_for: str | None = None
+ loaded_thread_id: str | None = None
+ dirty: set[str] = field(default_factory=set)
+ known_turns: set[str] = field(default_factory=set)
+ dirty_characters: int = 0
+ storage_failed: bool = False
+ failure_task: asyncio.Task[None] | None = None
+ deleted: bool = False
+
+ @property
+ def busy(self) -> bool:
+ return self.run is not None and self.run.status in ACTIVE_RUN_STATUSES
+
+ @property
+ def pending(self) -> bool:
+ return any(
+ prompt.status in {"pending", "answering"}
+ for prompt in self.prompts.values()
+ )
+
+
+class CodeService:
+ def __init__(self, store: CodeStore, harness: HarnessFactory) -> None:
+ self._store = store
+ self._harness = harness
+ self._owners: dict[str, _Owner] = {}
+ self._load_lock = asyncio.Lock()
+ self._events = EventPublisher()
+ self.epoch = str(uuid.uuid4())
+ self._commands: set[asyncio.Task] = set()
+ self._jobs: set[asyncio.Task] = set()
+ self._accepting = False
+ self._started = False
+ self._message: str | None = "Code sessions is starting."
+ self._close_task: asyncio.Task[None] | None = None
+
+ async def start(self) -> None:
+ if self._started:
+ return
+ try:
+ await self._store.start()
+ self._started = True
+ pending = await self._store.pending_deletions()
+ except Exception as exc:
+ await self._store.close()
+ self._started = False
+ self._message = _error_message(exc)
+ return
+ except BaseException:
+ await self._store.close()
+ raise
+ self._accepting = True
+ self._message = None
+ for session in pending:
+ owner = await self._owner(session.id)
+ owner.finished = asyncio.Event()
+ owner.job = self._job(self._delete_native(owner, reconcile=True))
+
+ def availability(self) -> tuple[bool, str | None]:
+ if not self._accepting:
+ return False, self._message
+ return self._harness.availability()
+
+ def catalog(self) -> CodeCatalog:
+ return self._harness.catalog()
+
+ def begin_shutdown(self) -> None:
+ self._accepting = False
+ self._message = "Code sessions is stopping."
+ self._events.disconnect_subscribers()
+
+ async def close(self) -> None:
+ self.begin_shutdown()
+ if self._close_task is None:
+ self._close_task = asyncio.create_task(self._close(), name="fcc-code-close")
+ await asyncio.shield(self._close_task)
+
+ async def _close(self) -> None:
+ if self._commands:
+ await asyncio.gather(*tuple(self._commands), return_exceptions=True)
+ owners = tuple(self._owners.values())
+ for owner in owners:
+ if owner.busy and owner.run is not None and not owner.storage_failed:
+ try:
+ await self._stop(owner.session.id, owner.run.id, shutting_down=True)
+ except Exception:
+ await self._close_connection(owner)
+ self._storage_failure(owner)
+ jobs = [owner.job for owner in owners if owner.job is not None]
+ if jobs:
+ await asyncio.wait(jobs, timeout=5)
+ await asyncio.gather(*(self._close_connection(owner) for owner in owners))
+ for owner in owners:
+ async with owner.lock:
+ if owner.busy and not owner.storage_failed:
+ try:
+ await self._finish_locked(
+ owner,
+ "interrupted",
+ "FCC stopped before this turn finished.",
+ )
+ except Exception:
+ self._storage_failure(owner)
+ if self._jobs:
+ await asyncio.gather(*tuple(self._jobs), return_exceptions=True)
+ self._events.close()
+ await self._store.close()
+ self._started = False
+ self._message = "Code sessions is stopped."
+
+ async def _command[T](self, work: Coroutine[object, object, T]) -> T:
+ task = asyncio.create_task(work)
+ self._commands.add(task)
+ task.add_done_callback(self._command_done)
+ return await asyncio.shield(task)
+
+ def _command_done(self, task: asyncio.Task) -> None:
+ self._commands.discard(task)
+ if not task.cancelled():
+ task.exception()
+
+ def _job(self, work: Coroutine[object, object, None]) -> asyncio.Task[None]:
+ task = asyncio.create_task(work)
+ self._jobs.add(task)
+ task.add_done_callback(self._job_done)
+ return task
+
+ def _job_done(self, task: asyncio.Task) -> None:
+ self._jobs.discard(task)
+ if not task.cancelled() and (error := task.exception()) is not None:
+ logger.warning(
+ "Code session task failed: exc_type={}", type(error).__name__
+ )
+
+ def _require_available(self) -> None:
+ if not self._accepting:
+ raise CodeUnavailableError(self._message or "Code sessions is unavailable.")
+
+ async def _owner(self, session_id: str) -> _Owner:
+ _validate_id(session_id)
+ async with self._load_lock:
+ owner = self._owners.get(session_id)
+ if owner is None:
+ session = await self._store.get_session(session_id)
+ items = await self._store.items(session_id, None, None)
+ runs = await self._store.runs(session_id)
+ owner = _Owner(
+ session,
+ await self._store.latest_run(session_id),
+ {item.id: item for item in items},
+ {
+ prompt.id: prompt
+ for prompt in await self._store.prompts(session_id)
+ },
+ {run.id: run for run in runs},
+ sequence=max((item.sequence for item in items), default=0),
+ known_turns={
+ item.native_turn_id for item in items if item.native_turn_id
+ },
+ )
+ if owner.run and owner.run.native_turn_id:
+ owner.known_turns.add(owner.run.native_turn_id)
+ if not owner.busy:
+ owner.finished.set()
+ self._owners[session_id] = owner
+ if owner.deleted:
+ raise CodeNotFoundError("Code session was deleted.")
+ return owner
+
+ async def create_session(self, session_id: str, cwd: str) -> CodeSession:
+ return await self._command(self._create(session_id, cwd))
+
+ async def _create(self, session_id: str, cwd: str) -> CodeSession:
+ self._require_available()
+ _validate_id(session_id)
+ try:
+ folder = Path(cwd).expanduser().resolve(strict=True)
+ if not folder.is_dir():
+ raise ValueError
+ except OSError, ValueError, RuntimeError:
+ raise CodeValidationError(
+ "Choose an existing folder on the FCC computer."
+ ) from None
+ session = await self._store.create(
+ CodeSession(
+ id=session_id, cwd=str(folder), model=self.catalog().default_model
+ )
+ )
+ owner = await self._owner(session.id)
+ async with owner.lock:
+ self._publish(owner, "session.updated")
+ return session
+
+ async def list_sessions(
+ self, cursor: tuple[int, str] | None = None, limit: int = 25, query: str = ""
+ ) -> CodePage:
+ return await self._store.list_sessions(cursor, max(1, min(limit, 25)), query)
+
+ async def subscribe(self) -> tuple[EventSubscription, JsonObject]:
+ self._require_available()
+ subscription = self._events.subscribe()
+ summaries = [
+ self._summary(owner)
+ for owner in tuple(self._owners.values())
+ if not owner.deleted
+ and (owner.busy or owner.pending or owner.session.status != "ready")
+ ]
+ return subscription, {
+ "epoch": self.epoch,
+ "cursor": subscription.cursor,
+ "sessions": summaries,
+ }
+
+ @property
+ def cursor(self) -> int:
+ return self._events.cursor
+
+ async def get_detail(
+ self, session_id: str, *, before: tuple[int, int] | None = None
+ ) -> CodeDetail:
+ owner = await self._owner(session_id)
+ async with owner.lock:
+ self._check_owner(owner)
+ await self._flush_locked(owner)
+ page_before = before
+ if owner.busy and owner.run:
+ active_start = (owner.run.ordinal, 0)
+ page_before = min(before, active_start) if before else active_start
+ page = await self._store.item_page(session_id, page_before, 50)
+ active = [
+ item
+ for item in owner.items.values()
+ if owner.busy and owner.run and item.run_id == owner.run.id
+ ]
+ selected = sorted(
+ {item.id: item for item in [*page.items, *active]}.values(),
+ key=lambda item: (owner.runs[item.run_id].ordinal, item.sequence),
+ )
+ turns = {item.native_turn_id for item in selected if item.native_turn_id}
+ if owner.run and owner.run.native_turn_id:
+ turns.add(owner.run.native_turn_id)
+ prompts = tuple(
+ prompt
+ for prompt in owner.prompts.values()
+ if prompt.status in {"pending", "answering"}
+ or prompt.native_turn_id in turns
+ )
+ return CodeDetail(
+ owner.session,
+ owner.run,
+ tuple(selected),
+ prompts,
+ self.epoch,
+ owner.version,
+ self.cursor,
+ page.next_before,
+ tuple(
+ {
+ run.id: run
+ for run in (*page.runs, *((owner.run,) if owner.run else ()))
+ }.values()
+ ),
+ tuple(
+ prompt.id
+ for prompt in owner.prompts.values()
+ if prompt.status in {"pending", "answering"}
+ ),
+ )
+
+ async def update_settings(
+ self, session_id: str, revision: int, changes: JsonObject
+ ) -> CodeSession:
+ return await self._command(self._update_settings(session_id, revision, changes))
+
+ async def _update_settings(
+ self, session_id: str, revision: int, changes: JsonObject
+ ) -> CodeSession:
+ if not changes or changes.keys() - {"title", "model", "reasoning_effort"}:
+ raise CodeValidationError(
+ "Choose a title, model or reasoning effort to update."
+ )
+ owner = await self._owner(session_id)
+ async with owner.lock:
+ self._editable(owner, revision)
+ updates: dict[str, object] = dict(changes)
+ if "title" in changes:
+ title = changes["title"]
+ if not isinstance(title, str) or not title.strip() or len(title) > 200:
+ raise CodeValidationError(
+ "Enter a title of at most 200 characters."
+ )
+ updates.update(title=title.strip(), auto_title=False)
+ if changes.keys() & {"model", "reasoning_effort"}:
+ if owner.busy or owner.pending:
+ raise CodeConflictError(
+ "Finish this turn and its prompts before changing settings."
+ )
+ model = changes.get("model", owner.session.model)
+ entry = next(
+ (entry for entry in self.catalog().models if entry.id == model),
+ None,
+ )
+ if entry is None:
+ raise CodeValidationError(
+ "This model is unavailable. Choose another model."
+ )
+ effort = changes.get("reasoning_effort", owner.session.reasoning_effort)
+ if (
+ "reasoning_effort" not in changes
+ and model != owner.session.model
+ and effort not in entry.reasoning_efforts
+ ):
+ effort = None
+ if effort is not None and effort not in entry.reasoning_efforts:
+ raise CodeValidationError(
+ "This reasoning effort is unavailable. Choose another effort or Model default."
+ )
+ updates.update(model=model, reasoning_effort=effort)
+ session = await self._store.update_settings(
+ _revision(owner.session, **updates), revision
+ )
+ owner.session = session
+ self._publish(owner, "session.updated")
+ return session
+
+ async def send(
+ self,
+ session_id: str,
+ operation_id: str,
+ revision: int,
+ text: str,
+ *,
+ expected_epoch: str,
+ ) -> CodeRun:
+ return await self._command(
+ self._send(session_id, operation_id, revision, text, expected_epoch)
+ )
+
+ async def _send(
+ self,
+ session_id: str,
+ operation_id: str,
+ revision: int,
+ text: str,
+ expected_epoch: str,
+ ) -> CodeRun:
+ _validate_id(operation_id)
+ if not text.strip() or len(text) > 1_000_000:
+ raise CodeValidationError(
+ "Enter a message of at most 1,000,000 characters."
+ )
+ owner = await self._owner(session_id)
+ async with owner.lock:
+ previous = await self._store.get_run(session_id, operation_id)
+ if previous:
+ if previous.session_id != session_id or previous.text != text:
+ raise CodeConflictError(
+ "This Send ID was already used for a different message."
+ )
+ return previous
+ if expected_epoch != self.epoch:
+ raise CodeConflictError(
+ "FCC restarted. Your draft has been kept; send it when you are ready."
+ )
+ self._editable(owner, revision)
+ if owner.busy or owner.pending:
+ raise CodeConflictError(
+ "This session is busy. Your draft has been kept."
+ )
+ selection = self._harness.prepare(
+ owner.session.model, owner.session.reasoning_effort
+ )
+ run = CodeRun(
+ id=operation_id,
+ session_id=session_id,
+ text=text,
+ model=selection.model,
+ reasoning_effort=selection.reasoning_effort,
+ )
+ title = (
+ " ".join(text.split())[:80]
+ if owner.session.auto_title
+ else owner.session.title
+ )
+ session = _revision(
+ owner.session, title=title, auto_title=False, error=None
+ )
+ item = CodeItem(
+ id=operation_id,
+ session_id=session_id,
+ sequence=owner.sequence + 1,
+ run_id=operation_id,
+ kind="user",
+ text=text,
+ complete=True,
+ )
+ session, run = await self._store.admit_run(session, run, item, revision)
+ owner.session, owner.run = session, run
+ owner.runs[run.id] = run
+ owner.items[item.id] = item
+ owner.sequence = item.sequence
+ owner.finished = asyncio.Event()
+ self._publish(owner, "run.updated", items=[item.model_dump(mode="json")])
+ owner.job = self._job(self._work(owner, run.id, selection))
+ return run
+
+ async def stop(self, session_id: str, operation_id: str) -> CodeRun:
+ return await self._command(self._stop(session_id, operation_id))
+
+ async def _stop(
+ self, session_id: str, operation_id: str, *, shutting_down: bool = False
+ ) -> CodeRun:
+ _validate_id(operation_id)
+ owner = await self._owner(session_id)
+ async with owner.lock:
+ run = await self._store.get_run(session_id, operation_id)
+ if run is None or run.session_id != session_id:
+ raise CodeNotFoundError("Code turn not found.")
+ if owner.run is None or owner.run.id != operation_id or not owner.busy:
+ return run
+ if not shutting_down:
+ self._require_available()
+ if not owner.run.stop_requested:
+ run = owner.run.model_copy(
+ update={"stop_requested": True, "status": "stopping"}
+ )
+ await self._persist(owner, owner.session, run=run)
+ owner.run = run
+ self._publish(owner, "run.updated")
+ self._schedule_interrupt(owner)
+ return owner.run
+
+ async def answer(
+ self, session_id: str, prompt_id: str, response_id: str, answer: JsonObject
+ ) -> CodePrompt:
+ return await self._command(
+ self._answer(session_id, prompt_id, response_id, answer)
+ )
+
+ async def _answer(
+ self, session_id: str, prompt_id: str, response_id: str, answer: JsonObject
+ ) -> CodePrompt:
+ _validate_id(response_id)
+ owner = await self._owner(session_id)
+ async with owner.lock:
+ self._require_available()
+ prompt = owner.prompts.get(prompt_id)
+ if prompt is None:
+ raise CodeNotFoundError("This prompt no longer exists.")
+ if prompt.response_id == response_id:
+ return prompt
+ connection = owner.connection
+ if (
+ prompt.status != "pending"
+ or connection is None
+ or prompt.generation != owner.generation
+ ):
+ raise CodeConflictError(
+ "This prompt was already answered or is no longer active."
+ )
+ response = connection.prepare_answer(prompt.request_id, answer)
+ claimed = await self._store.claim_prompt(
+ session_id, prompt_id, response_id, connection.generation
+ )
+ owner.prompts[prompt_id] = claimed
+ self._publish(
+ owner, "prompt.updated", prompt=claimed.model_dump(mode="json")
+ )
+ self._job(self._deliver_answer(owner, claimed, response))
+ return claimed
+
+ async def delete_session(
+ self, session_id: str, revision: int
+ ) -> CodeSession | None:
+ return await self._command(self._delete(session_id, revision))
+
+ async def _delete(self, session_id: str, revision: int) -> CodeSession | None:
+ self._require_available()
+ if await self._store.is_deleted(session_id):
+ return None
+ owner = await self._owner(session_id)
+ async with owner.lock:
+ self._check_owner(owner)
+ if owner.session.status != "ready":
+ if owner.session.status == "delete_uncertain" and (
+ owner.job is None or owner.job.done()
+ ):
+ if revision != owner.session.revision:
+ raise CodeConflictError(
+ "This session changed. Refresh its state and try again."
+ )
+ owner.finished = asyncio.Event()
+ owner.job = self._job(self._delete_native(owner, reconcile=True))
+ return owner.session
+ self._editable(owner, revision)
+ if owner.busy or owner.pending:
+ raise CodeConflictError(
+ "Stop the session and finish its prompts before deleting it."
+ )
+ session = _revision(owner.session, status="deleting", error=None)
+ await self._persist(owner, session)
+ owner.session = session
+ owner.finished = asyncio.Event()
+ self._publish(owner, "session.updated")
+ owner.job = self._job(self._delete_native(owner))
+ return session
+
+ async def wait_idle(self, session_id: str) -> None:
+ """Wait for the currently owned operation, including its durable settlement."""
+ owner = self._owners.get(session_id)
+ if owner is not None:
+ await owner.finished.wait()
+
+ async def _work(
+ self, owner: _Owner, run_id: str, selection: HarnessSelection
+ ) -> None:
+ finished = owner.finished
+ try:
+ connection = owner.connection
+ if connection is not None and not connection.supports(selection):
+ await self._close_connection(owner)
+ connection = None
+ if connection is None:
+ connection = await selection.open(
+ owner.session.cwd, lambda event: self._event(owner, event)
+ )
+ owner.connection = connection
+ owner.generation = connection.generation
+ thread_id = owner.session.native_thread_id
+ if thread_id is None:
+ async with owner.lock:
+ if owner.run and owner.run.stop_requested:
+ await self._finish_locked(owner, "interrupted")
+ return
+ native = await connection.create_thread()
+ elif owner.loaded_thread_id != thread_id:
+ try:
+ native = await connection.resume_thread(thread_id)
+ except NativeHistoryMissing:
+ if owner.session.native_may_have_input:
+ raise
+ native = await connection.create_thread()
+ else:
+ native = None
+ async with owner.lock:
+ if native is not None:
+ session = owner.session.model_copy(
+ update={"native_thread_id": native.id}
+ )
+ await self._persist(owner, session)
+ owner.session = session
+ owner.loaded_thread_id = native.id
+ await self._recover_locked(owner, native)
+ run = owner.run
+ if run is None or run.id != run_id or not owner.busy:
+ return
+ if run.stop_requested or not self._accepting:
+ await self._finish_locked(owner, "interrupted")
+ return
+ run = run.model_copy(update={"submission_started": True})
+ session = owner.session.model_copy(
+ update={"native_may_have_input": True}
+ )
+ await self._persist(owner, session, run=run)
+ owner.session, owner.run = session, run
+ turn_id = await connection.start_turn(run.text, selection, run.id)
+ async with owner.lock:
+ if owner.run is None or owner.run.id != run_id or not owner.busy:
+ return
+ if owner.run.native_turn_id not in {None, turn_id}:
+ raise CodeUnavailableError(
+ "Codex returned a different turn identity."
+ )
+ updated = owner.run.model_copy(
+ update={
+ "native_turn_id": turn_id,
+ "status": "stopping" if owner.run.stop_requested else "running",
+ }
+ )
+ await self._persist(owner, owner.session, run=updated)
+ owner.run = updated
+ owner.known_turns.add(turn_id)
+ self._publish(owner, "run.updated")
+ self._schedule_interrupt(owner)
+ await finished.wait()
+ except asyncio.CancelledError:
+ await self._fail(
+ owner,
+ run_id,
+ "Code session initialization was interrupted.",
+ interrupted=True,
+ )
+ raise
+ except Exception as exc:
+ await self._fail(owner, run_id, _error_message(exc))
+ finally:
+ if not self._accepting or owner.storage_failed:
+ await self._close_connection(owner)
+
+ async def _recover_locked(self, owner: _Owner, native: NativeThread) -> None:
+ mapped: dict[str, CodeRun] = {}
+ for turn in native.turns:
+ identities = {
+ item.client_id
+ for item in turn.items
+ if item.kind == "user" and item.client_id
+ }
+ candidates = [
+ run
+ for run in owner.runs.values()
+ if run.native_turn_id == turn.id or run.id in identities
+ ]
+ if len(candidates) > 1 or any(
+ identity not in owner.runs for identity in identities
+ ):
+ raise CodeUnavailableError(
+ "Codex history contains conflicting turn identities. Saved history was retained."
+ )
+ if candidates:
+ run = candidates[0]
+ if (
+ not run.submission_started
+ or run.native_turn_id not in {None, turn.id}
+ or run.id in {value.id for value in mapped.values()}
+ ):
+ raise CodeUnavailableError(
+ "Codex history could not be matched to its saved turns."
+ )
+ mapped[turn.id] = run
+ unmatched = [turn for turn in native.turns if turn.id not in mapped]
+ pending = [
+ run
+ for run in owner.runs.values()
+ if run.submission_started
+ and run.native_turn_id is None
+ and run.id not in {value.id for value in mapped.values()}
+ ]
+ if unmatched:
+ if len(unmatched) != 1 or len(pending) != 1:
+ raise CodeUnavailableError(
+ "Codex history could not be matched to its saved turns. No input was resent."
+ )
+ mapped[unmatched[0].id] = pending[0]
+ for turn in native.turns:
+ previous = mapped[turn.id]
+ # Restart/connection loss has already settled interrupted work. Recover
+ # source content and missing diagnostics without rewriting that outcome.
+ run = previous.model_copy(
+ update={
+ "native_turn_id": turn.id,
+ "error": previous.error or turn.error,
+ "error_details": previous.error_details or turn.error_details,
+ }
+ )
+ for item in turn.items:
+ self._update_item(owner, item, recovered_run=run)
+ items = tuple(owner.items[item_id] for item_id in owner.dirty)
+ await self._persist(owner, owner.session, run=run, items=items)
+ owner.dirty.clear()
+ owner.dirty_characters = 0
+ owner.known_turns.add(turn.id)
+ if owner.run and owner.run.id == run.id:
+ owner.run = run
+ self._publish(
+ owner,
+ "run.updated",
+ runs=[run.model_dump(mode="json")],
+ items=[item.model_dump(mode="json") for item in items],
+ )
+
+ def _schedule_interrupt(self, owner: _Owner) -> None:
+ run, connection = owner.run, owner.connection
+ if (
+ run is None
+ or connection is None
+ or not run.stop_requested
+ or not run.native_turn_id
+ or not owner.busy
+ or owner.interrupt_for == run.id
+ ):
+ return
+ owner.interrupt_for = run.id
+ owner.interrupt_task = self._job(
+ self._interrupt(owner, connection, run, owner.finished)
+ )
+
+ async def _interrupt(
+ self,
+ owner: _Owner,
+ connection: HarnessConnection,
+ run: CodeRun,
+ finished: asyncio.Event,
+ ) -> None:
+ assert run.native_turn_id is not None
+ try:
+ await connection.interrupt(run.native_turn_id)
+ async with asyncio.timeout(5):
+ await finished.wait()
+ return
+ except Exception:
+ pass
+ async with owner.lock:
+ if (
+ owner.connection is not connection
+ or owner.run is None
+ or owner.run.id != run.id
+ or not owner.busy
+ ):
+ return
+ owner.connection = None
+ owner.generation = None
+ owner.loaded_thread_id = None
+ await connection.close()
+ async with owner.lock:
+ if owner.run and owner.run.id == run.id and owner.busy:
+ await self._finish_locked(
+ owner,
+ "interrupted",
+ "Codex did not stop normally; its session process was closed.",
+ )
+
+ async def _deliver_answer(
+ self, owner: _Owner, prompt: CodePrompt, response: JsonObject
+ ) -> None:
+ connection = owner.connection
+ if connection is None:
+ return
+ try:
+ async with owner.lock:
+ current = owner.prompts.get(prompt.id)
+ if (
+ current is None
+ or current.status != "answering"
+ or owner.generation != prompt.generation
+ ):
+ return
+ await connection.respond(prompt.request_id, response)
+ async with owner.lock:
+ current = owner.prompts.get(prompt.id)
+ if (
+ current is not None
+ and current.status == "answering"
+ and owner.generation == prompt.generation
+ ):
+ resolved = current.model_copy(update={"status": "resolved"})
+ await self._persist(owner, owner.session, prompts=(resolved,))
+ owner.prompts[prompt.id] = resolved
+ self._publish(
+ owner, "prompt.updated", prompt=resolved.model_dump(mode="json")
+ )
+ except CodeConflictError:
+ async with owner.lock:
+ current = owner.prompts.get(prompt.id)
+ if current and current.status == "answering":
+ expired = current.model_copy(update={"status": "expired"})
+ await self._persist(owner, owner.session, prompts=(expired,))
+ owner.prompts[prompt.id] = expired
+ self._publish(
+ owner, "prompt.updated", prompt=expired.model_dump(mode="json")
+ )
+ except Exception as exc:
+ if owner.run and owner.busy:
+ await self._fail(
+ owner,
+ owner.run.id,
+ "The native answer could not be confirmed. It was not resent. "
+ + _error_message(exc),
+ )
+ else:
+ await self._close_connection(owner)
+
+ async def _event(self, owner: _Owner, event: HarnessEvent) -> None:
+ try:
+ async with owner.lock:
+ if (
+ owner.deleted
+ or event.generation != owner.generation
+ or event.thread_id not in {None, owner.session.native_thread_id}
+ ):
+ return
+ if owner.session.status != "ready":
+ return
+ run = owner.run
+ matches = (
+ run is not None
+ and owner.busy
+ and run.submission_started
+ and event.turn_id is not None
+ and (
+ run.native_turn_id == event.turn_id
+ or (
+ run.native_turn_id is None
+ and event.kind == "turn_started"
+ and event.turn_id not in owner.known_turns
+ )
+ )
+ )
+ if (
+ event.kind in {"turn_started", "turn_completed"}
+ and matches
+ and run is not None
+ ):
+ updated = run.model_copy(
+ update={
+ "native_turn_id": event.turn_id,
+ "status": "stopping" if run.stop_requested else "running",
+ }
+ )
+ await self._persist(owner, owner.session, run=updated)
+ owner.run = updated
+ if event.turn_id:
+ owner.known_turns.add(event.turn_id)
+ if event.kind == "turn_completed":
+ await self._finish_locked(
+ owner, event.status, event.message, event.error_details
+ )
+ else:
+ self._publish(owner, "run.updated")
+ self._schedule_interrupt(owner)
+ elif event.kind == "item" and event.item is not None and matches:
+ self._update_item(owner, event.item)
+ if event.item.complete or owner.dirty_characters >= 4096:
+ await self._flush_locked(owner)
+ elif owner.flush_task is None or owner.flush_task.done():
+ owner.flush_task = self._job(self._flush_later(owner))
+ elif event.kind == "prompt" and event.prompt is not None:
+ request = event.prompt
+ if request.turn_id is not None and not matches:
+ return
+ if any(
+ prompt.generation == event.generation
+ and prompt.request_id == request.request_id
+ for prompt in owner.prompts.values()
+ ):
+ return
+ await self._flush_locked(owner)
+ prompt = CodePrompt(
+ id=str(uuid.uuid4()),
+ session_id=owner.session.id,
+ generation=event.generation,
+ request_id=request.request_id,
+ native_turn_id=request.turn_id,
+ native_item_id=request.item_id,
+ kind=request.kind,
+ form=request.form,
+ raw=request.raw,
+ )
+ await self._persist(owner, owner.session, prompts=(prompt,))
+ owner.prompts[prompt.id] = prompt
+ self._publish(
+ owner, "prompt.updated", prompt=prompt.model_dump(mode="json")
+ )
+ elif event.kind == "resolved":
+ for prompt in tuple(owner.prompts.values()):
+ if (
+ prompt.generation == event.generation
+ and prompt.request_id == event.request_id
+ and prompt.status in {"pending", "answering"}
+ ):
+ resolved = prompt.model_copy(update={"status": "resolved"})
+ await self._persist(
+ owner, owner.session, prompts=(resolved,)
+ )
+ owner.prompts[prompt.id] = resolved
+ self._publish(
+ owner,
+ "prompt.updated",
+ prompt=resolved.model_dump(mode="json"),
+ )
+ elif event.kind == "error" and matches:
+ self._publish(
+ owner,
+ "run.notice",
+ message=event.message or "Codex reported an error.",
+ will_retry=event.will_retry,
+ )
+ elif event.kind == "closed":
+ owner.connection = None
+ owner.generation = None
+ owner.loaded_thread_id = None
+ if owner.busy:
+ await self._finish_locked(
+ owner,
+ "interrupted" if run and run.stop_requested else "failed",
+ event.message or "The Codex process ended.",
+ )
+ await self._expire_prompts_locked(owner)
+ except Exception as exc:
+ if owner.run and owner.busy:
+ # Never wait for process teardown from its event dispatcher.
+ self._job(self._fail(owner, owner.run.id, _error_message(exc)))
+ else:
+ logger.warning(
+ "Code event could not be saved: exc_type={}", type(exc).__name__
+ )
+
+ def _update_item(
+ self, owner: _Owner, update: ItemUpdate, *, recovered_run: CodeRun | None = None
+ ) -> None:
+ run = recovered_run or owner.run
+ if run is None:
+ raise CodeUnavailableError("Codex returned output without a saved turn.")
+ historical = recovered_run is not None
+ owner.known_turns.add(update.turn_id)
+ existing = next(
+ (
+ item
+ for item in owner.items.values()
+ if item.native_turn_id == update.turn_id
+ and item.native_item_id == update.item_id
+ ),
+ None,
+ )
+ if existing is None and update.kind == "user":
+ if update.client_id is not None and update.client_id != run.id:
+ raise CodeUnavailableError(
+ "Codex returned a different message identity."
+ )
+ existing = owner.items.get(run.id)
+ if existing is not None and existing.run_id != run.id:
+ raise CodeUnavailableError(
+ "Codex returned output belonging to another turn."
+ )
+ if existing is None:
+ owner.sequence += 1
+ preserve = bool(historical and existing and existing.complete)
+ raw = _merge_source(existing.raw if existing else {}, update.raw, preserve)
+ text = update.text
+ detail = update.detail
+ if historical and existing:
+ text = (existing.text or text) if preserve else (text or existing.text)
+ detail = (
+ (existing.detail or detail) if preserve else (detail or existing.detail)
+ )
+ item = CodeItem(
+ id=existing.id if existing else str(uuid.uuid4()),
+ session_id=owner.session.id,
+ sequence=existing.sequence if existing else owner.sequence,
+ run_id=run.id,
+ native_turn_id=update.turn_id,
+ native_item_id=update.item_id,
+ kind=update.kind,
+ title=update.title or (existing.title if existing else ""),
+ text=text,
+ detail=detail,
+ raw=raw,
+ complete=update.complete or bool(existing and existing.complete),
+ )
+ if item == existing:
+ return
+ owner.items[item.id] = item
+ owner.dirty.add(item.id)
+ owner.dirty_characters += abs(
+ len(item.text) - (len(existing.text) if existing else 0)
+ ) + abs(len(item.detail) - (len(existing.detail) if existing else 0))
+ owner.version += 1
+
+ async def _flush_later(self, owner: _Owner) -> None:
+ await asyncio.sleep(0.25)
+ try:
+ async with owner.lock:
+ if not owner.deleted and not owner.storage_failed:
+ await self._flush_locked(owner)
+ except Exception as exc:
+ if owner.run:
+ await self._fail(owner, owner.run.id, _error_message(exc))
+
+ async def _flush_locked(self, owner: _Owner) -> None:
+ if not owner.dirty:
+ return
+ items = tuple(owner.items[item_id] for item_id in owner.dirty)
+ await self._persist(owner, owner.session, items=items)
+ owner.dirty.clear()
+ owner.dirty_characters = 0
+ for item in sorted(items, key=lambda value: value.sequence):
+ self._publish(owner, "item.updated", item=item.model_dump(mode="json"))
+
+ async def _finish_locked(
+ self,
+ owner: _Owner,
+ status: RunStatus,
+ message: str | None = None,
+ error_details: JsonObject | None = None,
+ ) -> None:
+ if owner.run is None or not owner.busy:
+ return
+ run = owner.run.model_copy(
+ update={
+ "status": status,
+ "error": message,
+ "error_details": error_details or {},
+ "finished_at": now_ms(),
+ }
+ )
+ session = _revision(owner.session, error=None)
+ prompts = tuple(
+ prompt.model_copy(update={"status": "expired"})
+ for prompt in owner.prompts.values()
+ if prompt.status in {"pending", "answering"}
+ and prompt.native_turn_id is not None
+ and prompt.native_turn_id == run.native_turn_id
+ )
+ items = tuple(owner.items[item_id] for item_id in owner.dirty)
+ await self._persist(owner, session, run=run, items=items, prompts=prompts)
+ owner.session, owner.run = session, run
+ owner.prompts.update((prompt.id, prompt) for prompt in prompts)
+ owner.dirty.clear()
+ owner.dirty_characters = 0
+ self._publish(
+ owner,
+ "run.updated",
+ items=[item.model_dump(mode="json") for item in items],
+ prompts=[prompt.model_dump(mode="json") for prompt in prompts],
+ )
+ owner.finished.set()
+
+ async def _expire_prompts_locked(self, owner: _Owner) -> None:
+ prompts = tuple(
+ prompt.model_copy(update={"status": "expired"})
+ for prompt in owner.prompts.values()
+ if prompt.status in {"pending", "answering"}
+ )
+ if not prompts:
+ return
+ await self._persist(owner, owner.session, prompts=prompts)
+ for prompt in prompts:
+ owner.prompts[prompt.id] = prompt
+ self._publish(
+ owner, "prompt.updated", prompt=prompt.model_dump(mode="json")
+ )
+
+ async def _persist(
+ self,
+ owner: _Owner,
+ session: CodeSession,
+ *,
+ run: CodeRun | None = None,
+ items: Sequence[CodeItem] = (),
+ prompts: Sequence[CodePrompt] = (),
+ ) -> None:
+ if owner.storage_failed:
+ raise CodeUnavailableError(
+ "Code storage failed. Restart FCC to restore saved history."
+ )
+ try:
+ await self._store.save_progress(
+ session, owner.session.revision, run=run, items=items, prompts=prompts
+ )
+ if run is not None:
+ owner.runs[run.id] = run
+ except CodeConflictError, CodeNotFoundError:
+ raise
+ except Exception:
+ owner.storage_failed = True
+ if owner.failure_task is None:
+ owner.failure_task = self._job(self._halt_storage(owner))
+ raise
+
+ async def _halt_storage(self, owner: _Owner) -> None:
+ await self._close_connection(owner)
+ self._storage_failure(owner)
+
+ async def _close_connection(self, owner: _Owner) -> None:
+ async with owner.lock:
+ connection = owner.connection
+ owner.connection = None
+ owner.generation = None
+ owner.loaded_thread_id = None
+ if connection is not None:
+ await connection.close()
+ async with owner.lock:
+ if not owner.deleted and not owner.storage_failed:
+ try:
+ if (
+ connection
+ and connection.thread_id
+ and owner.session.native_thread_id is None
+ ):
+ session = owner.session.model_copy(
+ update={"native_thread_id": connection.thread_id}
+ )
+ await self._persist(owner, session)
+ owner.session = session
+ await self._expire_prompts_locked(owner)
+ except Exception:
+ self._storage_failure(owner)
+
+ async def _fail(
+ self, owner: _Owner, run_id: str, message: str, *, interrupted: bool = False
+ ) -> None:
+ async with owner.lock:
+ if owner.run is None or owner.run.id != run_id or not owner.busy:
+ return
+ try:
+ await self._close_connection(owner)
+ async with owner.lock:
+ if owner.run and owner.run.id == run_id and not owner.storage_failed:
+ status = (
+ "interrupted"
+ if interrupted or owner.run.stop_requested
+ else "failed"
+ )
+ await self._finish_locked(owner, status, message)
+ except Exception:
+ self._storage_failure(owner)
+
+ def _storage_failure(self, owner: _Owner) -> None:
+ owner.storage_failed = True
+ owner.finished.set()
+ self._publish(
+ owner,
+ "session.notice",
+ message="Code storage failed. This session was stopped; restart FCC to restore saved history.",
+ )
+
+ async def _delete_native(self, owner: _Owner, *, reconcile: bool = False) -> None:
+ thread_id = owner.session.native_thread_id
+ native_complete = False
+ try:
+ if thread_id is not None:
+ connection = owner.connection
+ if connection is None:
+ connection = await self._harness.open_history(
+ owner.session.cwd, lambda event: self._event(owner, event)
+ )
+ owner.connection, owner.generation = (
+ connection,
+ connection.generation,
+ )
+ try:
+ if reconcile:
+ await connection.read_thread(thread_id)
+ raise CodeConflictError(
+ "The native conversation still exists. You can retry deletion."
+ )
+ await connection.delete_thread(thread_id)
+ except NativeHistoryMissing:
+ pass
+ native_complete = True
+ await self._close_connection(owner)
+ async with owner.lock:
+ await self._store.delete(owner.session.id)
+ owner.deleted = True
+ owner.items.clear()
+ owner.prompts.clear()
+ owner.run = None
+ owner.runs.clear()
+ self._publish(owner, "session.deleted")
+ async with self._load_lock:
+ if self._owners.get(owner.session.id) is owner:
+ del self._owners[owner.session.id]
+ except Exception as exc:
+ await self._close_connection(owner)
+ status = (
+ "ready" if isinstance(exc, CodeConflictError) else "delete_uncertain"
+ )
+ async with owner.lock:
+ session = _revision(
+ owner.session, status=status, error=_error_message(exc)
+ )
+ try:
+ await self._persist(owner, session)
+ except Exception:
+ self._storage_failure(owner)
+ return
+ owner.session = session
+ self._publish(owner, "session.updated")
+ if status == "delete_uncertain" and not reconcile and not native_complete:
+ await self._delete_native(owner, reconcile=True)
+ finally:
+ owner.finished.set()
+
+ def _check_owner(self, owner: _Owner) -> None:
+ if owner.deleted:
+ raise CodeNotFoundError("Code session was deleted.")
+ if owner.storage_failed:
+ raise CodeUnavailableError(
+ "Code storage failed. Restart FCC to restore saved history."
+ )
+
+ def _editable(self, owner: _Owner, revision: int) -> None:
+ self._require_available()
+ self._check_owner(owner)
+ if owner.session.status != "ready" or owner.session.revision != revision:
+ raise CodeConflictError(
+ "This session changed. Refresh its state and try again."
+ )
+
+ def _summary(self, owner: _Owner) -> JsonObject:
+ return {
+ "session_id": owner.session.id,
+ "session": owner.session.model_dump(mode="json"),
+ "run": owner.run.model_dump(mode="json") if owner.run else None,
+ "version": owner.version,
+ "epoch": self.epoch,
+ }
+
+ def _publish(self, owner: _Owner, event: str, **data: JsonValue) -> None:
+ owner.version += 1
+ payload = self._summary(owner)
+ for key, value in data.items():
+ payload[key] = value
+ self._events.publish(event, payload)
+
+
+def _validate_id(value: str) -> None:
+ try:
+ parsed = uuid.UUID(value)
+ if str(parsed) != value or parsed.version != 4:
+ raise ValueError
+ except ValueError, AttributeError:
+ raise CodeValidationError("Invalid session or command ID.") from None
+
+
+def _merge_source(
+ previous: JsonObject, current: JsonObject, preserve: bool
+) -> JsonObject:
+ merged = dict(previous)
+ for key, value in current.items():
+ existing = merged.get(key)
+ if isinstance(existing, dict) and isinstance(value, dict):
+ merged[key] = _merge_source(existing, value, preserve)
+ elif not preserve or existing in (None, "", [], {}):
+ merged[key] = value
+ return merged
+
+
+def _revision(session: CodeSession, **updates: object) -> CodeSession:
+ return session.model_copy(
+ update={"revision": session.revision + 1, "updated_at": now_ms(), **updates}
+ )
+
+
+def _error_message(error: Exception) -> str:
+ if isinstance(
+ error,
+ CodeUnavailableError
+ | CodeValidationError
+ | CodeConflictError
+ | CodeNotFoundError,
+ ):
+ return str(error)
+ return f"The Code session could not continue ({type(error).__name__})."
diff --git a/src/free_claude_code/application/chat/events.py b/src/free_claude_code/application/session_events.py
similarity index 60%
rename from src/free_claude_code/application/chat/events.py
rename to src/free_claude_code/application/session_events.py
index feca8a4e..aa037ad6 100644
--- a/src/free_claude_code/application/chat/events.py
+++ b/src/free_claude_code/application/session_events.py
@@ -1,11 +1,26 @@
-"""Bounded in-process fan-out for observable Chat state changes."""
+"""Bounded in-process fan-out for observable session state changes."""
import asyncio
from collections.abc import AsyncIterator
+from dataclasses import dataclass
from free_claude_code.core.json_types import JsonObject
-from .models import ChatEventOverflowError, ChatPublishedEvent
+
+@dataclass(frozen=True, slots=True)
+class PublishedEvent:
+ event: str
+ id: int
+ data: JsonObject
+
+
+class EventOverflowError(Exception):
+ """One slow observer must reconnect from an authoritative snapshot."""
+
+ def __init__(self, cursor: int) -> None:
+ super().__init__("Session event subscription overflowed.")
+ self.cursor = cursor
+
_DEFAULT_QUEUE_SIZE = 128
@@ -22,15 +37,15 @@ class _Overflow:
self.cursor = cursor
-type _QueueItem = ChatPublishedEvent | _Overflow | _Closed
+type _QueueItem = PublishedEvent | _Overflow | _Closed
-class ChatEventSubscription:
- """One observer's independent view of the process-local Chat feed."""
+class EventSubscription:
+ """One observer's independent view of the process-local session feed."""
def __init__(
self,
- publisher: ChatEventPublisher,
+ publisher: EventPublisher,
*,
cursor: int,
queue_size: int,
@@ -40,17 +55,17 @@ class ChatEventSubscription:
self.cursor = cursor
self._closed = False
- def __aiter__(self) -> AsyncIterator[ChatPublishedEvent]:
+ def __aiter__(self) -> AsyncIterator[PublishedEvent]:
return self._events()
- async def _events(self) -> AsyncIterator[ChatPublishedEvent]:
+ async def _events(self) -> AsyncIterator[PublishedEvent]:
while True:
item = await self._queue.get()
if item is _CLOSED:
return
if isinstance(item, _Overflow):
- raise ChatEventOverflowError(item.cursor)
- if isinstance(item, ChatPublishedEvent):
+ raise EventOverflowError(item.cursor)
+ if isinstance(item, PublishedEvent):
yield item
async def aclose(self) -> None:
@@ -69,21 +84,25 @@ class ChatEventSubscription:
self._queue.put_nowait(item)
-class ChatEventPublisher:
- """Publish without allowing one observer to backpressure Chat work."""
+class EventPublisher:
+ """Publish without allowing one observer to backpressure session work."""
def __init__(self, *, queue_size: int = _DEFAULT_QUEUE_SIZE) -> None:
if queue_size <= 0:
- raise ValueError("Chat event queue size must be positive.")
+ raise ValueError("session event queue size must be positive.")
self._queue_size = queue_size
self._sequence = 0
- self._subscriptions: set[ChatEventSubscription] = set()
+ self._subscriptions: set[EventSubscription] = set()
self._closed = False
- def subscribe(self) -> ChatEventSubscription:
+ @property
+ def cursor(self) -> int:
+ return self._sequence
+
+ def subscribe(self) -> EventSubscription:
if self._closed:
- raise RuntimeError("Chat event publisher is closed.")
- subscription = ChatEventSubscription(
+ raise RuntimeError("session event publisher is closed.")
+ subscription = EventSubscription(
self,
cursor=self._sequence,
queue_size=self._queue_size,
@@ -91,11 +110,11 @@ class ChatEventPublisher:
self._subscriptions.add(subscription)
return subscription
- def publish(self, event: str, data: JsonObject) -> ChatPublishedEvent:
+ def publish(self, event: str, data: JsonObject) -> PublishedEvent:
if self._closed:
- raise RuntimeError("Chat event publisher is closed.")
+ raise RuntimeError("session event publisher is closed.")
self._sequence += 1
- published = ChatPublishedEvent(event=event, id=self._sequence, data={**data})
+ published = PublishedEvent(event=event, id=self._sequence, data={**data})
for subscription in tuple(self._subscriptions):
try:
subscription._queue.put_nowait(published)
@@ -104,7 +123,7 @@ class ChatEventPublisher:
subscription.signal(_Overflow(self._sequence))
return published
- def unsubscribe(self, subscription: ChatEventSubscription) -> None:
+ def unsubscribe(self, subscription: EventSubscription) -> None:
self._subscriptions.discard(subscription)
def close(self) -> None:
diff --git a/src/free_claude_code/cli/launchers/codex.py b/src/free_claude_code/cli/launchers/codex.py
index d26b69b2..05f87052 100644
--- a/src/free_claude_code/cli/launchers/codex.py
+++ b/src/free_claude_code/cli/launchers/codex.py
@@ -50,7 +50,7 @@ def codex_config_args(*, api_url: str, model: str | None = None) -> list[str]:
]
-def _configure(
+def prepare_codex_launch(
ctx: LaunchContext, args: list[str], files: LaunchResources
) -> PreparedLaunch:
catalog_path = files.write_json(
@@ -81,7 +81,7 @@ SPEC = HarnessSpec(
binary_name="codex",
display_name="Codex CLI",
install_hint="Install Codex with: npm install -g @openai/codex",
- configure=_configure,
+ configure=prepare_codex_launch,
catalog_view="responses",
)
diff --git a/src/free_claude_code/config/paths.py b/src/free_claude_code/config/paths.py
index 6021c1b8..0b97f168 100644
--- a/src/free_claude_code/config/paths.py
+++ b/src/free_claude_code/config/paths.py
@@ -19,6 +19,9 @@ LAUNCHER_TEMP_DIRNAME = "launchers"
CHAT_STATE_DIRNAME = "chat"
CHAT_DATABASE_FILENAME = "chat.db"
CHAT_LOCK_FILENAME = "chat.lock"
+CODE_STATE_DIRNAME = "code"
+CODE_DATABASE_FILENAME = "code.db"
+CODE_LOCK_FILENAME = "code.lock"
def config_dir_path() -> Path:
@@ -63,6 +66,16 @@ def chat_lock_path() -> Path:
return chat_state_dir_path() / CHAT_LOCK_FILENAME
+def code_database_path() -> Path:
+ """Return the managed Code sessions database path."""
+ return config_dir_path() / CODE_STATE_DIRNAME / CODE_DATABASE_FILENAME
+
+
+def code_lock_path() -> Path:
+ """Return the exclusive Code sessions process-lock path."""
+ return config_dir_path() / CODE_STATE_DIRNAME / CODE_LOCK_FILENAME
+
+
def legacy_env_paths() -> tuple[Path, ...]:
"""Return legacy user env paths that can be migrated to ~/.fcc/.env."""
diff --git a/src/free_claude_code/runtime/application.py b/src/free_claude_code/runtime/application.py
index b4ff500d..3845b87f 100644
--- a/src/free_claude_code/runtime/application.py
+++ b/src/free_claude_code/runtime/application.py
@@ -15,6 +15,7 @@ import free_claude_code.cli.managed as cli_managed
import free_claude_code.messaging.session as messaging_session
import free_claude_code.messaging.workflow as messaging_workflow_module
from free_claude_code.application.chat import ChatService
+from free_claude_code.application.code_sessions import CodeService
from free_claude_code.application.connected_accounts import (
ConnectedAccountLoginMode,
ConnectedAccountPort,
@@ -140,12 +141,14 @@ class ApplicationRuntime:
configuration: ConfigurationService,
transcriber: Transcriber | None,
chat_service: ChatService | None = None,
+ code_service: CodeService | None = None,
restart_callback: RestartCallback | None = None,
connected_accounts: Mapping[str, ConnectedAccountPort] | None = None,
) -> None:
self.provider_manager = provider_manager
self._configuration = configuration
self._chat_service = chat_service
+ self._code_service = code_service
self._transcriber = transcriber
self._restart_callback = restart_callback
self._connected_accounts = dict(connected_accounts or {})
@@ -198,6 +201,8 @@ class ApplicationRuntime:
self.provider_manager.start_model_list_refresh()
if self._chat_service is not None:
await self._chat_service.start()
+ if self._code_service is not None:
+ await self._code_service.start()
await self._start_messaging_if_configured()
if self._draining:
raise ApplicationUnavailableError(
@@ -223,6 +228,8 @@ class ApplicationRuntime:
self._draining = True
if self._chat_service is not None:
self._chat_service.begin_shutdown()
+ if self._code_service is not None:
+ self._code_service.begin_shutdown()
async def close(self) -> bool:
self.begin_shutdown()
@@ -583,6 +590,12 @@ class ApplicationRuntime:
if not await self._cleanup_messaging():
return False
verbose = self.settings.log_api_error_tracebacks
+ if self._code_service is not None and not await best_effort(
+ "code_service.close",
+ self._code_service.close(),
+ log_verbose_errors=verbose,
+ ):
+ return False
if self._chat_service is not None and not await best_effort(
"chat_service.close",
self._chat_service.close(),
diff --git a/src/free_claude_code/runtime/bootstrap.py b/src/free_claude_code/runtime/bootstrap.py
index 53ef508f..43b2d8c9 100644
--- a/src/free_claude_code/runtime/bootstrap.py
+++ b/src/free_claude_code/runtime/bootstrap.py
@@ -7,11 +7,14 @@ from pathlib import Path
from free_claude_code.api.app import create_app
from free_claude_code.api.ports import ApiServices
from free_claude_code.application.chat import ChatService
+from free_claude_code.application.code_sessions import CodeService
from free_claude_code.config.loader import ManagedConfigStore
from free_claude_code.config.logging_config import configure_logging
from free_claude_code.config.paths import (
chat_database_path,
chat_lock_path,
+ code_database_path,
+ code_lock_path,
server_log_path,
)
from free_claude_code.config.settings import Settings
@@ -32,6 +35,8 @@ from free_claude_code.providers.runtime.factory import create_provider
from .application import ApplicationRuntime, RestartCallback
from .asgi import RuntimeASGIApp
from .chat_sqlite import SQLiteChatStore
+from .code_sessions_sqlite import SQLiteCodeStore
+from .codex_app_server import CodexHarnessFactory
from .codex_catalog import CodexModelCatalogPublisher
from .configuration import ConfigurationService
from .provider_manager import ProviderRuntimeManager
@@ -76,10 +81,15 @@ def build_asgi_app(
provider_manager,
SQLiteChatStore(chat_database_path(), chat_lock_path()),
)
+ code_service = CodeService(
+ SQLiteCodeStore(code_database_path(), code_lock_path()),
+ CodexHarnessFactory(provider_manager),
+ )
runtime = ApplicationRuntime(
provider_manager,
configuration=ConfigurationService(ManagedConfigStore()),
chat_service=chat_service,
+ code_service=code_service,
transcriber=_create_transcriber(settings),
restart_callback=restart_callback,
connected_accounts={"openai": openai_auth, "github_copilot": copilot_auth},
@@ -89,6 +99,7 @@ def build_asgi_app(
admin=runtime,
tasks=runtime,
chat=chat_service,
+ code=code_service,
)
return RuntimeASGIApp(create_app(services), runtime)
diff --git a/src/free_claude_code/runtime/code_sessions_sqlite.py b/src/free_claude_code/runtime/code_sessions_sqlite.py
new file mode 100644
index 00000000..c4213598
--- /dev/null
+++ b/src/free_claude_code/runtime/code_sessions_sqlite.py
@@ -0,0 +1,686 @@
+"""Relational, transaction-owned state for FCC coding conversations."""
+
+import asyncio
+import json
+import os
+import sqlite3
+from collections.abc import Callable, Sequence
+from contextlib import closing
+from pathlib import Path
+
+import anyio.to_thread
+
+from free_claude_code.application.code_sessions.models import (
+ CodeConflictError,
+ CodeItem,
+ CodeItemPage,
+ CodeNotFoundError,
+ CodePage,
+ CodePrompt,
+ CodeRun,
+ CodeSession,
+ CodeUnavailableError,
+ Record,
+ now_ms,
+)
+from free_claude_code.core.interprocess_lock import InterprocessFileLock
+
+_JSON_FIELDS = frozenset({"raw", "form", "error_details", "request_id"})
+_RUN_TRANSITIONS = {
+ "preparing": {
+ "preparing",
+ "running",
+ "stopping",
+ "completed",
+ "failed",
+ "interrupted",
+ },
+ "running": {"running", "stopping", "completed", "failed", "interrupted"},
+ "stopping": {"stopping", "completed", "failed", "interrupted"},
+ "completed": {"completed"},
+ "failed": {"failed"},
+ "interrupted": {"interrupted"},
+}
+_PROMPT_TRANSITIONS = {
+ "pending": {"pending", "answering", "resolved", "expired"},
+ "answering": {"answering", "resolved", "expired"},
+ "resolved": {"resolved"},
+ "expired": {"expired"},
+}
+
+
+def _values(record: Record) -> dict[str, object]:
+ values = record.model_dump()
+ for key in values.keys() & _JSON_FIELDS:
+ values[key] = json.dumps(values[key], sort_keys=True, separators=(",", ":"))
+ if isinstance(record, CodeSession):
+ values.update(
+ title_search=record.title.casefold(), cwd_search=record.cwd.casefold()
+ )
+ return values
+
+
+def _record[T: Record](model: type[T], row: sqlite3.Row) -> T:
+ values = {key: row[key] for key in model.model_fields}
+ for key in values.keys() & _JSON_FIELDS:
+ values[key] = json.loads(values[key])
+ return model.model_validate(values)
+
+
+def _insert(connection: sqlite3.Connection, table: str, record: Record) -> None:
+ values = _values(record)
+ connection.execute(
+ f"INSERT INTO {table} ({','.join(values)}) VALUES ({','.join('?' for _ in values)})",
+ tuple(values.values()),
+ )
+
+
+def _update(
+ connection: sqlite3.Connection,
+ table: str,
+ values: dict[str, object],
+ where: str,
+ parameters: tuple[object, ...],
+) -> None:
+ result = connection.execute(
+ f"UPDATE {table} SET {','.join(f'{key} = ?' for key in values)} WHERE {where}",
+ (*values.values(), *parameters),
+ )
+ if result.rowcount != 1:
+ raise CodeConflictError("This Code session changed. Refresh it and try again.")
+
+
+def _session(connection: sqlite3.Connection, session_id: str) -> CodeSession:
+ row = connection.execute(
+ "SELECT * FROM code_sessions WHERE id = ?", (session_id,)
+ ).fetchone()
+ if row is None:
+ raise CodeNotFoundError("Code session not found.")
+ return _record(CodeSession, row)
+
+
+def _idle(connection: sqlite3.Connection, session_id: str) -> None:
+ if (
+ connection.execute(
+ "SELECT 1 FROM code_runs WHERE session_id = ? AND status IN ('preparing','running','stopping')",
+ (session_id,),
+ ).fetchone()
+ or connection.execute(
+ "SELECT 1 FROM code_prompts WHERE session_id = ? AND status IN ('pending','answering')",
+ (session_id,),
+ ).fetchone()
+ ):
+ raise CodeConflictError("This session is busy. Your draft has been kept.")
+
+
+def _write_session(
+ connection: sqlite3.Connection,
+ session: CodeSession,
+ expected_revision: int,
+ *,
+ settings: bool,
+) -> None:
+ current = _session(connection, session.id)
+ if current.revision != expected_revision or session.revision not in {
+ expected_revision,
+ expected_revision + 1,
+ }:
+ raise CodeConflictError(
+ "This session changed. Refresh its state and try again."
+ )
+ fields = (
+ {
+ "title",
+ "title_search",
+ "auto_title",
+ "model",
+ "reasoning_effort",
+ "revision",
+ "updated_at",
+ }
+ if settings
+ else {
+ "native_thread_id",
+ "native_may_have_input",
+ "revision",
+ "updated_at",
+ "status",
+ "error",
+ }
+ )
+ _update(
+ connection,
+ "code_sessions",
+ {key: value for key, value in _values(session).items() if key in fields},
+ "id = ? AND revision = ?",
+ (session.id, expected_revision),
+ )
+
+
+def _write_run(connection: sqlite3.Connection, run: CodeRun) -> None:
+ row = connection.execute(
+ "SELECT * FROM code_runs WHERE session_id = ? AND id = ?",
+ (run.session_id, run.id),
+ ).fetchone()
+ if row is None:
+ raise CodeNotFoundError("Code turn not found.")
+ previous = _record(CodeRun, row)
+ if (
+ run.status not in _RUN_TRANSITIONS[previous.status]
+ or (
+ previous.status in {"completed", "failed", "interrupted"}
+ and (
+ run.finished_at != previous.finished_at
+ or (previous.error is not None and run.error != previous.error)
+ )
+ )
+ or (previous.stop_requested and not run.stop_requested)
+ or (previous.submission_started and not run.submission_started)
+ or any(
+ getattr(previous, key) != getattr(run, key)
+ for key in ("ordinal", "text", "model", "reasoning_effort")
+ )
+ or (
+ previous.native_turn_id is not None
+ and previous.native_turn_id != run.native_turn_id
+ )
+ ):
+ raise CodeConflictError("This Code turn no longer accepts that update.")
+ values = _values(run)
+ for key in (
+ "id",
+ "session_id",
+ "ordinal",
+ "text",
+ "model",
+ "reasoning_effort",
+ "created_at",
+ ):
+ values.pop(key)
+ _update(
+ connection,
+ "code_runs",
+ values,
+ "session_id = ? AND id = ? AND status = ?",
+ (run.session_id, run.id, previous.status),
+ )
+
+
+def _write_item(connection: sqlite3.Connection, item: CodeItem) -> None:
+ row = connection.execute(
+ "SELECT * FROM code_items WHERE session_id = ? AND id = ?",
+ (item.session_id, item.id),
+ ).fetchone()
+ if row is None:
+ _insert(connection, "code_items", item)
+ return
+ previous = _record(CodeItem, row)
+ if (
+ previous.run_id != item.run_id
+ or previous.sequence != item.sequence
+ or previous.kind != item.kind
+ or (previous.complete and not item.complete)
+ or any(
+ getattr(previous, key) is not None
+ and getattr(previous, key) != getattr(item, key)
+ for key in ("native_turn_id", "native_item_id")
+ )
+ ):
+ raise CodeConflictError("This transcript entry belongs to different work.")
+ values = _values(item)
+ for key in ("id", "session_id", "run_id", "sequence"):
+ values.pop(key)
+ _update(
+ connection,
+ "code_items",
+ values,
+ "session_id = ? AND id = ?",
+ (item.session_id, item.id),
+ )
+
+
+def _write_prompt(connection: sqlite3.Connection, prompt: CodePrompt) -> None:
+ row = connection.execute(
+ "SELECT * FROM code_prompts WHERE session_id = ? AND id = ?",
+ (prompt.session_id, prompt.id),
+ ).fetchone()
+ if row is None:
+ _insert(connection, "code_prompts", prompt)
+ return
+ previous = _record(CodePrompt, row)
+ if (
+ prompt.status not in _PROMPT_TRANSITIONS[previous.status]
+ or any(
+ getattr(previous, key) != getattr(prompt, key)
+ for key in (
+ "generation",
+ "request_id",
+ "native_turn_id",
+ "native_item_id",
+ "kind",
+ )
+ )
+ or (
+ previous.response_id is not None
+ and previous.response_id != prompt.response_id
+ )
+ ):
+ raise CodeConflictError("This native prompt is no longer active.")
+ values = _values(prompt)
+ for key in ("id", "session_id"):
+ values.pop(key)
+ _update(
+ connection,
+ "code_prompts",
+ values,
+ "session_id = ? AND id = ? AND status = ?",
+ (prompt.session_id, prompt.id, previous.status),
+ )
+
+
+class SQLiteCodeStore:
+ def __init__(self, database_path: Path, lock_path: Path) -> None:
+ self._path = database_path
+ self._lock = InterprocessFileLock(lock_path)
+ self._started = False
+ self._lifecycle = asyncio.Lock()
+
+ async def start(self) -> None:
+ async with self._lifecycle:
+ if self._started:
+ return
+ initialization = asyncio.create_task(
+ anyio.to_thread.run_sync(self._initialize)
+ )
+ try:
+ await asyncio.shield(initialization)
+ except BaseException:
+ await asyncio.gather(initialization, return_exceptions=True)
+ self._lock.release()
+ raise
+ self._started = True
+
+ def _initialize(self) -> None:
+ self._path.parent.mkdir(parents=True, exist_ok=True)
+ if not self._lock.acquire():
+ raise CodeUnavailableError(
+ "Code sessions is already owned by another FCC server."
+ )
+ if os.name != "nt":
+ self._path.parent.chmod(0o700)
+ self._execute(self._initialize_schema)
+ if os.name != "nt":
+ for path in (
+ self._path,
+ Path(f"{self._path}-wal"),
+ Path(f"{self._path}-shm"),
+ ):
+ if path.exists():
+ path.chmod(0o600)
+
+ async def close(self) -> None:
+ async with self._lifecycle:
+ self._started = False
+ await anyio.to_thread.run_sync(self._lock.release)
+
+ def _execute[T](self, operation: Callable[[sqlite3.Connection], T]) -> T:
+ try:
+ with closing(sqlite3.connect(self._path, timeout=10)) as connection:
+ connection.row_factory = sqlite3.Row
+ connection.execute("PRAGMA foreign_keys = ON")
+ with connection:
+ return operation(connection)
+ except sqlite3.IntegrityError as exc:
+ raise CodeConflictError(
+ "This Code operation conflicts with existing session state."
+ ) from exc
+ except sqlite3.Error as exc:
+ raise CodeUnavailableError("Code session storage is unavailable.") from exc
+
+ async def _run[T](self, operation: Callable[[sqlite3.Connection], T]) -> T:
+ if not self._started:
+ raise CodeUnavailableError("Code session storage is closed.")
+ return await anyio.to_thread.run_sync(self._execute, operation)
+
+ def _initialize_schema(self, connection: sqlite3.Connection) -> None:
+ connection.execute("PRAGMA journal_mode = WAL")
+ connection.executescript(_SCHEMA)
+ connection.execute("BEGIN IMMEDIATE")
+ connection.execute(
+ "UPDATE code_runs SET status = 'interrupted', finished_at = ?, error = ? "
+ "WHERE status IN ('preparing','running','stopping')",
+ (
+ now_ms(),
+ "FCC restarted before this turn finished. Its input was not resent.",
+ ),
+ )
+ connection.execute(
+ "UPDATE code_prompts SET status = 'expired' WHERE status IN ('pending','answering')"
+ )
+
+ async def create(self, session: CodeSession) -> CodeSession:
+ def operation(connection: sqlite3.Connection) -> CodeSession:
+ connection.execute("BEGIN IMMEDIATE")
+ if connection.execute(
+ "SELECT 1 FROM code_deleted WHERE id = ?", (session.id,)
+ ).fetchone():
+ raise CodeConflictError(
+ "This session was deleted. Create a new session."
+ )
+ row = connection.execute(
+ "SELECT * FROM code_sessions WHERE id = ?", (session.id,)
+ ).fetchone()
+ if row:
+ previous = _record(CodeSession, row)
+ if previous.cwd != session.cwd or previous.harness != session.harness:
+ raise CodeConflictError(
+ "This session ID was already used for another folder."
+ )
+ return previous
+ _insert(connection, "code_sessions", session)
+ return session
+
+ return await self._run(operation)
+
+ async def get_session(self, session_id: str) -> CodeSession:
+ return await self._run(lambda connection: _session(connection, session_id))
+
+ async def list_sessions(
+ self, cursor: tuple[int, str] | None, limit: int, query: str = ""
+ ) -> CodePage:
+ def operation(connection: sqlite3.Connection) -> CodePage:
+ clauses, parameters = [], []
+ if query.strip():
+ clauses.append(
+ "(instr(title_search, ?) > 0 OR instr(cwd_search, ?) > 0)"
+ )
+ parameters.extend([query.strip().casefold()] * 2)
+ if cursor:
+ clauses.append("(updated_at, id) < (?, ?)")
+ parameters.extend(cursor)
+ where = " WHERE " + " AND ".join(clauses) if clauses else ""
+ rows = connection.execute(
+ "SELECT * FROM code_sessions"
+ + where
+ + " ORDER BY updated_at DESC, id DESC LIMIT ?",
+ (*parameters, limit + 1),
+ ).fetchall()
+ sessions = tuple(_record(CodeSession, row) for row in rows[:limit])
+ last = sessions[-1] if sessions and len(rows) > limit else None
+ return CodePage(sessions, (last.updated_at, last.id) if last else None)
+
+ return await self._run(operation)
+
+ async def pending_deletions(self) -> tuple[CodeSession, ...]:
+ return await self._run(
+ lambda connection: tuple(
+ _record(CodeSession, row)
+ for row in connection.execute(
+ "SELECT * FROM code_sessions WHERE status != 'ready'"
+ )
+ )
+ )
+
+ async def is_deleted(self, session_id: str) -> bool:
+ return await self._run(
+ lambda connection: (
+ connection.execute(
+ "SELECT 1 FROM code_deleted WHERE id = ?", (session_id,)
+ ).fetchone()
+ is not None
+ )
+ )
+
+ async def get_run(self, session_id: str, run_id: str) -> CodeRun | None:
+ def operation(connection: sqlite3.Connection) -> CodeRun | None:
+ row = connection.execute(
+ "SELECT * FROM code_runs WHERE session_id = ? AND id = ?",
+ (session_id, run_id),
+ ).fetchone()
+ return _record(CodeRun, row) if row else None
+
+ return await self._run(operation)
+
+ async def runs(self, session_id: str) -> tuple[CodeRun, ...]:
+ return await self._run(
+ lambda connection: tuple(
+ _record(CodeRun, row)
+ for row in connection.execute(
+ "SELECT * FROM code_runs WHERE session_id = ? ORDER BY ordinal",
+ (session_id,),
+ )
+ )
+ )
+
+ async def latest_run(self, session_id: str) -> CodeRun | None:
+ def operation(connection: sqlite3.Connection) -> CodeRun | None:
+ row = connection.execute(
+ "SELECT * FROM code_runs WHERE session_id = ? ORDER BY ordinal DESC LIMIT 1",
+ (session_id,),
+ ).fetchone()
+ return _record(CodeRun, row) if row else None
+
+ return await self._run(operation)
+
+ async def items(
+ self, session_id: str, before: tuple[int, int] | None, limit: int | None
+ ) -> tuple[CodeItem, ...]:
+ return (await self.item_page(session_id, before, limit)).items
+
+ async def item_page(
+ self, session_id: str, before: tuple[int, int] | None, limit: int | None
+ ) -> CodeItemPage:
+ def operation(connection: sqlite3.Connection) -> CodeItemPage:
+ connection.execute("BEGIN")
+ parameters: list[object] = [session_id]
+ query = "SELECT i.*, r.ordinal AS run_ordinal FROM code_items i JOIN code_runs r ON (r.session_id, r.id) = (i.session_id, i.run_id) WHERE i.session_id = ?"
+ if before:
+ query += " AND (r.ordinal, i.sequence) < (?, ?)"
+ parameters.extend(before)
+ query += " ORDER BY r.ordinal DESC, i.sequence DESC"
+ if limit is not None:
+ query += " LIMIT ?"
+ parameters.append(limit + 1)
+ rows = connection.execute(query, parameters).fetchall()
+ selected = rows if limit is None else rows[:limit]
+ run_ids = {row["run_id"] for row in selected}
+ runs = tuple(
+ _record(CodeRun, row)
+ for row in connection.execute(
+ "SELECT * FROM code_runs WHERE session_id = ? ORDER BY ordinal",
+ (session_id,),
+ )
+ if row["id"] in run_ids
+ )
+ last = (
+ selected[-1]
+ if selected and limit is not None and len(rows) > limit
+ else None
+ )
+ return CodeItemPage(
+ tuple(_record(CodeItem, row) for row in reversed(selected)),
+ runs,
+ (last["run_ordinal"], last["sequence"]) if last else None,
+ )
+
+ return await self._run(operation)
+
+ async def prompts(self, session_id: str) -> tuple[CodePrompt, ...]:
+ return await self._run(
+ lambda connection: tuple(
+ _record(CodePrompt, row)
+ for row in connection.execute(
+ "SELECT * FROM code_prompts WHERE session_id = ? ORDER BY id",
+ (session_id,),
+ )
+ )
+ )
+
+ async def update_settings(
+ self, session: CodeSession, expected_revision: int
+ ) -> CodeSession:
+ def operation(connection: sqlite3.Connection) -> CodeSession:
+ connection.execute("BEGIN IMMEDIATE")
+ previous = _session(connection, session.id)
+ if previous.status != "ready":
+ raise CodeConflictError("This session is being deleted.")
+ if (previous.model, previous.reasoning_effort) != (
+ session.model,
+ session.reasoning_effort,
+ ):
+ _idle(connection, session.id)
+ _write_session(connection, session, expected_revision, settings=True)
+ return _session(connection, session.id)
+
+ return await self._run(operation)
+
+ async def admit_run(
+ self, session: CodeSession, run: CodeRun, item: CodeItem, expected_revision: int
+ ) -> tuple[CodeSession, CodeRun]:
+ def operation(connection: sqlite3.Connection) -> tuple[CodeSession, CodeRun]:
+ connection.execute("BEGIN IMMEDIATE")
+ previous = _session(connection, session.id)
+ row = connection.execute(
+ "SELECT * FROM code_runs WHERE session_id = ? AND id = ?",
+ (session.id, run.id),
+ ).fetchone()
+ if row:
+ receipt = _record(CodeRun, row)
+ if receipt.text != run.text:
+ raise CodeConflictError(
+ "This Send ID was already used for a different message."
+ )
+ return previous, receipt
+ if (
+ previous.status != "ready"
+ or previous.model != run.model
+ or run.session_id != session.id
+ ):
+ raise CodeConflictError(
+ "This session changed. Refresh it and try again."
+ )
+ _idle(connection, session.id)
+ _write_session(connection, session, expected_revision, settings=True)
+ ordinal = connection.execute(
+ "SELECT coalesce(max(ordinal), 0) + 1 FROM code_runs WHERE session_id = ?",
+ (session.id,),
+ ).fetchone()[0]
+ admitted = run.model_copy(update={"ordinal": ordinal})
+ if (
+ item.session_id != session.id
+ or item.run_id != run.id
+ or item.id != run.id
+ or item.kind != "user"
+ ):
+ raise CodeConflictError(
+ "The submitted message belongs to different work."
+ )
+ _insert(connection, "code_runs", admitted)
+ _insert(connection, "code_items", item)
+ return _session(connection, session.id), admitted
+
+ return await self._run(operation)
+
+ async def claim_prompt(
+ self, session_id: str, prompt_id: str, response_id: str, generation: str
+ ) -> CodePrompt:
+ def operation(connection: sqlite3.Connection) -> CodePrompt:
+ connection.execute("BEGIN IMMEDIATE")
+ row = connection.execute(
+ "SELECT * FROM code_prompts WHERE session_id = ? AND id = ?",
+ (session_id, prompt_id),
+ ).fetchone()
+ if row is None:
+ raise CodeNotFoundError("This prompt no longer exists.")
+ prompt = _record(CodePrompt, row)
+ if prompt.response_id == response_id:
+ return prompt
+ if prompt.status != "pending" or prompt.generation != generation:
+ raise CodeConflictError(
+ "This prompt was already answered or is no longer active."
+ )
+ claimed = prompt.model_copy(
+ update={"status": "answering", "response_id": response_id}
+ )
+ _write_prompt(connection, claimed)
+ return claimed
+
+ return await self._run(operation)
+
+ async def save_progress(
+ self,
+ session: CodeSession,
+ expected_revision: int,
+ *,
+ run: CodeRun | None = None,
+ items: Sequence[CodeItem] = (),
+ prompts: Sequence[CodePrompt] = (),
+ ) -> None:
+ def operation(connection: sqlite3.Connection) -> None:
+ connection.execute("BEGIN IMMEDIATE")
+ _write_session(connection, session, expected_revision, settings=False)
+ if run is not None:
+ if run.session_id != session.id:
+ raise CodeConflictError("This turn belongs to another session.")
+ _write_run(connection, run)
+ for item in items:
+ if item.session_id != session.id:
+ raise CodeConflictError("This entry belongs to another session.")
+ _write_item(connection, item)
+ for prompt in prompts:
+ if prompt.session_id != session.id:
+ raise CodeConflictError("This prompt belongs to another session.")
+ _write_prompt(connection, prompt)
+
+ await self._run(operation)
+
+ async def delete(self, session_id: str) -> None:
+ def operation(connection: sqlite3.Connection) -> None:
+ connection.execute("BEGIN IMMEDIATE")
+ connection.execute(
+ "INSERT OR IGNORE INTO code_deleted(id) VALUES (?)", (session_id,)
+ )
+ connection.execute("DELETE FROM code_sessions WHERE id = ?", (session_id,))
+
+ await self._run(operation)
+
+
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS code_sessions(
+ id TEXT PRIMARY KEY NOT NULL, cwd TEXT NOT NULL, model TEXT NOT NULL, reasoning_effort TEXT,
+ harness TEXT NOT NULL CHECK(harness = 'codex'), title TEXT NOT NULL, title_search TEXT NOT NULL,
+ cwd_search TEXT NOT NULL, auto_title INTEGER NOT NULL CHECK(auto_title IN (0,1)), native_thread_id TEXT,
+ native_may_have_input INTEGER NOT NULL CHECK(native_may_have_input IN (0,1)),
+ revision INTEGER NOT NULL CHECK(revision > 0), status TEXT NOT NULL CHECK(status IN ('ready','deleting','delete_uncertain')),
+ error TEXT, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS code_sessions_recent ON code_sessions(updated_at DESC, id DESC);
+CREATE TABLE IF NOT EXISTS code_runs(
+ session_id TEXT NOT NULL REFERENCES code_sessions(id) ON DELETE CASCADE, id TEXT NOT NULL,
+ ordinal INTEGER NOT NULL CHECK(ordinal > 0), text TEXT NOT NULL, model TEXT NOT NULL, reasoning_effort TEXT,
+ status TEXT NOT NULL CHECK(status IN ('preparing','running','stopping','completed','interrupted','failed')),
+ submission_started INTEGER NOT NULL CHECK(submission_started IN (0,1)), native_turn_id TEXT,
+ stop_requested INTEGER NOT NULL CHECK(stop_requested IN (0,1)), error TEXT, error_details TEXT NOT NULL,
+ created_at INTEGER NOT NULL, finished_at INTEGER,
+ PRIMARY KEY(session_id,id), UNIQUE(session_id,ordinal), UNIQUE(session_id,native_turn_id)
+);
+CREATE UNIQUE INDEX IF NOT EXISTS code_one_active_run ON code_runs(session_id)
+ WHERE status IN ('preparing','running','stopping');
+CREATE TABLE IF NOT EXISTS code_items(
+ session_id TEXT NOT NULL REFERENCES code_sessions(id) ON DELETE CASCADE, id TEXT NOT NULL,
+ run_id TEXT NOT NULL, sequence INTEGER NOT NULL CHECK(sequence > 0), native_turn_id TEXT, native_item_id TEXT,
+ kind TEXT NOT NULL, title TEXT NOT NULL, text TEXT NOT NULL, detail TEXT NOT NULL,
+ complete INTEGER NOT NULL CHECK(complete IN (0,1)), raw TEXT NOT NULL,
+ PRIMARY KEY(session_id,id), FOREIGN KEY(session_id,run_id) REFERENCES code_runs(session_id,id) ON DELETE CASCADE,
+ UNIQUE(session_id,sequence), UNIQUE(session_id,native_turn_id,native_item_id)
+);
+CREATE INDEX IF NOT EXISTS code_items_run ON code_items(session_id,run_id,sequence);
+CREATE TABLE IF NOT EXISTS code_prompts(
+ session_id TEXT NOT NULL REFERENCES code_sessions(id) ON DELETE CASCADE, id TEXT NOT NULL,
+ generation TEXT NOT NULL, request_id TEXT NOT NULL, native_turn_id TEXT, native_item_id TEXT,
+ kind TEXT NOT NULL, form TEXT NOT NULL, raw TEXT NOT NULL,
+ status TEXT NOT NULL CHECK(status IN ('pending','answering','resolved','expired')), response_id TEXT, error TEXT,
+ PRIMARY KEY(session_id,id), UNIQUE(session_id,generation,request_id), UNIQUE(session_id,response_id)
+);
+CREATE TABLE IF NOT EXISTS code_deleted(id TEXT PRIMARY KEY NOT NULL);
+"""
diff --git a/src/free_claude_code/runtime/codex_app_server.py b/src/free_claude_code/runtime/codex_app_server.py
new file mode 100644
index 00000000..c98899d2
--- /dev/null
+++ b/src/free_claude_code/runtime/codex_app_server.py
@@ -0,0 +1,654 @@
+"""Owned Codex app-server processes over bidirectional stdio JSONL."""
+
+import asyncio
+import hashlib
+import json
+import os
+import shutil
+import signal
+import subprocess
+import uuid
+from collections.abc import Mapping
+from contextlib import ExitStack, suppress
+from dataclasses import dataclass, replace
+
+from free_claude_code.application.code_sessions.models import (
+ CodeCatalog,
+ CodeConflictError,
+ CodeModel,
+ CodeUnavailableError,
+ CodeValidationError,
+ HarnessEvent,
+ NativeHistoryMissing,
+ NativeThread,
+)
+from free_claude_code.application.code_sessions.ports import EventSink, HarnessSelection
+from free_claude_code.application.ports import RequestRuntimePort
+from free_claude_code.cli.launchers.codex import SPEC, prepare_codex_launch
+from free_claude_code.cli.launchers.codex_model_catalog import build_codex_model_catalog
+from free_claude_code.cli.launchers.resources import LaunchResources
+from free_claude_code.cli.launchers.runner import LaunchContext
+from free_claude_code.cli.process_registry import register_pid, unregister_pid
+from free_claude_code.config.server_urls import local_proxy_root_url
+from free_claude_code.core.json_types import JsonObject
+from free_claude_code.core.version import package_version
+
+from .codex_catalog import current_codex_models
+from .codex_protocol import (
+ CodexProtocol,
+ NativePrompt,
+ array_value,
+ object_value,
+ string_value,
+)
+
+
+class CodexAppServer:
+ def __init__(
+ self,
+ command: list[str],
+ env: Mapping[str, str],
+ cwd: str,
+ sink: EventSink,
+ *,
+ model_slugs: Mapping[str, str] | None = None,
+ fingerprints: Mapping[str, str] | None = None,
+ reasoning: Mapping[str, bool] | None = None,
+ resources: ExitStack | None = None,
+ ) -> None:
+ self.generation = str(uuid.uuid4())
+ self.thread_id: str | None = None
+ self._owned_threads: set[str] = set()
+ self._command, self._env, self._cwd, self._sink = command, dict(env), cwd, sink
+ self._model_slugs = dict(model_slugs or {})
+ self._fingerprints = dict(fingerprints or {})
+ self._reasoning = dict(reasoning or {})
+ self._resources = resources or ExitStack()
+ self._protocol = CodexProtocol(self.generation)
+ self._pending: dict[str, tuple[str, asyncio.Future[JsonObject]]] = {}
+ self._requests: dict[str | int, NativePrompt] = {}
+ self._queue: asyncio.Queue[HarnessEvent | None] = asyncio.Queue()
+ self._writer_lock = asyncio.Lock()
+ self._process: asyncio.subprocess.Process | None = None
+ self._reader: asyncio.Task[None] | None = None
+ self._stderr: asyncio.Task[None] | None = None
+ self._dispatcher: asyncio.Task[None] | None = None
+ self._closing: asyncio.Task[None] | None = None
+ self._reaping: asyncio.Task[None] | None = None
+ self._alive = False
+ self._stderr_tail = bytearray()
+
+ @property
+ def process(self) -> asyncio.subprocess.Process:
+ if self._process is None:
+ raise CodeUnavailableError("Codex has not started.")
+ return self._process
+
+ async def start(self) -> None:
+ try:
+ self._process = await asyncio.create_subprocess_exec(
+ *self._command,
+ cwd=self._cwd,
+ env=self._env,
+ stdin=asyncio.subprocess.PIPE,
+ stdout=asyncio.subprocess.PIPE,
+ stderr=asyncio.subprocess.PIPE,
+ creationflags=subprocess.CREATE_NO_WINDOW if os.name == "nt" else 0,
+ start_new_session=os.name != "nt",
+ )
+ register_pid(self._process.pid)
+ self._alive = True
+ self._reader = asyncio.create_task(self._read(), name="fcc-codex-jsonl")
+ self._stderr = asyncio.create_task(
+ self._read_stderr(), name="fcc-codex-stderr"
+ )
+ self._dispatcher = asyncio.create_task(
+ self._dispatch(), name="fcc-codex-events"
+ )
+ await self.rpc(
+ "initialize",
+ {
+ "clientInfo": {
+ "name": "free_claude_code",
+ "title": "Free Claude Code",
+ "version": package_version(),
+ },
+ "capabilities": {
+ "experimentalApi": True,
+ "mcpServerOpenaiFormElicitation": False,
+ },
+ },
+ )
+ await self._write({"method": "initialized", "params": {}})
+ except BaseException:
+ await self.close()
+ raise
+
+ def supports(self, selection: HarnessSelection) -> bool:
+ return (
+ self._alive
+ and self._closing is None
+ and self._fingerprints.get(selection.model) == selection.configuration_key
+ )
+
+ async def create_thread(self) -> NativeThread:
+ response = await self.rpc(
+ "thread/start", {"cwd": self._cwd, "modelProvider": "fcc"}
+ )
+ native = self._protocol.history(response)
+ self.thread_id = native.id
+ return native
+
+ async def resume_thread(self, thread_id: str) -> NativeThread:
+ response = await self.rpc(
+ "thread/resume",
+ {"threadId": thread_id, "cwd": self._cwd, "modelProvider": "fcc"},
+ )
+ native = self._protocol.history(response)
+ self.thread_id = native.id
+ return native
+
+ async def read_thread(self, thread_id: str) -> NativeThread:
+ return self._protocol.history(
+ await self.rpc("thread/read", {"threadId": thread_id, "includeTurns": True})
+ )
+
+ async def start_turn(
+ self, text: str, selection: HarnessSelection, client_id: str
+ ) -> str:
+ model = self._model_slugs.get(selection.model)
+ if not self.thread_id or model is None:
+ raise CodeUnavailableError(
+ "Codex is not prepared for the selected FCC model."
+ )
+ params: JsonObject = {
+ "threadId": self.thread_id,
+ "input": [{"type": "text", "text": text}],
+ "clientUserMessageId": client_id,
+ "model": model,
+ }
+ if self._reasoning.get(selection.model, True):
+ params["summary"] = "auto"
+ params["effort"] = selection.reasoning_effort
+ result = await self.rpc("turn/start", params)
+ turn_id = string_value(object_value(result.get("turn")).get("id"))
+ if not turn_id:
+ raise CodeUnavailableError(
+ "Codex did not return a turn ID; input was not resent."
+ )
+ return turn_id
+
+ async def interrupt(self, turn_id: str) -> None:
+ await self.rpc(
+ "turn/interrupt", {"threadId": self.thread_id, "turnId": turn_id}
+ )
+
+ def prepare_answer(self, request_id: str | int, answer: JsonObject) -> JsonObject:
+ prompt = self._requests.get(request_id)
+ if prompt is None:
+ raise CodeConflictError("This native prompt is no longer active.")
+ return prompt.answer(answer)
+
+ async def respond(self, request_id: str | int, response: JsonObject) -> None:
+ async with self._writer_lock:
+ if not self._alive or request_id not in self._requests:
+ raise CodeConflictError("This native prompt is no longer active.")
+ self._write_frame({"id": request_id, "result": response})
+ self._requests.pop(request_id, None)
+ assert self.process.stdin is not None
+ await self.process.stdin.drain()
+
+ async def delete_thread(self, thread_id: str) -> None:
+ await self.rpc("thread/delete", {"threadId": thread_id})
+
+ async def rpc(self, method: str, params: JsonObject) -> JsonObject:
+ if not self._alive:
+ raise CodeUnavailableError("The Codex connection is closed.")
+ request_id = f"fcc-{uuid.uuid4()}"
+ future: asyncio.Future[JsonObject] = asyncio.get_running_loop().create_future()
+ # A cancelled caller does not erase the pending native response/identity.
+ future.add_done_callback(
+ lambda value: value.exception() if not value.cancelled() else None
+ )
+ self._pending[request_id] = method, future
+ try:
+ await self._write({"id": request_id, "method": method, "params": params})
+ async with asyncio.timeout(30):
+ return await asyncio.shield(future)
+ except asyncio.CancelledError:
+ raise
+ except TimeoutError as exc:
+ raise CodeUnavailableError(
+ "Codex did not acknowledge the request. It was not resent."
+ ) from exc
+
+ async def _write(self, message: JsonObject) -> None:
+ async with self._writer_lock:
+ self._write_frame(message)
+ assert self.process.stdin is not None
+ await self.process.stdin.drain()
+
+ def _write_frame(self, message: JsonObject) -> None:
+ if not self._alive or self.process.stdin is None:
+ raise CodeUnavailableError("The Codex connection is closed.")
+ self.process.stdin.write(
+ (json.dumps(message, ensure_ascii=False, allow_nan=False) + "\n").encode(
+ "utf-8"
+ )
+ )
+
+ async def _read(self) -> None:
+ assert self.process.stdout is not None
+ buffer = bytearray()
+ message = "The Codex process ended."
+ discarded_output: asyncio.Task[None] | None = None
+ try:
+ while chunk := await self.process.stdout.read(65536):
+ buffer.extend(chunk)
+ while (position := buffer.find(b"\n")) >= 0:
+ frame = bytes(buffer[:position])
+ del buffer[: position + 1]
+ if frame.strip():
+ await self._packet(
+ object_value(json.loads(frame.decode("utf-8")))
+ )
+ if buffer.strip():
+ raise ValueError("Incomplete native JSONL frame")
+ except Exception as exc:
+ message = f"The Codex connection failed ({type(exc).__name__})."
+ discarded_output = asyncio.create_task(self._discard_stdout())
+ finally:
+ self._alive = False
+ for _, future in self._pending.values():
+ if not future.done():
+ future.set_exception(CodeUnavailableError(message))
+ self._pending.clear()
+ self._requests.clear()
+ # A failed pipe does not prove the native agent has stopped working.
+ # Keep the session reserved until its owned process is actually gone.
+ await self._reap_owned_process()
+ if discarded_output is not None:
+ await discarded_output
+ self._queue.put_nowait(
+ HarnessEvent(self.generation, self.thread_id, "closed", message=message)
+ )
+ self._queue.put_nowait(None)
+
+ async def _discard_stdout(self) -> None:
+ # Keep draining a failed protocol stream until EOF, so a full pipe
+ # cannot block native shutdown or retain its subprocess transport.
+ assert self.process.stdout is not None
+ while await self.process.stdout.read(65536):
+ pass
+
+ async def _packet(self, packet: JsonObject) -> None:
+ method = string_value(packet.get("method"))
+ if not method:
+ request_id = packet.get("id")
+ pending = (
+ self._pending.pop(request_id, None)
+ if isinstance(request_id, str)
+ else None
+ )
+ if pending is None:
+ return
+ operation, future = pending
+ if future.done():
+ return
+ if "error" in packet:
+ error = object_value(packet["error"])
+ message = (
+ self._redact(string_value(error.get("message")))
+ or "Codex rejected the request."
+ )
+ if operation in {
+ "thread/read",
+ "thread/resume",
+ "thread/delete",
+ } and any(
+ phrase in message.lower()
+ for phrase in (
+ "thread not found",
+ "thread does not exist",
+ "no rollout found",
+ "not found for thread",
+ )
+ ):
+ future.set_exception(NativeHistoryMissing(message))
+ elif error.get("code") == -32601:
+ future.set_exception(
+ CodeUnavailableError(
+ "This Codex version lacks the required app-server method. Update Codex."
+ )
+ )
+ else:
+ future.set_exception(CodeConflictError(message))
+ return
+ result = object_value(packet.get("result"))
+ if operation in {"thread/start", "thread/resume"}:
+ identity = string_value(object_value(result.get("thread")).get("id"))
+ if identity:
+ self.thread_id = identity
+ self._owned_threads.add(identity)
+ future.set_result(result)
+ return
+ params = object_value(packet.get("params"))
+ if method == "thread/started":
+ thread = object_value(params.get("thread"))
+ source = object_value(object_value(thread.get("source")).get("subAgent"))
+ parent = object_value(source.get("thread_spawn")).get("parent_thread_id")
+ child = string_value(thread.get("id"))
+ if child and isinstance(parent, str) and parent in self._owned_threads:
+ self._owned_threads.add(child)
+ return
+ request_id = packet.get("id")
+ if isinstance(request_id, str | int) and not isinstance(request_id, bool):
+ try:
+ thread_id = string_value(params.get("threadId")) or self.thread_id
+ if thread_id and thread_id not in self._owned_threads:
+ raise CodeValidationError(
+ "Codex requested input for a conversation outside this Code session."
+ )
+ prompt = NativePrompt(method, request_id, params)
+ except CodeValidationError as exc:
+ await self._write(
+ {"id": request_id, "error": {"code": -32601, "message": str(exc)}}
+ )
+ self._queue.put_nowait(
+ HarnessEvent(
+ self.generation, self.thread_id, "error", message=str(exc)
+ )
+ )
+ return
+ self._requests[request_id] = prompt
+ request = prompt.request()
+ if thread_id != self.thread_id:
+ request = replace(
+ request,
+ turn_id=None,
+ form={
+ **request.form,
+ "detail": "A Codex subagent needs your input.\n"
+ + string_value(request.form.get("detail")),
+ },
+ )
+ self._queue.put_nowait(
+ HarnessEvent(
+ self.generation,
+ self.thread_id,
+ "prompt",
+ turn_id=request.turn_id,
+ prompt=request,
+ )
+ )
+ return
+ event = self._protocol.notification(method, params)
+ if event is not None:
+ if event.kind == "resolved" and event.request_id is not None:
+ self._requests.pop(event.request_id, None)
+ if event.thread_id in self._owned_threads:
+ event = replace(event, thread_id=self.thread_id)
+ if event.kind == "turn_completed":
+ for key, prompt in tuple(self._requests.items()):
+ if (
+ prompt.params.get("turnId") == event.turn_id
+ and prompt.params.get("threadId") == event.thread_id
+ ):
+ self._requests.pop(key, None)
+ if (
+ event.thread_id != self.thread_id
+ and event.thread_id in self._owned_threads
+ ):
+ self._queue.put_nowait(
+ HarnessEvent(
+ self.generation,
+ self.thread_id,
+ "resolved",
+ request_id=key,
+ )
+ )
+ self._queue.put_nowait(event)
+
+ async def _dispatch(self) -> None:
+ while (event := await self._queue.get()) is not None:
+ await self._sink(event)
+
+ async def _read_stderr(self) -> None:
+ assert self.process.stderr is not None
+ while chunk := await self.process.stderr.read(8192):
+ self._stderr_tail.extend(chunk)
+ del self._stderr_tail[:-16384]
+
+ def _redact(self, text: str) -> str:
+ for key, value in self._env.items():
+ if value and any(
+ part in key.upper()
+ for part in ("TOKEN", "API_KEY", "PASSWORD", "SECRET")
+ ):
+ text = text.replace(value, "[redacted]")
+ return text
+
+ async def close(self) -> None:
+ if asyncio.current_task() is self._dispatcher:
+ await self._reap_owned_process()
+ return
+ if self._closing is None:
+ self._closing = asyncio.create_task(
+ self._close(),
+ name="fcc-codex-close",
+ )
+ await asyncio.shield(self._closing)
+
+ async def _close(self) -> None:
+ await self._reap_owned_process()
+ if self._reader is not None:
+ await self._reader
+ if self._dispatcher is not None:
+ await self._dispatcher
+
+ async def _reap_owned_process(self) -> None:
+ if self._reaping is None:
+ self._reaping = asyncio.create_task(self._reap(), name="fcc-codex-reap")
+ await asyncio.shield(self._reaping)
+
+ async def _reap(self) -> None:
+ process = self._process
+ if process is not None:
+ if process.stdin is not None:
+ process.stdin.close()
+ try:
+ async with asyncio.timeout(5):
+ await process.wait()
+ except TimeoutError:
+ await self._kill_tree(process)
+ if self._stderr is not None:
+ await self._stderr
+ unregister_pid(process.pid)
+ self._alive = False
+ self._resources.close()
+
+ @staticmethod
+ async def _kill_tree(process: asyncio.subprocess.Process) -> None:
+ if process.returncode is not None:
+ return
+ if os.name == "nt":
+ killer = await asyncio.create_subprocess_exec(
+ "taskkill",
+ "/PID",
+ str(process.pid),
+ "/T",
+ "/F",
+ stdout=asyncio.subprocess.DEVNULL,
+ stderr=asyncio.subprocess.DEVNULL,
+ creationflags=subprocess.CREATE_NO_WINDOW,
+ )
+ await killer.wait()
+ else:
+ with suppress(ProcessLookupError):
+ os.killpg(process.pid, signal.SIGKILL)
+ if process.returncode is None:
+ with suppress(ProcessLookupError):
+ process.kill()
+ await process.wait()
+
+
+@dataclass(frozen=True, slots=True)
+class _CodexSelection:
+ context: LaunchContext
+ model: str
+ configuration_key: str
+ fingerprints: dict[str, str]
+ reasoning_effort: str | None
+
+ async def open(self, cwd: str, sink: EventSink) -> CodexAppServer:
+ resources = ExitStack()
+ try:
+ prepared = prepare_codex_launch(
+ self.context,
+ [
+ "-c",
+ "features.default_mode_request_user_input=true",
+ "-c",
+ "tools.experimental_request_user_input.enabled=true",
+ "app-server",
+ ],
+ LaunchResources(resources),
+ )
+ connection = CodexAppServer(
+ prepared.command,
+ prepared.env,
+ cwd,
+ sink,
+ model_slugs={
+ model.provider_model_ref: model.wire_slug
+ for model in self.context.models
+ },
+ fingerprints=self.fingerprints,
+ reasoning={
+ model.provider_model_ref: model.supports_reasoning is not False
+ for model in self.context.models
+ },
+ resources=resources,
+ )
+ await connection.start()
+ return connection
+ except BaseException:
+ resources.close()
+ raise
+
+
+class CodexHarnessFactory:
+ def __init__(
+ self,
+ runtime: RequestRuntimePort,
+ *,
+ binary: str | None = None,
+ env: Mapping[str, str] | None = None,
+ ) -> None:
+ self._runtime, self._binary, self._env = runtime, binary, env
+
+ def availability(self) -> tuple[bool, str | None]:
+ if self._binary or shutil.which("codex"):
+ return True, None
+ return False, "Codex is not installed. " + SPEC.install_hint
+
+ def catalog(self) -> CodeCatalog:
+ settings = self._runtime.current_settings()
+ models = current_codex_models(self._runtime, settings)
+ entries = array_value(build_codex_model_catalog(models).get("models"))
+ return CodeCatalog(
+ settings.model,
+ tuple(
+ _model_option(model.provider_model_ref, object_value(entry))
+ for model, entry in zip(models, entries, strict=True)
+ ),
+ )
+
+ def prepare(self, model: str, reasoning_effort: str | None) -> _CodexSelection:
+ binary = self._binary or shutil.which("codex")
+ if binary is None:
+ raise CodeUnavailableError("Codex is not installed. " + SPEC.install_hint)
+ settings = self._runtime.current_settings()
+ models = current_codex_models(self._runtime, settings)
+ selected = next(
+ (
+ candidate
+ for candidate in models
+ if candidate.provider_model_ref == model
+ ),
+ None,
+ )
+ if selected is None:
+ raise CodeValidationError(
+ "This model is unavailable. Choose another model."
+ )
+ catalog = build_codex_model_catalog(models)
+ entries = {
+ string_value(entry.get("slug")): entry
+ for value in array_value(catalog.get("models"))
+ if (entry := object_value(value))
+ }
+ option = _model_option(model, entries[selected.wire_slug])
+ if (
+ reasoning_effort is not None
+ and reasoning_effort not in option.reasoning_efforts
+ ):
+ raise CodeValidationError(
+ "This reasoning effort is unavailable. Choose another effort or Model default."
+ )
+ effort = reasoning_effort or option.default_reasoning_effort
+ fingerprints = {
+ model.provider_model_ref: _fingerprint(entries[model.wire_slug])
+ for model in models
+ }
+ context = LaunchContext(
+ binary,
+ settings.model_copy(update={"model": model}),
+ local_proxy_root_url(settings),
+ settings.proxy_auth_token,
+ dict(self._env if self._env is not None else os.environ),
+ models,
+ )
+ return _CodexSelection(
+ context, model, fingerprints[model], fingerprints, effort
+ )
+
+ async def open_history(self, cwd: str, sink: EventSink) -> CodexAppServer:
+ binary = self._binary or shutil.which("codex")
+ if binary is None:
+ raise CodeUnavailableError(
+ "Codex is needed to remove its native conversation. "
+ + SPEC.install_hint
+ )
+ connection = CodexAppServer(
+ [binary, "app-server"],
+ dict(self._env if self._env is not None else os.environ),
+ cwd,
+ sink,
+ )
+ await connection.start()
+ return connection
+
+
+def _model_option(model: str, entry: JsonObject) -> CodeModel:
+ return CodeModel(
+ id=model,
+ display_name=string_value(entry.get("display_name")) or model,
+ reasoning_efforts=tuple(
+ string_value(object_value(level).get("effort"))
+ for level in array_value(entry.get("supported_reasoning_levels"))
+ ),
+ default_reasoning_effort=string_value(entry.get("default_reasoning_level"))
+ or None,
+ )
+
+
+def _fingerprint(entry: JsonObject) -> str:
+ behavior = {
+ key: value
+ for key, value in entry.items()
+ if key not in {"display_name", "description", "priority", "visibility"}
+ }
+ return hashlib.sha256(
+ json.dumps(behavior, sort_keys=True, ensure_ascii=True).encode()
+ ).hexdigest()
diff --git a/src/free_claude_code/runtime/codex_catalog.py b/src/free_claude_code/runtime/codex_catalog.py
index 2ff30612..1da9354d 100644
--- a/src/free_claude_code/runtime/codex_catalog.py
+++ b/src/free_claude_code/runtime/codex_catalog.py
@@ -11,8 +11,26 @@ from free_claude_code.cli.launchers.codex_model_catalog import (
build_codex_model_catalog,
write_codex_model_catalog,
)
-from free_claude_code.cli.launchers.model_catalog import client_models_from_response
+from free_claude_code.cli.launchers.model_catalog import (
+ ClientModel,
+ client_models_from_response,
+)
from free_claude_code.config.paths import codex_model_catalog_path
+from free_claude_code.config.settings import Settings
+
+
+def current_codex_models(
+ runtime: RequestRuntimePort, settings: Settings | None = None
+) -> tuple[ClientModel, ...]:
+ """Read the current FCC inventory without a request to the server itself."""
+ response = build_models_list_response(
+ settings or runtime.current_settings(),
+ runtime,
+ view=ModelCatalogView.RESPONSES,
+ )
+ return client_models_from_response(
+ response.model_dump(by_alias=True, exclude_none=True)
+ )
class CodexModelCatalogPublisher:
@@ -39,16 +57,7 @@ class CodexModelCatalogPublisher:
runtime: RequestRuntimePort,
catalog_path: Path,
) -> None:
- models_response = build_models_list_response(
- runtime.current_settings(),
- runtime,
- view=ModelCatalogView.RESPONSES,
- )
- catalog = build_codex_model_catalog(
- client_models_from_response(
- models_response.model_dump(by_alias=True, exclude_none=True)
- )
- )
+ catalog = build_codex_model_catalog(current_codex_models(runtime))
models = catalog.get("models")
if not isinstance(models, list) or not models:
raise ValueError("Codex model catalog contains no routable models.")
diff --git a/src/free_claude_code/runtime/codex_protocol.py b/src/free_claude_code/runtime/codex_protocol.py
new file mode 100644
index 00000000..e9bf8978
--- /dev/null
+++ b/src/free_claude_code/runtime/codex_protocol.py
@@ -0,0 +1,603 @@
+"""Codex app-server v2 item and interactive-request projection."""
+
+import json
+import math
+from dataclasses import dataclass, field
+
+from jsonschema import FormatChecker
+
+from free_claude_code.application.code_sessions.models import (
+ CodeValidationError,
+ HarnessEvent,
+ ItemUpdate,
+ NativeThread,
+ NativeTurn,
+ PromptRequest,
+ RunStatus,
+)
+from free_claude_code.core.json_types import JsonObject, JsonValue
+
+
+def object_value(value: object) -> JsonObject:
+ return dict(value) if isinstance(value, dict) else {}
+
+
+def array_value(value: object) -> list[JsonValue]:
+ return list(value) if isinstance(value, list | tuple) else []
+
+
+def string_value(value: object) -> str:
+ return value if isinstance(value, str) else ""
+
+
+def pretty(value: object) -> str:
+ return json.dumps(value, ensure_ascii=False, indent=2)
+
+
+@dataclass(slots=True)
+class _Item:
+ raw: JsonObject = field(default_factory=dict)
+ text: str = ""
+ output: str = ""
+ summary: dict[int, str] = field(default_factory=dict)
+ reasoning: dict[int, str] = field(default_factory=dict)
+
+
+class CodexProtocol:
+ def __init__(self, generation: str) -> None:
+ self.generation = generation
+ self._items: dict[tuple[str, str], _Item] = {}
+
+ def notification(self, method: str, params: JsonObject) -> HarnessEvent | None:
+ thread_id = string_value(params.get("threadId")) or None
+ turn = object_value(params.get("turn"))
+ turn_id = (
+ string_value(params.get("turnId")) or string_value(turn.get("id")) or None
+ )
+ if method in {"turn/started", "turn/completed"}:
+ status: RunStatus = "completed"
+ if turn.get("status") == "interrupted":
+ status = "interrupted"
+ elif turn.get("status") == "failed":
+ status = "failed"
+ return HarnessEvent(
+ self.generation,
+ thread_id,
+ "turn_started" if method == "turn/started" else "turn_completed",
+ turn_id=turn_id,
+ status=status,
+ message=string_value(object_value(turn.get("error")).get("message"))
+ or None,
+ error_details=object_value(turn.get("error")),
+ )
+ if method == "error":
+ return HarnessEvent(
+ self.generation,
+ thread_id,
+ "error",
+ turn_id=turn_id,
+ message=string_value(object_value(params.get("error")).get("message")),
+ will_retry=params.get("willRetry") is True,
+ error_details=object_value(params.get("error")),
+ )
+ if method == "serverRequest/resolved":
+ request_id = params.get("requestId")
+ if isinstance(request_id, str | int) and not isinstance(request_id, bool):
+ return HarnessEvent(
+ self.generation, thread_id, "resolved", request_id=request_id
+ )
+ return None
+ if not thread_id or not turn_id:
+ return None
+ raw = object_value(params.get("item"))
+ item_id = string_value(params.get("itemId")) or string_value(raw.get("id"))
+ if not item_id:
+ return None
+ item = self._items.setdefault((turn_id, item_id), _Item())
+ complete = method == "item/completed"
+ delta = string_value(params.get("delta"))
+ if method in {"item/started", "item/completed"}:
+ item.raw = {**item.raw, **raw}
+ elif method == "item/agentMessage/delta":
+ item.raw.setdefault("type", "agentMessage")
+ item.text += delta
+ elif method in {
+ "item/reasoning/summaryTextDelta",
+ "item/reasoning/textDelta",
+ "item/reasoning/summaryPartAdded",
+ }:
+ item.raw.setdefault("type", "reasoning")
+ summary = method != "item/reasoning/textDelta"
+ index = params.get("summaryIndex" if summary else "contentIndex", 0)
+ if not isinstance(index, int) or isinstance(index, bool) or index < 0:
+ return None
+ parts = item.summary if summary else item.reasoning
+ parts[index] = parts.get(index, "") + delta
+ elif method in {
+ "item/commandExecution/outputDelta",
+ "item/fileChange/outputDelta",
+ }:
+ item.raw.setdefault(
+ "type", "fileChange" if "fileChange" in method else "commandExecution"
+ )
+ item.output += delta
+ elif method == "item/fileChange/patchUpdated":
+ item.raw["changes"] = params.get("changes", [])
+ elif method == "item/mcpToolCall/progress":
+ item.output += string_value(params.get("message")) + "\n"
+ else:
+ return None
+ return HarnessEvent(
+ self.generation,
+ thread_id,
+ "item",
+ turn_id=turn_id,
+ item=self._project(turn_id, item_id, item, complete),
+ )
+
+ def history(self, payload: JsonObject) -> NativeThread:
+ thread = object_value(payload.get("thread"))
+ thread_id = string_value(thread.get("id"))
+ if not thread_id:
+ raise CodeValidationError("Codex did not return a conversation ID.")
+ turns: list[NativeTurn] = []
+ for raw_turn in array_value(thread.get("turns")):
+ turn = object_value(raw_turn)
+ turn_id = string_value(turn.get("id"))
+ items: list[ItemUpdate] = []
+ for value in array_value(turn.get("items")):
+ raw = object_value(value)
+ item_id = string_value(raw.get("id"))
+ if not turn_id or not item_id:
+ continue
+ accumulated = self._items.setdefault((turn_id, item_id), _Item())
+ accumulated.raw = {**accumulated.raw, **raw}
+ items.append(self._project(turn_id, item_id, accumulated, True))
+ if turn_id:
+ error = object_value(turn.get("error"))
+ status: RunStatus = (
+ "failed"
+ if turn.get("status") == "failed"
+ else "interrupted"
+ if turn.get("status") == "interrupted"
+ else "completed"
+ )
+ turns.append(
+ NativeTurn(
+ turn_id,
+ tuple(items),
+ status,
+ string_value(error.get("message")) or None,
+ error,
+ )
+ )
+ return NativeThread(thread_id, tuple(turns))
+
+ @staticmethod
+ def _project(turn_id: str, item_id: str, item: _Item, complete: bool) -> ItemUpdate:
+ raw = item.raw
+ native_kind = string_value(raw.get("type"))
+ kind, text, title, detail = "tool", "", native_kind, ""
+ if native_kind == "userMessage":
+ kind = "user"
+ text = "\n".join(
+ string_value(object_value(value).get("text"))
+ for value in array_value(raw.get("content"))
+ )
+ elif native_kind == "agentMessage":
+ kind = "text"
+ text = (
+ string_value(raw.get("text"))
+ if complete and "text" in raw
+ else item.text or string_value(raw.get("text"))
+ )
+ questions = array_value(raw.get("questions"))
+ if questions:
+ detail = "\n\n".join(
+ string_value(object_value(question).get("title"))
+ for question in questions
+ )
+ elif native_kind == "reasoning":
+ kind, title = "reasoning", "Thinking"
+ summary = [string_value(value) for value in array_value(raw.get("summary"))]
+ content = [string_value(value) for value in array_value(raw.get("content"))]
+ if not any(summary):
+ summary = [value for _, value in sorted(item.summary.items())]
+ if not any(content):
+ content = [value for _, value in sorted(item.reasoning.items())]
+ text = "\n\n".join(value for value in [*summary, *content] if value)
+ elif native_kind == "commandExecution":
+ title = string_value(raw.get("command")) or "Command"
+ output = string_value(raw.get("aggregatedOutput")) or item.output
+ detail = "\n".join(
+ value
+ for value in [
+ string_value(raw.get("cwd")),
+ output,
+ f"Exit code: {raw['exitCode']}"
+ if raw.get("exitCode") is not None
+ else "",
+ ]
+ if value
+ )
+ elif native_kind == "fileChange":
+ kind, title = "tool", "File changes"
+ changes = []
+ for value in array_value(raw.get("changes")):
+ change = object_value(value)
+ changes.append(
+ "\n".join(
+ [
+ string_value(change.get("path")),
+ string_value(change.get("diff")),
+ ]
+ )
+ )
+ detail = "\n\n".join(changes) or item.output
+ elif native_kind == "mcpToolCall":
+ title = ".".join(
+ value
+ for value in [
+ string_value(raw.get("server")),
+ string_value(raw.get("tool")),
+ ]
+ if value
+ )
+ detail = "\n\n".join(
+ value
+ for value in [
+ pretty(raw.get("arguments")),
+ pretty(raw.get("result")) if raw.get("result") is not None else "",
+ pretty(raw.get("error")) if raw.get("error") else "",
+ item.output,
+ ]
+ if value
+ )
+ else:
+ title = native_kind or "Native item"
+ detail = pretty(raw)
+ source: JsonObject = {
+ "item": dict(raw),
+ "stream": {
+ "text": item.text,
+ "output": item.output,
+ "summary": {
+ str(index): value for index, value in sorted(item.summary.items())
+ },
+ "reasoning": {
+ str(index): value for index, value in sorted(item.reasoning.items())
+ },
+ },
+ }
+ return ItemUpdate(
+ turn_id,
+ item_id,
+ kind,
+ text=text,
+ title=title,
+ detail=detail,
+ raw=source,
+ complete=complete,
+ client_id=string_value(raw.get("clientId")) or None,
+ )
+
+
+class NativePrompt:
+ def __init__(self, method: str, request_id: str | int, params: JsonObject) -> None:
+ self.method, self.request_id, self.params = method, request_id, params
+ self.decisions: list[JsonValue] = []
+ self.grants: dict[str, tuple[str, JsonValue]] = {}
+ self.kind, self.form = self._form()
+
+ def request(self) -> PromptRequest:
+ return PromptRequest(
+ self.request_id,
+ self.kind,
+ self.form,
+ dict(self.params),
+ string_value(self.params.get("turnId")) or None,
+ string_value(self.params.get("itemId")) or None,
+ )
+
+ def _form(self) -> tuple[str, JsonObject]:
+ params = self.params
+ if self.method in {
+ "item/commandExecution/requestApproval",
+ "item/fileChange/requestApproval",
+ }:
+ offered = params.get("availableDecisions")
+ self.decisions = (
+ array_value(offered)
+ if isinstance(offered, list)
+ else ["accept", "acceptForSession", "decline", "cancel"]
+ )
+ labels = {
+ "accept": "Allow once",
+ "acceptForSession": "Allow for this session",
+ "decline": "Decline",
+ "cancel": "Cancel turn",
+ }
+ choices: list[JsonValue] = []
+ for index, decision in enumerate(self.decisions):
+ if isinstance(decision, str):
+ label = labels.get(decision, decision)
+ elif "acceptWithExecpolicyAmendment" in object_value(decision):
+ amendment = object_value(
+ object_value(decision).get("acceptWithExecpolicyAmendment")
+ )
+ label = "Allow and remember command prefix: " + " ".join(
+ string_value(value)
+ for value in array_value(amendment.get("execpolicy_amendment"))
+ )
+ else:
+ label = "Apply requested network rule: " + pretty(decision)
+ choices.append({"id": str(index), "label": label})
+ details = [
+ string_value(params.get(key))
+ for key in ("command", "cwd", "grantRoot", "reason")
+ ]
+ if params.get("additionalPermissions"):
+ details.append(pretty(params["additionalPermissions"]))
+ return "approval", {
+ "title": "Permission requested",
+ "detail": "\n".join(value for value in details if value),
+ "choices": choices,
+ }
+ if self.method == "item/tool/requestUserInput":
+ questions: list[JsonValue] = []
+ for value in array_value(params.get("questions")):
+ question = object_value(value)
+ questions.append(
+ {
+ "id": question.get("id"),
+ "label": question.get("question"),
+ "header": question.get("header"),
+ "options": question.get("options"),
+ "allow_other": question.get("isOther", False),
+ "secret": question.get("isSecret", False),
+ }
+ )
+ return "questions", {
+ "title": "Codex needs your input",
+ "questions": questions,
+ }
+ if self.method == "item/permissions/requestApproval":
+ permissions = object_value(params.get("permissions"))
+ choices: list[JsonValue] = []
+ if object_value(permissions.get("network")).get("enabled") is True:
+ self.grants["network"] = ("network", {"enabled": True})
+ choices.append({"id": "network", "label": "Network access"})
+ files = object_value(permissions.get("fileSystem"))
+ for access in ("read", "write", "entries"):
+ for index, grant in enumerate(array_value(files.get(access))):
+ if (
+ access == "entries"
+ and object_value(grant).get("access") == "deny"
+ ):
+ continue
+ key = f"{access}:{index}"
+ self.grants[key] = (access, grant)
+ label = (
+ f"{access.title()}: {grant}"
+ if access != "entries"
+ else pretty(grant)
+ )
+ choices.append({"id": key, "label": label})
+ return "permissions", {
+ "title": "Additional permissions",
+ "detail": string_value(params.get("reason")),
+ "choices": choices,
+ }
+ if self.method == "mcpServer/elicitation/request":
+ mode = params.get("mode")
+ form: JsonObject = {
+ "title": string_value(params.get("serverName")) or "Tool question",
+ "detail": string_value(params.get("message")),
+ }
+ if mode == "url":
+ form["url"] = params.get("url")
+ return "url", form
+ schema = object_value(params.get("requestedSchema"))
+ fields: list[JsonValue] = []
+ unsupported = mode != "form" or schema.get("type") != "object"
+ required = array_value(schema.get("required"))
+ for name, value in object_value(schema.get("properties")).items():
+ definition = object_value(value)
+ field_type = string_value(definition.get("type"))
+ if field_type not in {
+ "string",
+ "integer",
+ "number",
+ "boolean",
+ "array",
+ }:
+ unsupported = True
+ choices = _enum_options(definition)
+ if field_type == "array" and (
+ not choices
+ or any(
+ not isinstance(object_value(choice).get("value"), str)
+ for choice in choices
+ )
+ ):
+ unsupported = True
+ fields.append(
+ {
+ "id": name,
+ "label": definition.get("title", name),
+ "description": definition.get("description"),
+ "type": field_type,
+ "required": name in required,
+ "options": choices,
+ "default": definition.get("default"),
+ "minimum": definition.get("minimum"),
+ "maximum": definition.get("maximum"),
+ "minLength": definition.get("minLength"),
+ "maxLength": definition.get("maxLength"),
+ }
+ )
+ form.update({"fields": fields, "unsupported": unsupported})
+ return "form", form
+ raise CodeValidationError(f"Unsupported native interaction: {self.method}")
+
+ def answer(self, answer: JsonObject) -> JsonObject:
+ if self.kind == "approval":
+ choice = answer.get("choice")
+ if not isinstance(choice, str) or choice not in {
+ str(index) for index in range(len(self.decisions))
+ }:
+ raise CodeValidationError("Choose one of the offered decisions.")
+ return {"decision": self.decisions[int(choice)]}
+ if self.kind == "questions":
+ values = object_value(answer.get("answers"))
+ questions = [
+ object_value(value)
+ for value in array_value(self.params.get("questions"))
+ ]
+ if set(values) != {
+ string_value(question.get("id")) for question in questions
+ }:
+ raise CodeValidationError("Answer each question before submitting.")
+ result: JsonObject = {}
+ for question in questions:
+ key = string_value(question.get("id"))
+ entries = array_value(values.get(key))
+ if not entries or any(
+ not isinstance(value, str) or not value.strip() for value in entries
+ ):
+ raise CodeValidationError("Answer each question before submitting.")
+ options = {
+ string_value(object_value(value).get("label"))
+ for value in array_value(question.get("options"))
+ }
+ if (
+ options
+ and not question.get("isOther")
+ and any(value not in options for value in entries)
+ ):
+ raise CodeValidationError("Choose an offered answer.")
+ result[key] = {"answers": entries}
+ return {"answers": result}
+ if self.kind == "permissions":
+ selected = array_value(answer.get("selected"))
+ if any(
+ not isinstance(value, str) or value not in self.grants
+ for value in selected
+ ) or answer.get("scope", "turn") not in {"turn", "session"}:
+ raise CodeValidationError(
+ "Choose only the requested permissions and scope."
+ )
+ permissions: JsonObject = {}
+ files: JsonObject = {}
+ requested_files = object_value(
+ object_value(self.params.get("permissions")).get("fileSystem")
+ )
+ denies = [
+ value
+ for value in array_value(requested_files.get("entries"))
+ if object_value(value).get("access") == "deny"
+ ]
+ if denies:
+ files["entries"] = denies
+ for key in selected:
+ access, value = self.grants[string_value(key)]
+ if access == "network":
+ permissions["network"] = value
+ else:
+ files[access] = [*array_value(files.get(access)), value]
+ if files:
+ if requested_files.get("globScanMaxDepth") is not None:
+ files["globScanMaxDepth"] = requested_files["globScanMaxDepth"]
+ permissions["fileSystem"] = files
+ return {"permissions": permissions, "scope": answer.get("scope", "turn")}
+ action = answer.get("action")
+ if action not in {"accept", "decline", "cancel"}:
+ raise CodeValidationError(
+ "Choose whether to answer or dismiss this prompt."
+ )
+ if action != "accept":
+ return {"action": action, "content": None}
+ if self.kind == "url":
+ return {"action": "accept", "content": None}
+ if self.form.get("unsupported"):
+ raise CodeValidationError(
+ "This tool's form is not supported. Decline or cancel it."
+ )
+ values = object_value(answer.get("values"))
+ schema = object_value(self.params.get("requestedSchema"))
+ properties = object_value(schema.get("properties"))
+ if not set(values).issubset(properties) or any(
+ name not in values for name in array_value(schema.get("required"))
+ ):
+ raise CodeValidationError("Complete the required fields.")
+ for name, value in values.items():
+ _validate_field(name, value, object_value(properties[name]))
+ return {"action": "accept", "content": values}
+
+
+def _enum_options(definition: JsonObject) -> list[JsonValue]:
+ if definition.get("type") == "array":
+ definition = object_value(definition.get("items"))
+ values = array_value(definition.get("enum"))
+ names = array_value(definition.get("enumNames"))
+ if values:
+ return [
+ {"value": value, "label": names[index] if index < len(names) else value}
+ for index, value in enumerate(values)
+ ]
+ return [
+ {
+ "value": object_value(value).get("const"),
+ "label": object_value(value).get("title"),
+ }
+ for value in array_value(definition.get("oneOf", definition.get("anyOf")))
+ ]
+
+
+def _validate_field(name: str, value: JsonValue, definition: JsonObject) -> None:
+ kind = definition.get("type")
+ valid = True
+ if kind == "boolean":
+ valid = isinstance(value, bool)
+ elif kind in {"number", "integer"}:
+ valid = (
+ isinstance(value, int | float)
+ and not isinstance(value, bool)
+ and math.isfinite(value)
+ )
+ if valid and kind == "integer":
+ valid = isinstance(value, int)
+ if valid and isinstance(value, int | float):
+ minimum, maximum = definition.get("minimum"), definition.get("maximum")
+ valid = (not isinstance(minimum, int | float) or value >= minimum) and (
+ not isinstance(maximum, int | float) or value <= maximum
+ )
+ elif kind == "string":
+ valid = isinstance(value, str)
+ if isinstance(value, str):
+ minimum, maximum = definition.get("minLength"), definition.get("maxLength")
+ valid = (not isinstance(minimum, int) or len(value) >= minimum) and (
+ not isinstance(maximum, int) or len(value) <= maximum
+ )
+ format_name = definition.get("format")
+ if isinstance(format_name, str):
+ valid = valid and FormatChecker().conforms(value, format_name)
+ elif kind == "array":
+ valid = isinstance(value, list) and all(
+ isinstance(entry, str) for entry in value
+ )
+ if valid and isinstance(value, list):
+ minimum, maximum = definition.get("minItems"), definition.get("maxItems")
+ valid = (not isinstance(minimum, int) or len(value) >= minimum) and (
+ not isinstance(maximum, int) or len(value) <= maximum
+ )
+ else:
+ valid = False
+ options = [
+ object_value(option).get("value") for option in _enum_options(definition)
+ ]
+ if options:
+ candidates = array_value(value) if kind == "array" else [value]
+ valid = valid and all(candidate in options for candidate in candidates)
+ if not valid:
+ raise CodeValidationError(f"Invalid value for {name}.")
diff --git a/tests/api/support.py b/tests/api/support.py
index 60df99d3..c52dc341 100644
--- a/tests/api/support.py
+++ b/tests/api/support.py
@@ -7,6 +7,7 @@ from fastapi import FastAPI
from free_claude_code.api.app import create_app
from free_claude_code.api.ports import ApiServices
from free_claude_code.application.chat import ChatApplicationPort
+from free_claude_code.application.code_sessions import CodeApplicationPort
from free_claude_code.application.connected_accounts import ConnectedAccountPort
from free_claude_code.config.loader import ManagedConfigStore
from free_claude_code.config.settings import Settings
@@ -24,6 +25,7 @@ def create_test_app(
restart_callback: RestartCallback | None = None,
connected_accounts: Mapping[str, ConnectedAccountPort] | None = None,
chat: ChatApplicationPort | None = None,
+ code: CodeApplicationPort | None = None,
) -> FastAPI:
"""Build an API app with explicit in-memory runtime services."""
store = ManagedConfigStore()
@@ -65,6 +67,7 @@ def create_test_app(
admin=runtime,
tasks=runtime,
chat=chat,
+ code=code,
)
)
diff --git a/tests/api/test_admin.py b/tests/api/test_admin.py
index 7210be08..3cd60bf7 100644
--- a/tests/api/test_admin.py
+++ b/tests/api/test_admin.py
@@ -178,6 +178,7 @@ def test_admin_page_uses_installed_version(monkeypatch, tmp_path):
("admin.js", "text/javascript"),
("chat_sessions.css", "text/css"),
("chat_sessions.js", "text/javascript"),
+ ("session_ui.js", "text/javascript"),
("model_combobox.js", "text/javascript"),
),
)
diff --git a/tests/api/test_chat_markdown.py b/tests/api/test_chat_markdown.py
index fdee0d7e..4e65ff0f 100644
--- a/tests/api/test_chat_markdown.py
+++ b/tests/api/test_chat_markdown.py
@@ -1,8 +1,8 @@
-from free_claude_code.api.chat_markdown import render_chat_markdown
+from free_claude_code.api.markdown import render_markdown
def test_chat_markdown_escapes_html_and_never_loads_remote_images():
- rendered = render_chat_markdown(
+ rendered = render_markdown(
'<script>alert("x")</script>\n\n![diagram](https://example.com/image.png)'
)
@@ -14,7 +14,7 @@ def test_chat_markdown_escapes_html_and_never_loads_remote_images():
def test_chat_markdown_disables_non_http_links():
- rendered = render_chat_markdown("[unsafe](javascript:alert(1))")
+ rendered = render_markdown("[unsafe](javascript:alert(1))")
assert "href=" not in rendered
assert "unsafe" in rendered
diff --git a/tests/api/test_chat_routes.py b/tests/api/test_chat_routes.py
index 2458b48d..dd9df64e 100644
--- a/tests/api/test_chat_routes.py
+++ b/tests/api/test_chat_routes.py
@@ -8,13 +8,11 @@ from free_claude_code.application.chat import (
ChatActiveOperation,
ChatCompaction,
ChatContextEstimate,
- ChatEventOverflowError,
ChatModelOption,
ChatOperationAcknowledgement,
ChatOperationKind,
ChatOperationPhase,
ChatPreferences,
- ChatPublishedEvent,
ChatReasoning,
ChatSegment,
ChatSession,
@@ -27,6 +25,10 @@ from free_claude_code.application.chat import (
SegmentKind,
)
from free_claude_code.application.chat.models import ChatGeneration
+from free_claude_code.application.session_events import (
+ EventOverflowError,
+ PublishedEvent,
+)
from free_claude_code.core.model_capabilities import ModelInputModality
from tests.api.support import create_test_app
@@ -44,7 +46,7 @@ class StubSubscription:
return self._events()
async def _events(self):
- yield ChatPublishedEvent(
+ yield PublishedEvent(
event="turn.completed",
id=5,
data={
@@ -65,7 +67,7 @@ class OverflowSubscription(StubSubscription):
async def _events(self):
if False:
yield
- raise ChatEventOverflowError(9)
+ raise EventOverflowError(9)
class StubChat:
diff --git a/tests/api/test_code_sessions_routes.py b/tests/api/test_code_sessions_routes.py
new file mode 100644
index 00000000..ead849da
--- /dev/null
+++ b/tests/api/test_code_sessions_routes.py
@@ -0,0 +1,126 @@
+import asyncio
+import uuid
+
+import httpx
+import pytest
+import pytest_asyncio
+
+from free_claude_code.application.code_sessions import CodeService
+from free_claude_code.runtime.code_sessions_sqlite import SQLiteCodeStore
+from tests.api.support import create_test_app
+from tests.code_sessions_support import FakeHarness
+
+
+@pytest_asyncio.fixture
+async def code_api(tmp_path):
+ harness = FakeHarness()
+ code = CodeService(
+ SQLiteCodeStore(tmp_path / "code.db", tmp_path / "code.lock"), harness
+ )
+ await code.start()
+ app = create_test_app(code=code)
+ try:
+ async with httpx.AsyncClient(
+ transport=httpx.ASGITransport(app=app), base_url="http://127.0.0.1"
+ ) as client:
+ yield client, code, harness, tmp_path, app
+ finally:
+ await code.close()
+ await app.state.services.admin.close()
+
+
+async def create_session(code_api):
+ client, _, _, folder, _ = code_api
+ response = await client.post(
+ "/admin/api/code/sessions",
+ json={"session_id": str(uuid.uuid4()), "cwd": str(folder), "harness": "codex"},
+ )
+ assert response.status_code == 201
+ return response.json()
+
+
+async def test_code_library_has_one_harness_and_no_native_work_on_open(code_api):
+ client, _, harness, _, _ = code_api
+ bootstrap = await client.get("/admin/api/code/bootstrap")
+ assert bootstrap.json()["harnesses"] == [{"id": "codex", "name": "Codex"}]
+ session = await create_session(code_api)
+ detail = await client.get(f"/admin/api/code/sessions/{session['id']}")
+ assert detail.status_code == 200
+ assert detail.headers["cache-control"] == "no-store"
+ assert detail.json()["items"] == []
+ assert harness.connections == []
+ page = await client.get(f"/admin/code/{session['id']}")
+ assert page.status_code == 200
+
+
+async def test_http_send_competition_and_safe_item_projection(code_api):
+ client, code, harness, _, _ = code_api
+ session = await create_session(code_api)
+ path = f"/admin/api/code/sessions/{session['id']}"
+ responses = await asyncio.gather(
+ *(
+ client.post(
+ path + "/turns",
+ json={
+ "operation_id": str(uuid.uuid4()),
+ "expected_revision": session["revision"],
+ "expected_epoch": code.epoch,
+ "text": text,
+ },
+ )
+ for text in ("one", "two")
+ )
+ )
+ assert sorted(response.status_code for response in responses) == [202, 409]
+ await harness.started.wait()
+ await harness.connections[0].text(
+ "turn-1", "answer", "**safe** <script>bad()</script>", complete=True
+ )
+ await harness.connections[0].finish("turn-1")
+ detail = (await client.get(path)).json()
+ item = detail["items"][-1]
+ assert "<strong>safe</strong>" in item["html"]
+ assert "<script>" not in item["html"]
+ assert "raw" not in item
+ assert detail["run"]["status"] == "completed"
+
+
+async def test_code_commands_reject_unplanned_fields_and_other_harnesses(code_api):
+ client, code, _, folder, _ = code_api
+ response = await client.post(
+ "/admin/api/code/sessions",
+ json={"session_id": str(uuid.uuid4()), "cwd": str(folder), "harness": "cline"},
+ )
+ assert response.status_code == 422
+ session = await create_session(code_api)
+ response = await client.post(
+ f"/admin/api/code/sessions/{session['id']}/turns",
+ json={
+ "operation_id": str(uuid.uuid4()),
+ "expected_revision": session["revision"],
+ "expected_epoch": code.epoch,
+ "text": "hi",
+ "model": "override",
+ },
+ )
+ assert response.status_code == 422
+
+
+ "headers", [{"host": "remote.example"}, {"origin": "https://remote.example"}]
+)
+async def test_code_routes_share_admin_access_boundary(code_api, headers):
+ client, _, harness, _, _ = code_api
+ for path in (
+ "/admin/code",
+ "/admin/api/code/bootstrap",
+ "/admin/api/code/sessions",
+ "/admin/api/code/events",
+ ):
+ response = await client.get(path, headers=headers)
+ assert response.status_code == 403
+ assert harness.connections == []
diff --git a/tests/application/test_chat_events.py b/tests/application/test_chat_events.py
index a41ae74b..3f6f7f38 100644
--- a/tests/application/test_chat_events.py
+++ b/tests/application/test_chat_events.py
@@ -2,13 +2,15 @@ import asyncio
import pytest
-from free_claude_code.application.chat import ChatEventOverflowError
-from free_claude_code.application.chat.events import ChatEventPublisher
+from free_claude_code.application.session_events import (
+ EventOverflowError,
+ EventPublisher,
+)
@pytest.mark.asyncio
async def test_subscribers_receive_the_same_ordered_events_independently() -> None:
- publisher = ChatEventPublisher(queue_size=4)
+ publisher = EventPublisher(queue_size=4)
first = publisher.subscribe()
second = publisher.subscribe()
first_events = first.__aiter__()
@@ -34,7 +36,7 @@ async def test_subscribers_receive_the_same_ordered_events_independently() -> No
@pytest.mark.asyncio
async def test_slow_subscriber_overflow_does_not_block_a_healthy_subscriber() -> None:
- publisher = ChatEventPublisher(queue_size=2)
+ publisher = EventPublisher(queue_size=2)
slow = publisher.subscribe()
healthy = publisher.subscribe()
slow_events = slow.__aiter__()
@@ -47,7 +49,7 @@ async def test_slow_subscriber_overflow_does_not_block_a_healthy_subscriber() ->
)
assert await asyncio.wait_for(anext(healthy_events), timeout=1) == published
- with pytest.raises(ChatEventOverflowError) as raised:
+ with pytest.raises(EventOverflowError) as raised:
await asyncio.wait_for(anext(slow_events), timeout=1)
assert raised.value.cursor == 3
@@ -60,7 +62,7 @@ async def test_slow_subscriber_overflow_does_not_block_a_healthy_subscriber() ->
@pytest.mark.asyncio
async def test_publisher_close_releases_every_waiting_subscription() -> None:
- publisher = ChatEventPublisher()
+ publisher = EventPublisher()
first = publisher.subscribe().__aiter__()
second = publisher.subscribe().__aiter__()
diff --git a/tests/application/test_code_sessions.py b/tests/application/test_code_sessions.py
new file mode 100644
index 00000000..836d0896
--- /dev/null
+++ b/tests/application/test_code_sessions.py
@@ -0,0 +1,1005 @@
+import asyncio
+import uuid
+
+import pytest
+import pytest_asyncio
+
+from free_claude_code.application.code_sessions import CodeConflictError, CodeService
+from free_claude_code.application.code_sessions.models import (
+ CodeUnavailableError,
+ CodeValidationError,
+ HarnessEvent,
+ ItemUpdate,
+)
+from free_claude_code.runtime.code_sessions_sqlite import SQLiteCodeStore
+from tests.code_sessions_support import FakeConnection, FakeHarness
+
+
+def new_id():
+ return str(uuid.uuid4())
+
+
+@pytest_asyncio.fixture
+async def code(tmp_path):
+ harness = FakeHarness()
+ store = SQLiteCodeStore(tmp_path / "code.db", tmp_path / "code.lock")
+ service = CodeService(store, harness)
+ await service.start()
+ try:
+ yield service, harness, tmp_path
+ finally:
+ await service.close()
+
+
+async def session_for(code):
+ service, _, directory = code
+ return await service.create_session(new_id(), str(directory))
+
+
+async def test_selected_model_and_effort_are_session_settings_captured_on_send(code):
+ service, harness, _ = code
+ harness.configurations["provider/other"] = "other"
+ session = await session_for(code)
+ for effort in (None, "high", None):
+ session = await service.update_settings(
+ session.id,
+ session.revision,
+ {"model": "provider/other", "reasoning_effort": effort},
+ )
+ run = await service.send(
+ session.id,
+ new_id(),
+ session.revision,
+ "hello",
+ expected_epoch=service.epoch,
+ )
+ await harness.wait_inputs(run.ordinal)
+ connection = harness.connections[0]
+ with pytest.raises(CodeConflictError):
+ await service.update_settings(
+ session.id, session.revision + 1, {"reasoning_effort": "low"}
+ )
+ await connection.finish(f"turn-{run.ordinal}")
+ session = (await service.get_detail(session.id)).session
+ assert connection.efforts == ["medium", "high", "medium"]
+ assert {value[2] for value in connection.inputs} == {"provider/other"}
+ assert len(harness.connections) == 1
+ harness.configurations.pop("provider/other")
+ with pytest.raises(CodeValidationError, match="unavailable"):
+ await service.send(
+ session.id,
+ new_id(),
+ session.revision,
+ "kept draft",
+ expected_epoch=service.epoch,
+ )
+ assert (await service.get_detail(session.id)).session.model == "provider/other"
+
+
+async def test_catalog_effort_removal_requires_choice_but_model_change_resolves_default(
+ code,
+):
+ service, harness, _ = code
+ session = await session_for(code)
+ session = await service.update_settings(
+ session.id, session.revision, {"reasoning_effort": "xhigh"}
+ )
+ harness.efforts = ("low", "medium")
+ with pytest.raises(CodeValidationError, match="effort"):
+ await service.send(
+ session.id,
+ new_id(),
+ session.revision,
+ "hello",
+ expected_epoch=service.epoch,
+ )
+ harness.configurations["provider/other"] = "other"
+ session = await service.update_settings(
+ session.id, session.revision, {"model": "provider/other"}
+ )
+ assert session.reasoning_effort is None
+ assert session.model == "provider/other"
+
+
+async def test_failed_outcome_is_durable_once_after_partial_output_and_older_pagination(
+ code,
+):
+ service, harness, _ = code
+ session = await session_for(code)
+ run = await service.send(
+ session.id, new_id(), session.revision, "first", expected_epoch=service.epoch
+ )
+ await harness.started.wait()
+ connection = harness.connections[0]
+ for kind in ("text", "reasoning", "tool"):
+ await connection.text("turn-1", kind, f"partial {kind}", kind=kind)
+ await connection.finish("turn-1", "failed", "Provider rejected the request")
+ await connection.finish("turn-1", "failed", "duplicate")
+ detail = await service.get_detail(session.id)
+ assert detail.session.error is None
+ assert detail.runs == (detail.run,)
+ assert detail.run.error == "Provider rejected the request"
+ assert [item.text for item in detail.items] == [
+ "first",
+ "partial text",
+ "partial reasoning",
+ "partial tool",
+ ]
+ await service.send(
+ session.id,
+ new_id(),
+ detail.session.revision,
+ "second",
+ expected_epoch=service.epoch,
+ )
+ await harness.wait_inputs(2)
+ for index in range(55):
+ await connection.text("turn-2", str(index), str(index), complete=True)
+ active = await service.get_detail(session.id)
+ assert active.items[0].text == "first"
+ assert len(active.items) == 60
+ await connection.finish("turn-2")
+ latest = await service.get_detail(session.id)
+ assert run.id not in {value.id for value in latest.runs}
+ older = await service.get_detail(session.id, before=latest.next_before)
+ assert (
+ next(value for value in older.runs if value.id == run.id).error
+ == detail.run.error
+ )
+
+
+async def test_retry_notice_does_not_finish_run_and_stale_error_is_ignored(code):
+ service, harness, _ = code
+ session = await session_for(code)
+ await service.send(
+ session.id, new_id(), session.revision, "hello", expected_epoch=service.epoch
+ )
+ await harness.started.wait()
+ connection = harness.connections[0]
+ await connection.sink(
+ HarnessEvent(
+ connection.generation,
+ connection.thread_id,
+ "error",
+ turn_id="turn-1",
+ message="retry",
+ will_retry=True,
+ )
+ )
+ assert (await service.get_detail(session.id)).run.status == "running"
+ await connection.text("turn-1", "text", "success", complete=True)
+ await connection.finish("turn-1")
+ subscription, _ = await service.subscribe()
+ cursor = service.cursor
+ await connection.sink(
+ HarnessEvent(
+ connection.generation,
+ connection.thread_id,
+ "error",
+ turn_id="turn-1",
+ message="stale",
+ )
+ )
+ assert service.cursor == cursor
+ await subscription.aclose()
+ assert (await service.get_detail(session.id)).run.error is None
+
+
[email protected]("client_id", [True, False])
+async def test_acknowledgement_loss_recovers_old_turn_before_newer_send(
+ code, client_id
+):
+ service, harness, _ = code
+ session = await session_for(code)
+ harness.start_gate.clear()
+ first = await service.send(
+ session.id, new_id(), session.revision, "first", expected_epoch=service.epoch
+ )
+ await harness.submitted.wait()
+ connection = harness.connections[0]
+ harness.histories[connection.thread_id] = [
+ ItemUpdate(
+ "turn-1",
+ "native-user",
+ "user",
+ text="first",
+ complete=True,
+ client_id=first.id if client_id else None,
+ ),
+ ItemUpdate("turn-1", "tail", "text", text="recovered tail", complete=True),
+ ]
+ await connection.close()
+ await service.wait_idle(session.id)
+ detail = await service.get_detail(session.id)
+ assert detail.run.status == "failed"
+ await service.send(
+ session.id,
+ new_id(),
+ detail.session.revision,
+ "second",
+ expected_epoch=service.epoch,
+ )
+ await harness.wait_inputs(2)
+ recovered = await service.get_detail(session.id)
+ assert [item.text for item in recovered.items] == [
+ "first",
+ "recovered tail",
+ "second",
+ ]
+ assert recovered.runs[0].status == "failed"
+ assert recovered.items[0].id == first.id
+
+
+async def test_prompt_membership_and_deleted_subscription_are_authoritative(code):
+ service, harness, _ = code
+ session = await session_for(code)
+ await service.send(
+ session.id, new_id(), session.revision, "first", expected_epoch=service.epoch
+ )
+ await harness.started.wait()
+ connection = harness.connections[0]
+ await connection.prompt(0, turn_id=None)
+ detail = await service.get_detail(session.id)
+ assert detail.active_prompt_ids == (detail.prompts[0].id,)
+ await connection.resolve(0)
+ assert (await service.get_detail(session.id)).active_prompt_ids == ()
+ await connection.finish("turn-1")
+ session = (await service.get_detail(session.id)).session
+ await service.delete_session(session.id, session.revision)
+ await service.wait_idle(session.id)
+ subscription, ready = await service.subscribe()
+ assert ready["sessions"] == []
+ assert session.id not in service._owners
+ await subscription.aclose()
+
+
+async def test_ambiguous_native_history_fails_recovery_without_resending_input(code):
+ service, harness, _ = code
+ session = await session_for(code)
+ harness.start_gate.clear()
+ await service.send(
+ session.id, new_id(), session.revision, "first", expected_epoch=service.epoch
+ )
+ await harness.submitted.wait()
+ connection = harness.connections[0]
+ harness.histories[connection.thread_id] = [
+ ItemUpdate(turn_id, "item", "text", text="unmatched", complete=True)
+ for turn_id in ("unknown-1", "unknown-2")
+ ]
+ await connection.close()
+ await service.wait_idle(session.id)
+ detail = await service.get_detail(session.id)
+ await service.send(
+ session.id,
+ new_id(),
+ detail.session.revision,
+ "second",
+ expected_epoch=service.epoch,
+ )
+ await service.wait_idle(session.id)
+ detail = await service.get_detail(session.id)
+ assert detail.run.status == "failed"
+ assert "could not be matched" in detail.run.error
+ assert [item.text for item in detail.items] == ["first", "second"]
+ assert sum(len(connection.inputs) for connection in harness.connections) == 1
+
+
+async def test_settings_and_send_compete_for_the_same_revision(code):
+ service, harness, _ = code
+ session = await session_for(code)
+ outcomes = await asyncio.gather(
+ service.update_settings(
+ session.id, session.revision, {"reasoning_effort": "high"}
+ ),
+ service.send(
+ session.id,
+ new_id(),
+ session.revision,
+ "hello",
+ expected_epoch=service.epoch,
+ ),
+ return_exceptions=True,
+ )
+ assert sum(isinstance(result, CodeConflictError) for result in outcomes) == 1
+ detail = await service.get_detail(session.id)
+ assert detail.session.revision == session.revision + 1
+ if detail.run:
+ assert detail.run.reasoning_effort == "medium"
+ else:
+ assert detail.session.reasoning_effort == "high"
+ assert harness.connections == []
+
+
+async def test_old_service_epoch_cannot_admit_a_new_send_but_can_read_receipt(code):
+ service, harness, _ = code
+ session = await session_for(code)
+ with pytest.raises(CodeConflictError, match="restarted"):
+ await service.send(
+ session.id, new_id(), session.revision, "stale", expected_epoch="previous"
+ )
+ assert harness.connections == []
+ run = await service.send(
+ session.id, new_id(), session.revision, "accepted", expected_epoch=service.epoch
+ )
+ repeated = await service.send(
+ session.id, run.id, session.revision, "accepted", expected_epoch="previous"
+ )
+ assert repeated.id == run.id
+
+
+async def test_poorer_native_history_keeps_captured_source_and_reasoning(code):
+ service, harness, _ = code
+ session = await session_for(code)
+ await service.send(
+ session.id, new_id(), session.revision, "first", expected_epoch=service.epoch
+ )
+ await harness.started.wait()
+ connection = harness.connections[0]
+ original = ItemUpdate(
+ "turn-1",
+ "reasoning",
+ "reasoning",
+ text="Full captured reasoning",
+ complete=True,
+ raw={
+ "item": {
+ "id": "reasoning",
+ "summary": ["original"],
+ "opaque": {"signature": "retained"},
+ },
+ "stream": {"reasoning": {"0": "full"}},
+ },
+ )
+ await connection.sink(
+ HarnessEvent(
+ connection.generation,
+ connection.thread_id,
+ "item",
+ turn_id="turn-1",
+ item=original,
+ )
+ )
+ await connection.finish("turn-1")
+ harness.histories[connection.thread_id] = [
+ ItemUpdate(
+ "turn-1",
+ "reasoning",
+ "reasoning",
+ text="Shorter native history",
+ complete=True,
+ raw={"item": {"id": "reasoning", "summary": []}, "stream": {}},
+ )
+ ]
+ harness.configurations[harness.model] = "changed"
+ detail = await service.get_detail(session.id)
+ await service.send(
+ session.id,
+ new_id(),
+ detail.session.revision,
+ "next",
+ expected_epoch=service.epoch,
+ )
+ await harness.wait_inputs(2)
+ retained = next(
+ item
+ for item in (await service.get_detail(session.id)).items
+ if item.native_item_id == "reasoning"
+ )
+ assert retained.text == original.text
+ assert retained.raw == original.raw
+
+
+async def test_storage_start_failure_is_isolated_to_code(tmp_path):
+ class BrokenStore(SQLiteCodeStore):
+ async def start(self):
+ raise CodeUnavailableError("Code disk unavailable")
+
+ service = CodeService(
+ BrokenStore(tmp_path / "code.db", tmp_path / "code.lock"), FakeHarness()
+ )
+ try:
+ await service.start()
+ assert service.availability() == (False, "Code disk unavailable")
+ finally:
+ await service.close()
+
+
+async def test_shutdown_settles_run_when_native_interrupt_never_acknowledges(code):
+ service, harness, _ = code
+ session = await session_for(code)
+ await service.send(
+ session.id,
+ new_id(),
+ session.revision,
+ "stop on shutdown",
+ expected_epoch=service.epoch,
+ )
+ await harness.started.wait()
+ harness.interrupt_gate.clear()
+ await asyncio.wait_for(service.close(), 8)
+ assert harness.connections[0].closed
+
+
+async def test_storage_failure_retires_native_work_even_with_pending_prompt(
+ code, monkeypatch
+):
+ service, harness, _ = code
+ session = await session_for(code)
+ await service.send(
+ session.id, new_id(), session.revision, "prompt", expected_epoch=service.epoch
+ )
+ await harness.started.wait()
+ connection = harness.connections[0]
+ await connection.prompt(1)
+
+ async def fail_save(*args, **kwargs):
+ raise CodeUnavailableError("Code disk unavailable")
+
+ monkeypatch.setattr(service._store, "save_progress", fail_save)
+ await connection.text("turn-1", "text", "unsaved", complete=True)
+ await asyncio.wait_for(service.wait_idle(session.id), 3)
+ assert connection.closed
+ with pytest.raises(CodeUnavailableError):
+ await service.get_detail(session.id)
+
+
+async def test_same_send_id_in_two_sessions_has_independent_receipts(code, monkeypatch):
+ service, harness, _ = code
+ first, second = await session_for(code), await session_for(code)
+ original = service._store.get_run
+ looked_up = 0
+ barrier = asyncio.Event()
+
+ async def simultaneous_lookup(session_id, run_id):
+ nonlocal looked_up
+ result = await original(session_id, run_id)
+ looked_up += 1
+ if looked_up == 2:
+ barrier.set()
+ await barrier.wait()
+ return result
+
+ monkeypatch.setattr(service._store, "get_run", simultaneous_lookup)
+ operation = new_id()
+ outcomes = await asyncio.gather(
+ *(
+ service.send(
+ session.id,
+ operation,
+ session.revision,
+ "once",
+ expected_epoch=service.epoch,
+ )
+ for session in (first, second)
+ ),
+ return_exceptions=True,
+ )
+ assert {
+ value.session_id for value in outcomes if not isinstance(value, BaseException)
+ } == {first.id, second.id}
+ await harness.wait_inputs(2)
+ assert sum(len(connection.inputs) for connection in harness.connections) == 2
+
+
+async def idle_native(code):
+ service, harness, _ = code
+ session = await session_for(code)
+ await service.send(
+ session.id, new_id(), session.revision, "one", expected_epoch=service.epoch
+ )
+ await harness.started.wait()
+ await harness.connections[0].finish("turn-1")
+ return (await service.get_detail(session.id)).session
+
+
+async def test_deletion_fences_commands_and_repeated_delete_has_one_native_call(code):
+ service, harness, folder = code
+ session = await idle_native(code)
+ project = folder / "project.txt"
+ project.write_text("keep")
+ harness.delete_gate.clear()
+ await service.delete_session(session.id, session.revision)
+ await harness.deleting.wait()
+ await service.delete_session(session.id, session.revision)
+ with pytest.raises(CodeConflictError):
+ await service.send(
+ session.id, new_id(), session.revision, "late", expected_epoch=service.epoch
+ )
+ with pytest.raises(CodeConflictError):
+ await service.update_settings(session.id, session.revision, {"title": "late"})
+ harness.delete_gate.set()
+ await service.wait_idle(session.id)
+ assert harness.connections[0].deleted == [session.native_thread_id]
+ assert project.read_text() == "keep"
+ assert not (await service.list_sessions()).sessions
+
+
+async def test_lost_native_delete_ack_reconciles_without_repeating_delete(code):
+ service, harness, _ = code
+ session = await idle_native(code)
+ harness.delete_before_error = True
+ harness.delete_error = CodeUnavailableError("Delete acknowledgement lost")
+ await service.delete_session(session.id, session.revision)
+ await service.wait_idle(session.id)
+ assert not (await service.list_sessions()).sessions
+ assert sum(len(connection.deleted) for connection in harness.connections) == 1
+
+
+async def test_local_delete_commit_failure_keeps_fence_and_can_reconcile(
+ code, monkeypatch
+):
+ service, harness, _ = code
+ session = await idle_native(code)
+ original = service._store.delete
+
+ async def failing_delete(session_id):
+ raise CodeUnavailableError("Delete commit failed")
+
+ monkeypatch.setattr(service._store, "delete", failing_delete)
+ await service.delete_session(session.id, session.revision)
+ await asyncio.wait_for(service.wait_idle(session.id), 3)
+ detail = await service.get_detail(session.id)
+ assert detail.session.status == "delete_uncertain"
+ assert detail.items
+ with pytest.raises(CodeConflictError):
+ await service.send(
+ session.id,
+ new_id(),
+ detail.session.revision,
+ "late",
+ expected_epoch=service.epoch,
+ )
+ monkeypatch.setattr(service._store, "delete", original)
+ await service.delete_session(session.id, detail.session.revision)
+ await service.wait_idle(session.id)
+ assert not (await service.list_sessions()).sessions
+ assert sum(len(connection.deleted) for connection in harness.connections) == 1
+
+
+async def test_late_old_native_events_cannot_claim_a_new_turn_before_ack(code):
+ service, harness, _ = code
+ session = await idle_native(code)
+ connection = harness.connections[0]
+ harness.start_gate.clear()
+ harness.started.clear()
+ await service.send(
+ session.id, new_id(), session.revision, "next", expected_epoch=service.epoch
+ )
+ await harness.wait_inputs(2)
+ await connection.sink(
+ HarnessEvent(
+ connection.generation,
+ connection.thread_id,
+ "turn_started",
+ turn_id="turn-1",
+ )
+ )
+ await connection.text("turn-1", "late", "obsolete", complete=True)
+ await connection.finish("turn-1")
+ detail = await service.get_detail(session.id)
+ assert detail.run.status == "preparing"
+ assert not any(item.text == "obsolete" for item in detail.items)
+ harness.start_gate.set()
+ await harness.started.wait()
+ detail = await service.get_detail(session.id)
+ assert detail.run.native_turn_id == "turn-2"
+
+
+async def test_creation_identity_received_during_cleanup_is_saved(code, monkeypatch):
+ service, harness, _ = code
+ session = await session_for(code)
+ original_close = FakeConnection.close
+
+ async def failed_create(connection):
+ raise CodeUnavailableError("Native creation acknowledgement timed out")
+
+ async def close_with_late_reply(connection):
+ connection.thread_id = "late-native-id"
+ harness.histories[connection.thread_id] = []
+ await original_close(connection)
+
+ monkeypatch.setattr(FakeConnection, "create_thread", failed_create)
+ monkeypatch.setattr(FakeConnection, "close", close_with_late_reply)
+ await service.send(
+ session.id,
+ new_id(),
+ session.revision,
+ "uncertain create",
+ expected_epoch=service.epoch,
+ )
+ await service.wait_idle(session.id)
+ detail = await service.get_detail(session.id)
+ assert detail.session.native_thread_id == "late-native-id"
+ assert detail.run.status == "failed"
+ assert not harness.connections[0].inputs
+
+
+async def test_failed_stop_persistence_closes_work_without_waiting_for_more_output(
+ code, monkeypatch
+):
+ service, harness, _ = code
+ session = await session_for(code)
+ run = await service.send(
+ session.id,
+ new_id(),
+ session.revision,
+ "quiet work",
+ expected_epoch=service.epoch,
+ )
+ await harness.started.wait()
+
+ async def failed_save(*args, **kwargs):
+ raise CodeUnavailableError("Disk failed")
+
+ monkeypatch.setattr(service._store, "save_progress", failed_save)
+ with pytest.raises(CodeUnavailableError):
+ await service.stop(session.id, run.id)
+ await asyncio.wait_for(service.wait_idle(session.id), 3)
+ assert harness.connections[0].closed
+
+
+async def test_create_is_lazy_and_retry_does_not_duplicate(code):
+ service, harness, directory = code
+ session = await session_for(code)
+ repeated = await service.create_session(session.id, str(directory))
+ assert repeated == session
+ assert harness.connections == []
+ assert len((await service.list_sessions()).sessions) == 1
+
+
+async def test_competing_sends_admit_only_one_and_repeat_returns_receipt(code):
+ service, harness, _ = code
+ session = await session_for(code)
+ command = new_id()
+ results = await asyncio.gather(
+ service.send(
+ session.id, command, session.revision, "first", expected_epoch=service.epoch
+ ),
+ service.send(
+ session.id,
+ new_id(),
+ session.revision,
+ "second",
+ expected_epoch=service.epoch,
+ ),
+ return_exceptions=True,
+ )
+ assert sum(isinstance(result, CodeConflictError) for result in results) == 1
+ run = results[0]
+ assert not isinstance(run, BaseException)
+ await harness.started.wait()
+ repeat = await service.send(
+ session.id, command, session.revision, "first", expected_epoch=service.epoch
+ )
+ assert repeat.id == run.id
+ assert harness.connections[0].inputs == [(command, "first", "provider/model")]
+ with pytest.raises(CodeConflictError):
+ await service.send(
+ session.id,
+ command,
+ session.revision,
+ "changed",
+ expected_epoch=service.epoch,
+ )
+
+
+async def test_http_cancellation_does_not_cancel_native_creation(code):
+ service, harness, _ = code
+ session = await session_for(code)
+ harness.creation_gate.clear()
+ command = new_id()
+ await service.send(
+ session.id, command, session.revision, "continue", expected_epoch=service.epoch
+ )
+ await harness.creating.wait()
+ # There is no HTTP-owned native waiter left to cancel after admission.
+ detail = await service.get_detail(session.id)
+ assert detail.run.id == command
+ harness.creation_gate.set()
+ await harness.started.wait()
+ detail = await service.get_detail(session.id)
+ assert detail.session.native_thread_id == "native-1"
+ assert harness.connections[0].inputs[0][0] == command
+
+
+async def test_stop_before_native_ack_targets_that_run_only(code):
+ service, harness, _ = code
+ session = await session_for(code)
+ harness.start_gate.clear()
+ run = await service.send(
+ session.id, new_id(), session.revision, "first", expected_epoch=service.epoch
+ )
+ await harness.submitted.wait()
+ await service.stop(session.id, run.id)
+ harness.start_gate.set()
+ await harness.interrupted.wait()
+ connection = harness.connections[0]
+ assert connection.interrupts == ["turn-1"]
+ await connection.finish("turn-1", "interrupted")
+ detail = await service.get_detail(session.id)
+ assert detail.run.status == "interrupted"
+ second = await service.send(
+ session.id,
+ new_id(),
+ detail.session.revision,
+ "second",
+ expected_epoch=service.epoch,
+ )
+ await harness.wait_inputs(2)
+ await service.stop(session.id, run.id)
+ assert second.id != run.id
+ assert connection.interrupts == ["turn-1"]
+
+
+async def test_stop_during_creation_prevents_native_submission(code):
+ service, harness, _ = code
+ session = await session_for(code)
+ harness.creation_gate.clear()
+ run = await service.send(
+ session.id,
+ new_id(),
+ session.revision,
+ "do not run",
+ expected_epoch=service.epoch,
+ )
+ await harness.creating.wait()
+ await service.stop(session.id, run.id)
+ harness.creation_gate.set()
+ await service.wait_idle(session.id)
+ detail = await service.get_detail(session.id)
+ assert detail.run.status == "interrupted"
+ assert detail.session.native_thread_id == "native-1"
+ assert harness.connections[0].inputs == []
+
+
+async def test_browser_observers_are_independent_of_work(code):
+ service, harness, _ = code
+ session = await session_for(code)
+ first, _ = await service.subscribe()
+ second, _ = await service.subscribe()
+ await service.send(
+ session.id,
+ new_id(),
+ session.revision,
+ "keep running",
+ expected_epoch=service.epoch,
+ )
+ await harness.started.wait()
+ await first.aclose()
+ await second.aclose()
+ connection = harness.connections[0]
+ await connection.text("turn-1", "answer", "Still running", complete=True)
+ await connection.finish("turn-1")
+ detail = await service.get_detail(session.id)
+ assert detail.items[-1].text == "Still running"
+ assert detail.run.status == "completed"
+ assert not connection.closed
+
+
+async def test_idle_delete_removes_both_histories_and_blocks_late_create(code):
+ service, harness, directory = code
+ session = await session_for(code)
+ await service.send(
+ session.id, new_id(), session.revision, "hello", expected_epoch=service.epoch
+ )
+ await harness.started.wait()
+ with pytest.raises(CodeConflictError):
+ await service.delete_session(session.id, session.revision)
+ assert harness.connections[0].deleted == []
+ await harness.connections[0].finish("turn-1")
+ detail = await service.get_detail(session.id)
+ await service.delete_session(session.id, detail.session.revision)
+ await service.wait_idle(session.id)
+ assert harness.connections[0].deleted == ["native-1"]
+ assert (await service.list_sessions()).sessions == ()
+ with pytest.raises(CodeConflictError):
+ await service.create_session(session.id, str(directory))
+
+
+async def test_restart_preserves_receipt_and_does_not_replay_input(tmp_path):
+ harness = FakeHarness()
+ database, lock = tmp_path / "code.db", tmp_path / "code.lock"
+ first = CodeService(SQLiteCodeStore(database, lock), harness)
+ await first.start()
+ session = await first.create_session(new_id(), str(tmp_path))
+ run = await first.send(
+ session.id, new_id(), session.revision, "once", expected_epoch=first.epoch
+ )
+ await harness.started.wait()
+ await first.close()
+ second = CodeService(SQLiteCodeStore(database, lock), harness)
+ await second.start()
+ try:
+ repeat = await second.send(
+ session.id, run.id, session.revision, "once", expected_epoch=second.epoch
+ )
+ assert repeat.id == run.id
+ assert repeat.status == "interrupted"
+ assert len(harness.connections) == 1
+ assert harness.connections[0].inputs == [(run.id, "once", "provider/model")]
+ finally:
+ await second.close()
+
+
+async def test_two_answers_claim_one_native_prompt(code):
+ service, harness, _ = code
+ session = await session_for(code)
+ await service.send(
+ session.id, new_id(), session.revision, "approval", expected_epoch=service.epoch
+ )
+ await harness.started.wait()
+ connection = harness.connections[0]
+ await connection.prompt(0)
+ prompt = (await service.get_detail(session.id)).prompts[0]
+ harness.answer_gate.clear()
+ results = await asyncio.gather(
+ service.answer(session.id, prompt.id, new_id(), {"choice": "accept"}),
+ service.answer(session.id, prompt.id, new_id(), {"choice": "decline"}),
+ return_exceptions=True,
+ )
+ assert sum(isinstance(result, CodeConflictError) for result in results) == 1
+ await harness.answering.wait()
+ harness.answer_gate.set()
+ await harness.answered.wait()
+ assert len(connection.answers) == 1
+ assert (await service.get_detail(session.id)).prompts[0].status == "resolved"
+
+
+async def test_native_resolution_while_answer_is_waiting_never_resurrects_prompt(code):
+ service, harness, _ = code
+ session = await session_for(code)
+ await service.send(
+ session.id, new_id(), session.revision, "approval", expected_epoch=service.epoch
+ )
+ await harness.started.wait()
+ connection = harness.connections[0]
+ await connection.prompt(0)
+ prompt = (await service.get_detail(session.id)).prompts[0]
+ harness.answer_gate.clear()
+ await service.answer(session.id, prompt.id, new_id(), {"choice": "accept"})
+ await harness.answering.wait()
+ await connection.resolve(0)
+ harness.answer_gate.set()
+ await harness.answered.wait()
+ assert connection.answers == []
+ assert (await service.get_detail(session.id)).prompts[0].status == "resolved"
+
+
+async def test_streaming_does_not_invalidate_rename_revision(code):
+ service, harness, _ = code
+ session = await session_for(code)
+ await service.send(
+ session.id, new_id(), session.revision, "hello", expected_epoch=service.epoch
+ )
+ await harness.started.wait()
+ before = await service.get_detail(session.id)
+ await harness.connections[0].text("turn-1", "answer", "partial")
+ after = await service.get_detail(session.id)
+ assert after.version > before.version
+ assert after.session.revision == before.session.revision
+ await service.update_settings(
+ session.id, before.session.revision, {"title": "My code"}
+ )
+ assert (await service.get_detail(session.id)).session.title == "My code"
+
+
+async def test_catalog_replacement_is_limited_to_selected_entry_and_session(code):
+ service, harness, _ = code
+ harness.configurations["provider/other"] = "other-1"
+ session = await session_for(code)
+ await service.send(
+ session.id, new_id(), session.revision, "first", expected_epoch=service.epoch
+ )
+ await harness.started.wait()
+ original = harness.connections[0]
+ await original.finish("turn-1")
+ harness.model = "provider/other"
+ detail = await service.get_detail(session.id)
+ selected = await service.update_settings(
+ session.id, detail.session.revision, {"model": harness.model}
+ )
+ await service.send(
+ session.id,
+ new_id(),
+ selected.revision,
+ "second",
+ expected_epoch=service.epoch,
+ )
+ await harness.wait_inputs(2)
+ await original.finish("turn-2")
+ assert len(harness.connections) == 1
+ harness.configurations["unrelated/model"] = "new"
+ harness.configurations["provider/other"] = "changed"
+ detail = await service.get_detail(session.id)
+ await service.send(
+ session.id,
+ new_id(),
+ detail.session.revision,
+ "third",
+ expected_epoch=service.epoch,
+ )
+ await harness.wait_inputs(3)
+ assert len(harness.connections) == 2
+ assert original.closed
+ assert harness.connections[1].resumed == ["native-1"]
+
+
+async def test_cancelled_http_admission_still_commits_and_executes_once(tmp_path):
+ committed = asyncio.Event()
+ release = asyncio.Event()
+
+ class GatedStore(SQLiteCodeStore):
+ async def admit_run(self, session, run, item, expected_revision):
+ result = await super().admit_run(session, run, item, expected_revision)
+ committed.set()
+ await release.wait()
+ return result
+
+ harness = FakeHarness()
+ service = CodeService(
+ GatedStore(tmp_path / "code.db", tmp_path / "code.lock"), harness
+ )
+ await service.start()
+ try:
+ session = await service.create_session(new_id(), str(tmp_path))
+ operation_id = new_id()
+ http = asyncio.create_task(
+ service.send(
+ session.id,
+ operation_id,
+ session.revision,
+ "once",
+ expected_epoch=service.epoch,
+ )
+ )
+ await committed.wait()
+ http.cancel()
+ with pytest.raises(asyncio.CancelledError):
+ await http
+ release.set()
+ await harness.started.wait()
+ repeat = await service.send(
+ session.id,
+ operation_id,
+ session.revision,
+ "once",
+ expected_epoch=service.epoch,
+ )
+ assert repeat.id == operation_id
+ assert len(harness.connections[0].inputs) == 1
+ finally:
+ release.set()
+ await service.close()
diff --git a/tests/application/test_execution.py b/tests/application/test_execution.py
index 4793bf30..3d34d158 100644
--- a/tests/application/test_execution.py
+++ b/tests/application/test_execution.py
@@ -1218,35 +1218,52 @@ async def test_empty_chunks_do_not_renew_provider_progress() -> None:
@pytest.mark.asyncio
async def test_fallback_transition_does_not_reset_shared_progress_deadline() -> None:
- timeout_seconds = 0.2
+ primary_wait = WaitStep()
primary = ControlledProvider(
- [DelayStep(0.06), _execution_failure("primary overloaded")]
+ [primary_wait, _execution_failure("primary overloaded")]
)
fallback_wait = WaitStep()
fallback = ControlledProvider([fallback_wait])
providers = {"provider": primary, "fallback": fallback}
executor = ProviderExecutor(
providers.__getitem__,
- progress_timeout_seconds=timeout_seconds,
+ progress_timeout_seconds=60,
)
stream = executor.stream_messages(
_routed_request(_target("fallback", "model")),
raw_log_payload={},
request_id="req_shared_deadline",
)
- loop = asyncio.get_running_loop()
- started = loop.time()
+ deadlines: list[float | None] = []
+ timeouts: list[asyncio.Timeout] = []
+
+ def controlled_timeout_at(deadline):
+ deadlines.append(deadline)
+ timeout = asyncio.timeout(None)
+ timeouts.append(timeout)
+ return timeout
with (
patch("free_claude_code.application.execution.trace_event") as trace_mock,
- pytest.raises(ExecutionFailure) as exc_info,
+ patch(
+ "free_claude_code.application.execution.asyncio.timeout_at",
+ controlled_timeout_at,
+ ),
):
- await anext(stream)
+ reading = asyncio.ensure_future(anext(stream))
+ await primary_wait.started.wait()
+ primary_wait.release.set()
+ await fallback_wait.started.wait()
+ # Expire the actual fallback read context after observing its admission;
+ # machine load must not determine whether the shared deadline was reused.
+ timeouts[-1].reschedule(asyncio.get_running_loop().time())
+ with pytest.raises(ExecutionFailure) as exc_info:
+ await reading
- elapsed = loop.time() - started
- assert fallback_wait.started.is_set()
+ read_deadlines = [deadline for deadline in deadlines if deadline is not None]
+ assert len(read_deadlines) >= 3
+ assert len(set(read_deadlines)) == 1
assert exc_info.value.kind == FailureKind.TIMEOUT
- assert elapsed < 0.24
assert primary.stream_close_calls == fallback.stream_close_calls == 1
timeout_trace = next(
call.kwargs
diff --git a/tests/code_sessions_support.py b/tests/code_sessions_support.py
new file mode 100644
index 00000000..0116700b
--- /dev/null
+++ b/tests/code_sessions_support.py
@@ -0,0 +1,284 @@
+"""Controllable native harness used by application and browser tests."""
+
+import asyncio
+import uuid
+from dataclasses import dataclass
+
+from free_claude_code.application.code_sessions.models import (
+ CodeCatalog,
+ CodeConflictError,
+ CodeModel,
+ CodeUnavailableError,
+ CodeValidationError,
+ HarnessEvent,
+ ItemUpdate,
+ NativeHistoryMissing,
+ NativeThread,
+ NativeTurn,
+ PromptRequest,
+ RunStatus,
+)
+from free_claude_code.application.code_sessions.ports import EventSink, HarnessSelection
+from free_claude_code.core.json_types import JsonObject
+
+
+class FakeHarness:
+ def __init__(self):
+ self.connections: list[FakeConnection] = []
+ self.model = "provider/model"
+ self.configurations = {self.model: "capabilities-1"}
+ self.efforts = ("low", "medium", "high", "xhigh")
+ self.default_effort = "medium"
+ self.creation_gate = asyncio.Event()
+ self.start_gate = asyncio.Event()
+ self.creation_gate.set()
+ self.start_gate.set()
+ self.creating = asyncio.Event()
+ self.started = asyncio.Event()
+ self.submitted = asyncio.Event()
+ self.interrupted = asyncio.Event()
+ self.input_changed = asyncio.Event()
+ self.answer_gate = asyncio.Event()
+ self.answer_gate.set()
+ self.answering = asyncio.Event()
+ self.answered = asyncio.Event()
+ self.interrupt_gate = asyncio.Event()
+ self.interrupt_gate.set()
+ self.turn_count = 0
+ self.histories: dict[str, list[ItemUpdate]] = {}
+ self.delete_error: Exception | None = None
+ self.delete_gate = asyncio.Event()
+ self.delete_gate.set()
+ self.deleting = asyncio.Event()
+ self.delete_before_error = False
+
+ def availability(self):
+ return True, None
+
+ def catalog(self):
+ return CodeCatalog(
+ self.model,
+ tuple(
+ CodeModel(
+ id=model,
+ display_name=model,
+ reasoning_efforts=self.efforts,
+ default_reasoning_effort=self.default_effort,
+ )
+ for model in self.configurations
+ ),
+ )
+
+ def prepare(self, model, reasoning_effort):
+ if model not in self.configurations:
+ raise CodeValidationError("This model is unavailable.")
+ if reasoning_effort is not None and reasoning_effort not in self.efforts:
+ raise CodeValidationError("This reasoning effort is unavailable.")
+ return FakeSelection(
+ self,
+ model,
+ self.configurations[model],
+ dict(self.configurations),
+ reasoning_effort or self.default_effort,
+ )
+
+ async def open_history(self, cwd: str, sink: EventSink):
+ return await self.prepare(self.model, None).open(cwd, sink)
+
+ async def wait_inputs(self, count: int):
+ while sum(len(connection.inputs) for connection in self.connections) < count:
+ self.input_changed.clear()
+ await self.input_changed.wait()
+
+
+@dataclass
+class FakeSelection:
+ harness: FakeHarness
+ model: str
+ configuration_key: str
+ catalog: dict[str, str]
+ reasoning_effort: str | None
+
+ async def open(self, cwd: str, sink: EventSink):
+ connection = FakeConnection(self.harness, sink, self.catalog)
+ self.harness.connections.append(connection)
+ return connection
+
+
+class FakeConnection:
+ def __init__(self, harness: FakeHarness, sink: EventSink, catalog: dict[str, str]):
+ self.harness = harness
+ self.sink = sink
+ self.catalog = catalog
+ self.generation = str(uuid.uuid4())
+ self.thread_id: str | None = None
+ self.inputs: list[tuple[str, str, str]] = []
+ self.efforts: list[str | None] = []
+ self.interrupts: list[str] = []
+ self.deleted: list[str] = []
+ self.resumed: list[str] = []
+ self.answers: list[tuple[str | int, JsonObject]] = []
+ self.requests: dict[str | int, PromptRequest] = {}
+ self.closed = False
+
+ def supports(self, selection: HarnessSelection):
+ return (
+ not self.closed
+ and self.catalog.get(selection.model) == selection.configuration_key
+ )
+
+ async def create_thread(self):
+ self.harness.creating.set()
+ await self.harness.creation_gate.wait()
+ if self.closed:
+ raise CodeUnavailableError("Native process closed during creation.")
+ self.thread_id = f"native-{len(self.harness.histories) + 1}"
+ self.harness.histories[self.thread_id] = []
+ return NativeThread(self.thread_id)
+
+ async def resume_thread(self, thread_id: str):
+ self.resumed.append(thread_id)
+ self.thread_id = thread_id
+ return await self.read_thread(thread_id)
+
+ async def read_thread(self, thread_id: str):
+ if thread_id not in self.harness.histories:
+ raise NativeHistoryMissing("Native conversation not found.")
+ groups: dict[str, list[ItemUpdate]] = {}
+ for item in self.harness.histories[thread_id]:
+ groups.setdefault(item.turn_id, []).append(item)
+ return NativeThread(
+ thread_id,
+ tuple(
+ NativeTurn(turn_id, tuple(items)) for turn_id, items in groups.items()
+ ),
+ )
+
+ async def start_turn(self, text: str, selection: HarnessSelection, client_id: str):
+ self.inputs.append((client_id, text, selection.model))
+ self.efforts.append(selection.reasoning_effort)
+ self.harness.input_changed.set()
+ self.harness.submitted.set()
+ self.harness.turn_count += 1
+ turn_id = f"turn-{self.harness.turn_count}"
+ await self.harness.start_gate.wait()
+ if self.closed:
+ raise CodeUnavailableError("Native process closed during submission.")
+ await self.sink(
+ HarnessEvent(
+ self.generation, self.thread_id, "turn_started", turn_id=turn_id
+ )
+ )
+ self.harness.started.set()
+ return turn_id
+
+ async def interrupt(self, turn_id: str):
+ self.interrupts.append(turn_id)
+ self.harness.interrupted.set()
+ await self.harness.interrupt_gate.wait()
+ if self.closed:
+ raise CodeUnavailableError(
+ "Native process closed before interrupt acknowledgement."
+ )
+ await self.finish(turn_id, "interrupted")
+
+ async def finish(self, turn_id: str, status: RunStatus = "completed", message=None):
+ await self.sink(
+ HarnessEvent(
+ self.generation,
+ self.thread_id,
+ "turn_completed",
+ turn_id=turn_id,
+ status=status,
+ message=message,
+ )
+ )
+
+ async def text(
+ self, turn_id: str, item_id: str, text: str, *, complete=False, kind="text"
+ ):
+ item = ItemUpdate(
+ turn_id,
+ item_id,
+ kind,
+ text=text,
+ complete=complete,
+ raw={"id": item_id, "text": text},
+ )
+ if self.thread_id:
+ self.harness.histories[self.thread_id].append(item)
+ await self.sink(
+ HarnessEvent(
+ self.generation, self.thread_id, "item", turn_id=turn_id, item=item
+ )
+ )
+
+ async def prompt(self, request_id: str | int, turn_id: str | None = "turn-1"):
+ prompt = PromptRequest(
+ request_id,
+ "approval",
+ {
+ "title": "Run command?",
+ "choices": [
+ {"id": "accept", "label": "Allow"},
+ {"id": "decline", "label": "Decline"},
+ ],
+ },
+ {"requestId": request_id},
+ turn_id,
+ )
+ self.requests[request_id] = prompt
+ await self.sink(
+ HarnessEvent(
+ self.generation,
+ self.thread_id,
+ "prompt",
+ turn_id=turn_id,
+ prompt=prompt,
+ )
+ )
+
+ def prepare_answer(self, request_id: str | int, answer: JsonObject):
+ if request_id not in self.requests:
+ raise CodeConflictError("Prompt resolved.")
+ return dict(answer)
+
+ async def respond(self, request_id: str | int, response: JsonObject):
+ self.harness.answering.set()
+ await self.harness.answer_gate.wait()
+ try:
+ if request_id not in self.requests:
+ raise CodeConflictError("Prompt resolved.")
+ self.answers.append((request_id, response))
+ await self.resolve(request_id)
+ finally:
+ self.harness.answered.set()
+
+ async def resolve(self, request_id: str | int):
+ self.requests.pop(request_id, None)
+ await self.sink(
+ HarnessEvent(
+ self.generation, self.thread_id, "resolved", request_id=request_id
+ )
+ )
+
+ async def delete_thread(self, thread_id: str):
+ self.deleted.append(thread_id)
+ self.harness.deleting.set()
+ await self.harness.delete_gate.wait()
+ if self.harness.delete_before_error:
+ self.harness.histories.pop(thread_id, None)
+ if self.harness.delete_error:
+ raise self.harness.delete_error
+ self.harness.histories.pop(thread_id, None)
+
+ async def close(self):
+ if self.closed:
+ return
+ self.closed = True
+ self.harness.creation_gate.set()
+ self.harness.start_gate.set()
+ self.harness.answer_gate.set()
+ self.harness.interrupt_gate.set()
+ self.harness.delete_gate.set()
+ await self.sink(HarnessEvent(self.generation, self.thread_id, "closed"))
diff --git a/tests/runtime/codex_fake_process.py b/tests/runtime/codex_fake_process.py
new file mode 100644
index 00000000..293164ee
--- /dev/null
+++ b/tests/runtime/codex_fake_process.py
@@ -0,0 +1,161 @@
+"""Deterministic JSONL peer for native transport tests; never executes tools."""
+
+import json
+import sys
+
+
+def emit(value):
+ encoded = (json.dumps(value, ensure_ascii=False) + "\n").encode("utf-8")
+ # Exercise framing across both large messages and UTF-8 boundaries.
+ for start in range(0, len(encoded), 32767):
+ sys.stdout.buffer.write(encoded[start : start + 32767])
+ sys.stdout.buffer.flush()
+
+
+mode = sys.argv[1]
+creation_id = None
+turn = "turn-1"
+for line in sys.stdin.buffer:
+ request = json.loads(line)
+ method = request.get("method")
+ request_id = request.get("id")
+ if method == "initialize":
+ emit({"id": request_id, "result": {"userAgent": "codex/0.153.0"}})
+ elif method == "initialized":
+ pass
+ elif method == "thread/start":
+ if mode == "delayed-create":
+ creation_id = request_id
+ else:
+ emit(
+ {
+ "id": request_id,
+ "result": {"thread": {"id": "native-1", "turns": []}},
+ }
+ )
+ elif method == "test/barrier":
+ emit({"id": request_id, "result": {}})
+ elif method == "test/release-create":
+ emit({"id": creation_id, "result": {"thread": {"id": "native-1", "turns": []}}})
+ emit({"id": request_id, "result": {}})
+ elif method == "turn/start":
+ emit(
+ {
+ "method": "turn/started",
+ "params": {
+ "threadId": "native-1",
+ "turn": {"id": turn, "status": "inProgress"},
+ },
+ }
+ )
+ if mode in {"prompt", "child-prompt"}:
+ if mode == "child-prompt":
+ emit(
+ {
+ "method": "thread/started",
+ "params": {
+ "thread": {
+ "id": "child-1",
+ "source": {
+ "subAgent": {
+ "thread_spawn": {
+ "parent_thread_id": "native-1",
+ "depth": 1,
+ }
+ }
+ },
+ }
+ },
+ }
+ )
+ emit(
+ {
+ "method": "item/commandExecution/requestApproval",
+ "id": 0,
+ "params": {
+ "threadId": "child-1" if mode == "child-prompt" else "native-1",
+ "turnId": turn,
+ "itemId": "command",
+ "command": "echo test",
+ "availableDecisions": ["accept", "decline", "cancel"],
+ },
+ }
+ )
+ else:
+ emit(
+ {
+ "method": "item/agentMessage/delta",
+ "params": {
+ "threadId": "native-1",
+ "turnId": turn,
+ "itemId": "answer",
+ "delta": "snow ☃ " * 16000,
+ },
+ }
+ )
+ emit(
+ {
+ "method": "item/completed",
+ "params": {
+ "threadId": "native-1",
+ "turnId": turn,
+ "item": {
+ "id": "answer",
+ "type": "agentMessage",
+ "text": "snow ☃ " * 16000,
+ },
+ },
+ }
+ )
+ emit(
+ {
+ "method": "turn/completed",
+ "params": {
+ "threadId": "native-1",
+ "turn": {"id": turn, "status": "completed"},
+ },
+ }
+ )
+ emit(
+ {"id": request_id, "result": {"turn": {"id": turn, "status": "inProgress"}}}
+ )
+ elif method is None and request_id == 0:
+ emit(
+ {
+ "method": "serverRequest/resolved",
+ "params": {"threadId": "native-1", "requestId": 0},
+ }
+ )
+ emit(
+ {
+ "method": "item/completed",
+ "params": {
+ "threadId": "native-1",
+ "turnId": turn,
+ "item": {
+ "id": "answer",
+ "type": "agentMessage",
+ "text": request["result"]["decision"],
+ },
+ },
+ }
+ )
+ emit(
+ {
+ "method": "turn/completed",
+ "params": {
+ "threadId": "native-1",
+ "turn": {"id": turn, "status": "completed"},
+ },
+ }
+ )
+ elif method == "test/eof":
+ break
+ elif method == "test/malformed":
+ sys.stdout.buffer.write(b"invalid-json\n")
+ sys.stdout.buffer.flush()
+ elif method == "test/malformed-flood":
+ sys.stdout.buffer.write(b"invalid-json\n" + b"x" * 500_000 + b"\n")
+ sys.stdout.buffer.flush()
+ else:
+ emit({"id": request_id, "result": {}})
diff --git a/tests/runtime/test_code_sessions_sqlite.py b/tests/runtime/test_code_sessions_sqlite.py
new file mode 100644
index 00000000..007e3c15
--- /dev/null
+++ b/tests/runtime/test_code_sessions_sqlite.py
@@ -0,0 +1,277 @@
+import asyncio
+import sqlite3
+import threading
+import uuid
+from contextlib import closing
+
+import pytest
+import pytest_asyncio
+
+from free_claude_code.application.code_sessions.models import (
+ CodeConflictError,
+ CodeItem,
+ CodePrompt,
+ CodeRun,
+ CodeSession,
+ CodeUnavailableError,
+)
+from free_claude_code.runtime.code_sessions_sqlite import SQLiteCodeStore
+
+
+async def test_cancelled_initialization_drains_thread_before_releasing_owner_lock(
+ tmp_path,
+):
+ entered = threading.Event()
+ release = threading.Event()
+ initialized = threading.Event()
+
+ class GatedStore(SQLiteCodeStore):
+ def _initialize(self):
+ entered.set()
+ assert release.wait(5)
+ super()._initialize()
+ initialized.set()
+
+ store = GatedStore(tmp_path / "code.db", tmp_path / "code.lock")
+ starting = asyncio.create_task(store.start())
+ await asyncio.to_thread(entered.wait, 3)
+ starting.cancel()
+ release.set()
+ with pytest.raises(asyncio.CancelledError):
+ await starting
+ await asyncio.to_thread(initialized.wait, 3)
+ second = SQLiteCodeStore(tmp_path / "code.db", tmp_path / "code.lock")
+ try:
+ await second.start()
+ session = await second.create(
+ CodeSession(id=str(uuid.uuid4()), cwd=str(tmp_path), model="provider/model")
+ )
+ assert (await second.get_session(session.id)).id == session.id
+ finally:
+ await store.close()
+ await second.close()
+
+
+async def test_store_has_one_process_owner_and_can_reopen_after_close(tmp_path):
+ first = SQLiteCodeStore(tmp_path / "code.db", tmp_path / "code.lock")
+ second = SQLiteCodeStore(tmp_path / "code.db", tmp_path / "code.lock")
+ await first.start()
+ try:
+ with pytest.raises(CodeUnavailableError, match="another FCC"):
+ await second.start()
+ finally:
+ await first.close()
+ await second.start()
+ await second.close()
+
+
+async def test_reused_item_id_cannot_overwrite_another_session(tmp_path):
+ store = SQLiteCodeStore(tmp_path / "code.db", tmp_path / "code.lock")
+ await store.start()
+ try:
+ first, second = [
+ await store.create(
+ CodeSession(
+ id=str(uuid.uuid4()), cwd=str(tmp_path), model="provider/model"
+ )
+ )
+ for _ in range(2)
+ ]
+ shared_id = str(uuid.uuid4())
+ first, first_run = await _admit(store, first, text="first")
+ original = CodeItem(
+ id=shared_id,
+ session_id=first.id,
+ sequence=2,
+ run_id=first_run.id,
+ kind="tool",
+ text="original output",
+ complete=True,
+ )
+ await store.save_progress(first, first.revision, items=(original,))
+ await _admit(store, second, run_id=shared_id, text="second")
+ assert (await store.items(first.id, None, None))[-1] == original
+ assert (await store.items(second.id, None, None))[0].text == "second"
+ finally:
+ await store.close()
+
+
+async def _admit(store, session, *, run_id=None, text="message", sequence=1):
+ run_id = run_id or str(uuid.uuid4())
+ run = CodeRun(id=run_id, session_id=session.id, text=text, model=session.model)
+ item = CodeItem(
+ id=run_id,
+ session_id=session.id,
+ run_id=run_id,
+ sequence=sequence,
+ kind="user",
+ text=text,
+ complete=True,
+ )
+ return await store.admit_run(
+ session.model_copy(update={"revision": session.revision + 1}),
+ run,
+ item,
+ session.revision,
+ )
+
+
+@pytest_asyncio.fixture
+async def store(tmp_path):
+ result = SQLiteCodeStore(tmp_path / "code.db", tmp_path / "code.lock")
+ await result.start()
+ yield result
+ await result.close()
+
+
+async def _session(store):
+ return await store.create(
+ CodeSession(id=str(uuid.uuid4()), cwd="/work", model="provider/model")
+ )
+
+
+async def test_admission_is_atomic_and_idempotent(store):
+ session = await _session(store)
+ results = await asyncio.gather(
+ _admit(store, session), _admit(store, session), return_exceptions=True
+ )
+ assert sum(isinstance(result, CodeConflictError) for result in results) == 1
+ session, run = next(result for result in results if isinstance(result, tuple))
+ assert (
+ len(await store.runs(session.id))
+ == len(await store.items(session.id, None, None))
+ == 1
+ )
+ assert await _admit(store, session, run_id=run.id) == (session, run)
+ await store.save_progress(
+ session, session.revision, run=run.model_copy(update={"status": "completed"})
+ )
+ collision = CodeItem(
+ id=str(uuid.uuid4()),
+ session_id=session.id,
+ run_id=run.id,
+ sequence=2,
+ kind="tool",
+ text="keep me",
+ complete=True,
+ )
+ await store.save_progress(session, session.revision, items=(collision,))
+ with pytest.raises(CodeConflictError):
+ await _admit(store, session, run_id=collision.id, sequence=3)
+ assert (await store.get_session(session.id)).revision == session.revision
+ assert len(await store.runs(session.id)) == 1
+ assert (await store.items(session.id, None, None))[-1] == collision
+
+
+async def test_schema_rejects_second_active_run_and_cross_session_item_link(
+ store, tmp_path
+):
+ session, run = await _admit(store, await _session(store))
+ other = await _session(store)
+ with closing(sqlite3.connect(tmp_path / "code.db")) as connection:
+ connection.execute("PRAGMA foreign_keys = ON")
+ columns = [row[1] for row in connection.execute("PRAGMA table_info(code_runs)")]
+ expressions = [
+ "'another'"
+ if column == "id"
+ else "ordinal + 1"
+ if column == "ordinal"
+ else column
+ for column in columns
+ ]
+ with pytest.raises(sqlite3.IntegrityError):
+ connection.execute(
+ f"INSERT INTO code_runs SELECT {','.join(expressions)} FROM code_runs"
+ )
+ columns = [
+ row[1] for row in connection.execute("PRAGMA table_info(code_items)")
+ ]
+ expressions = ["?" if column == "session_id" else column for column in columns]
+ with pytest.raises(sqlite3.IntegrityError):
+ connection.execute(
+ f"INSERT INTO code_items SELECT {','.join(expressions)} FROM code_items",
+ (other.id,),
+ )
+ assert await store.get_run(session.id, run.id) == run
+
+
+async def test_prompt_claim_and_settings_are_guarded_in_storage(store):
+ session = await _session(store)
+ prompts = tuple(
+ CodePrompt(
+ id=str(uuid.uuid4()),
+ session_id=session.id,
+ generation="g",
+ request_id=request_id,
+ kind="question",
+ form={},
+ raw={},
+ )
+ for request_id in (1, "1")
+ )
+ await store.save_progress(session, session.revision, prompts=prompts)
+ results = await asyncio.gather(
+ *(
+ store.claim_prompt(session.id, prompts[0].id, str(uuid.uuid4()), "g")
+ for _ in range(2)
+ ),
+ return_exceptions=True,
+ )
+ assert sum(isinstance(result, CodeConflictError) for result in results) == 1
+ claimed = next(result for result in results if isinstance(result, CodePrompt))
+ assert (
+ await store.claim_prompt(session.id, claimed.id, claimed.response_id, "g")
+ == claimed
+ )
+ with pytest.raises(CodeConflictError):
+ await store.claim_prompt(session.id, prompts[1].id, claimed.response_id, "g")
+ settings = session.model_copy(
+ update={"model": "provider/other", "revision": session.revision + 1}
+ )
+ with pytest.raises(CodeConflictError):
+ await store.update_settings(settings, session.revision)
+ await store.save_progress(
+ session,
+ session.revision,
+ prompts=(
+ claimed.model_copy(update={"status": "resolved"}),
+ prompts[1].model_copy(update={"status": "expired"}),
+ ),
+ )
+ assert (
+ await store.update_settings(settings, session.revision)
+ ).model == "provider/other"
+ with pytest.raises(CodeConflictError):
+ await store.update_settings(
+ session.model_copy(update={"title": "stale"}), session.revision
+ )
+
+
+async def test_recovered_old_output_pages_with_its_original_run_outcome(store):
+ session, old = await _admit(store, await _session(store))
+ old = old.model_copy(update={"status": "failed", "error": "first failed"})
+ await store.save_progress(session, session.revision, run=old)
+ session, newer = await _admit(store, session, sequence=2)
+ tail = CodeItem(
+ id=str(uuid.uuid4()),
+ session_id=session.id,
+ run_id=old.id,
+ sequence=3,
+ kind="assistant",
+ text="recovered",
+ complete=True,
+ )
+ await store.save_progress(session, session.revision, items=(tail,))
+ page = await store.item_page(session.id, None, 2)
+ assert [item.run_id for item in page.items] == [old.id, newer.id]
+ assert page.runs[0].error == "first failed"
+ assert page.next_before == (old.ordinal, 3)
+ older = await store.item_page(session.id, page.next_before, 2)
+ assert [item.sequence for item in older.items] == [1]
diff --git a/tests/runtime/test_codex_app_server.py b/tests/runtime/test_codex_app_server.py
new file mode 100644
index 00000000..06cc987f
--- /dev/null
+++ b/tests/runtime/test_codex_app_server.py
@@ -0,0 +1,195 @@
+import asyncio
+import os
+import sys
+from pathlib import Path
+
+import pytest
+
+from free_claude_code.application.code_sessions.models import CodeUnavailableError
+from free_claude_code.runtime.codex_app_server import CodexAppServer
+from tests.code_sessions_support import FakeHarness
+
+
+async def connect(tmp_path, mode):
+ events = []
+ completed = asyncio.Event()
+ prompted = asyncio.Event()
+
+ async def receive(event):
+ events.append(event)
+ if event.kind == "turn_completed":
+ completed.set()
+ if event.kind == "prompt":
+ prompted.set()
+
+ native = CodexAppServer(
+ [sys.executable, str(Path(__file__).with_name("codex_fake_process.py")), mode],
+ dict(os.environ),
+ str(tmp_path),
+ receive,
+ model_slugs={"provider/model": "provider/model"},
+ fingerprints={"provider/model": "capabilities-1"},
+ )
+ await native.start()
+ return native, events, completed, prompted
+
+
+async def test_jsonl_large_unicode_events_can_precede_rpc_ack(tmp_path):
+ native, events, completed, _ = await connect(tmp_path, "large")
+ try:
+ assert (await native.create_thread()).id == "native-1"
+ assert (
+ await native.start_turn(
+ "hello", FakeHarness().prepare("provider/model", None), "input-1"
+ )
+ == "turn-1"
+ )
+ await asyncio.wait_for(completed.wait(), 3)
+ texts = [
+ event.item.text for event in events if event.item and event.item.complete
+ ]
+ assert texts == ["snow ☃ " * 16000]
+ finally:
+ await native.close()
+
+
+async def test_server_rpc_during_start_preserves_numeric_zero_id(tmp_path):
+ native, events, completed, prompted = await connect(tmp_path, "prompt")
+ try:
+ await native.create_thread()
+ await native.start_turn(
+ "hello", FakeHarness().prepare("provider/model", None), "input-1"
+ )
+ await asyncio.wait_for(prompted.wait(), 3)
+ response = native.prepare_answer(0, {"choice": "0"})
+ await native.respond(0, response)
+ await asyncio.wait_for(completed.wait(), 3)
+ assert any(event.item and event.item.text == "accept" for event in events)
+ assert any(
+ event.kind == "resolved" and event.request_id == 0 for event in events
+ )
+ finally:
+ await native.close()
+
+
+async def test_cancelled_creation_waiter_retains_late_native_identity(tmp_path):
+ native, _, _, _ = await connect(tmp_path, "delayed-create")
+ try:
+ creation = asyncio.create_task(native.create_thread())
+ await native.rpc("test/barrier", {})
+ creation.cancel()
+ with pytest.raises(asyncio.CancelledError):
+ await creation
+ await native.rpc("test/release-create", {})
+ assert native.thread_id == "native-1"
+ finally:
+ await native.close()
+
+
+async def test_eof_completes_pending_calls_and_cleanup(tmp_path):
+ native, _, _, _ = await connect(tmp_path, "large")
+ try:
+ with pytest.raises(CodeUnavailableError):
+ await native.rpc("test/eof", {})
+ finally:
+ await native.close()
+ assert native.process.returncode is not None
+
+
[email protected]("method", ["test/malformed", "test/malformed-flood"])
+async def test_malformed_frame_reports_closed_only_after_process_termination(
+ tmp_path, method
+):
+ closed = asyncio.Event()
+ returncodes = []
+
+ async def receive(event):
+ if event.kind == "closed":
+ returncodes.append(native.process.returncode)
+ closed.set()
+
+ native = CodexAppServer(
+ [
+ sys.executable,
+ str(Path(__file__).with_name("codex_fake_process.py")),
+ "large",
+ ],
+ dict(os.environ),
+ str(tmp_path),
+ receive,
+ )
+ try:
+ await native.start()
+ with pytest.raises(CodeUnavailableError):
+ await native.rpc(method, {})
+ await asyncio.wait_for(closed.wait(), 8)
+ assert returncodes and returncodes[0] is not None
+ assert native.process.stdout is not None and native.process.stdout.at_eof()
+ finally:
+ if native.process.stdout is not None and not native.process.stdout.at_eof():
+ await native.process.stdout.read()
+ await native.close()
+
+
+async def test_spawned_agent_prompt_is_visible_in_its_registered_root_session(tmp_path):
+ native, events, completed, prompted = await connect(tmp_path, "child-prompt")
+ try:
+ await native.create_thread()
+ await native.start_turn(
+ "delegate", FakeHarness().prepare("provider/model", None), "input-1"
+ )
+ await asyncio.wait_for(prompted.wait(), 3)
+ event = next(event for event in events if event.kind == "prompt")
+ assert event.thread_id == "native-1"
+ assert event.prompt.turn_id is None
+ assert event.prompt.raw["threadId"] == "child-1"
+ await native.respond(0, native.prepare_answer(0, {"choice": "0"}))
+ await asyncio.wait_for(completed.wait(), 3)
+ finally:
+ await native.close()
+
+
[email protected]("reasoning", [True, False])
+async def test_turn_start_resets_sticky_effort_and_preserves_client_identity(
+ tmp_path, monkeypatch, reasoning
+):
+ async def receive(event):
+ pass
+
+ native = CodexAppServer(
+ [],
+ {},
+ str(tmp_path),
+ receive,
+ model_slugs={"provider/model": "native-slug"},
+ reasoning={"provider/model": reasoning},
+ )
+ native.thread_id = "thread"
+ requests = []
+
+ async def rpc(method, params):
+ assert method == "turn/start"
+ requests.append(params)
+ return {"turn": {"id": "turn"}}
+
+ monkeypatch.setattr(native, "rpc", rpc)
+ harness = FakeHarness()
+ for effort in (None, "high", None):
+ await native.start_turn(
+ "hello", harness.prepare("provider/model", effort), "operation"
+ )
+ assert [request.get("effort") for request in requests] == (
+ ["medium", "high", "medium"] if reasoning else [None, None, None]
+ )
+ assert all(
+ request["clientUserMessageId"] == "operation"
+ and request["model"] == "native-slug"
+ for request in requests
+ )
diff --git a/tests/runtime/test_codex_catalog.py b/tests/runtime/test_codex_catalog.py
index 9ddd3f34..99fdfd55 100644
--- a/tests/runtime/test_codex_catalog.py
+++ b/tests/runtime/test_codex_catalog.py
@@ -4,12 +4,14 @@ from unittest.mock import patch
import pytest
+from free_claude_code.application.code_sessions.models import CodeValidationError
from free_claude_code.application.model_metadata import ProviderModelInfo
from free_claude_code.application.ports import (
RequestRuntimeLease,
RequestRuntimePort,
)
from free_claude_code.config.settings import Settings
+from free_claude_code.runtime.codex_app_server import CodexHarnessFactory
from free_claude_code.runtime.codex_catalog import CodexModelCatalogPublisher
@@ -102,3 +104,19 @@ def test_empty_projection_preserves_existing_catalog(tmp_path: Path) -> None:
publisher.publish(_runtime())
assert catalog_path.read_text(encoding="utf-8") == "last known good\n"
+
+
+def test_code_picker_and_native_selection_use_the_same_advertised_efforts():
+ factory = CodexHarnessFactory(_runtime(), binary="codex")
+ advertised = factory.catalog()
+ assert advertised.default_model == "nvidia_nim/configured"
+ model = advertised.models[1]
+ selected = factory.prepare(model.id, None)
+ assert selected.model == model.id
+ assert selected.context.settings.model == model.id
+ assert selected.reasoning_effort == model.default_reasoning_effort == "medium"
+ assert factory.prepare(model.id, "high").reasoning_effort == "high"
+ with pytest.raises(CodeValidationError, match="effort"):
+ factory.prepare(model.id, "unsupported")
+ with pytest.raises(CodeValidationError, match="model"):
+ factory.prepare("missing/model", None)
diff --git a/tests/runtime/test_codex_protocol.py b/tests/runtime/test_codex_protocol.py
new file mode 100644
index 00000000..28eace48
--- /dev/null
+++ b/tests/runtime/test_codex_protocol.py
@@ -0,0 +1,300 @@
+import pytest
+
+from free_claude_code.application.code_sessions import CodeValidationError
+from free_claude_code.runtime.codex_protocol import CodexProtocol, NativePrompt
+
+
+def notification(protocol, method, **extra):
+ return protocol.notification(
+ method, {"threadId": "thread", "turnId": "turn", "itemId": "item", **extra}
+ )
+
+
+def test_reasoning_keeps_summary_and_content_indices_and_original_completion():
+ protocol = CodexProtocol("generation")
+ notification(
+ protocol, "item/reasoning/summaryTextDelta", summaryIndex=1, delta="Second"
+ )
+ notification(
+ protocol, "item/reasoning/summaryTextDelta", summaryIndex=0, delta="First"
+ )
+ notification(
+ protocol,
+ "item/reasoning/textDelta",
+ contentIndex=0,
+ delta="Available reasoning",
+ )
+ event = notification(
+ protocol,
+ "item/completed",
+ item={
+ "id": "item",
+ "type": "reasoning",
+ "summary": [],
+ "content": [],
+ "opaque": "keep",
+ },
+ )
+ assert event.item.text == "First\n\nSecond\n\nAvailable reasoning"
+ assert event.item.raw["item"]["opaque"] == "keep"
+ assert event.item.raw["stream"]["summary"] == {"0": "First", "1": "Second"}
+
+
+def test_text_final_replaces_partial_without_losing_source_metadata():
+ protocol = CodexProtocol("generation")
+ notification(protocol, "item/agentMessage/delta", delta="Hel")
+ event = notification(
+ protocol,
+ "item/completed",
+ item={
+ "id": "item",
+ "type": "agentMessage",
+ "text": "Hello",
+ "delivery": "async",
+ "questions": [{"title": "Continue?"}],
+ },
+ )
+ assert event.item.text == "Hello"
+ assert event.item.raw["item"]["questions"] == [{"title": "Continue?"}]
+ assert event.item.complete
+
+
+def test_retryable_error_does_not_turn_into_completion():
+ event = notification(
+ CodexProtocol("generation"), "error", error={"message": "retry"}, willRetry=True
+ )
+ assert event.kind == "error"
+ assert event.message == "retry"
+ assert event.will_retry is True
+ assert event.error_details == {"message": "retry"}
+
+
+def test_command_completion_keeps_output_and_exit_code():
+ protocol = CodexProtocol("generation")
+ notification(protocol, "item/commandExecution/outputDelta", delta="output\n")
+ event = notification(
+ protocol,
+ "item/completed",
+ item={
+ "id": "item",
+ "type": "commandExecution",
+ "command": "pytest",
+ "cwd": "/work",
+ "status": "completed",
+ "exitCode": 1,
+ },
+ )
+ assert "output" in event.item.detail
+ assert "1" in event.item.detail
+ assert event.item.title == "pytest"
+
+
+def test_approval_can_only_select_exact_native_offered_decisions():
+ amendment = {"acceptWithExecpolicyAmendment": {"execpolicy_amendment": ["pytest"]}}
+ prompt = NativePrompt(
+ "item/commandExecution/requestApproval",
+ 7,
+ {
+ "threadId": "thread",
+ "turnId": "turn",
+ "itemId": "item",
+ "command": "pytest",
+ "availableDecisions": ["accept", amendment, "decline", "cancel"],
+ },
+ )
+ assert prompt.answer({"choice": "1"}) == {"decision": amendment}
+ assert prompt.answer({"choice": "2"}) == {"decision": "decline"}
+ with pytest.raises(CodeValidationError):
+ prompt.answer({"choice": "acceptForSession"})
+
+
+def test_questions_preserve_ids_and_free_text_and_need_an_answer():
+ prompt = NativePrompt(
+ "item/tool/requestUserInput",
+ "7",
+ {
+ "threadId": "thread",
+ "turnId": "turn",
+ "itemId": "item",
+ "isBlocking": False,
+ "questions": [
+ {
+ "id": "choice",
+ "header": "Choose",
+ "question": "Where?",
+ "options": [{"label": "Here", "description": "This folder"}],
+ "isOther": True,
+ "isSecret": False,
+ }
+ ],
+ },
+ )
+ assert prompt.answer({"answers": {"choice": ["Elsewhere"]}}) == {
+ "answers": {"choice": {"answers": ["Elsewhere"]}}
+ }
+ with pytest.raises(CodeValidationError):
+ prompt.answer({"answers": {"unknown": ["x"]}})
+
+
+def test_permission_grant_is_selected_subset_and_keeps_denies():
+ prompt = NativePrompt(
+ "item/permissions/requestApproval",
+ 8,
+ {
+ "threadId": "thread",
+ "turnId": "turn",
+ "itemId": "item",
+ "permissions": {
+ "network": {"enabled": True},
+ "fileSystem": {
+ "read": ["/work"],
+ "entries": [
+ {"access": "deny", "path": {"type": "path", "path": "/secret"}}
+ ],
+ },
+ },
+ },
+ )
+ response = prompt.answer({"selected": ["network"], "scope": "turn"})
+ assert response == {
+ "scope": "turn",
+ "permissions": {
+ "network": {"enabled": True},
+ "fileSystem": {
+ "entries": [
+ {"access": "deny", "path": {"type": "path", "path": "/secret"}}
+ ]
+ },
+ },
+ }
+ with pytest.raises(CodeValidationError):
+ prompt.answer({"selected": ["unoffered"], "scope": "session"})
+
+
+def test_mcp_form_answers_use_schema_types_and_reject_invalid_values():
+ prompt = NativePrompt(
+ "mcpServer/elicitation/request",
+ 9,
+ {
+ "threadId": "thread",
+ "turnId": None,
+ "serverName": "local",
+ "mode": "form",
+ "message": "Choose a limit",
+ "requestedSchema": {
+ "type": "object",
+ "required": ["limit"],
+ "properties": {
+ "limit": {"type": "integer", "minimum": 1, "maximum": 4}
+ },
+ },
+ },
+ )
+ assert prompt.answer({"action": "accept", "values": {"limit": 2}}) == {
+ "action": "accept",
+ "content": {"limit": 2},
+ }
+ with pytest.raises(CodeValidationError):
+ prompt.answer({"action": "accept", "values": {"limit": 7}})
+ assert prompt.answer({"action": "decline"}) == {
+ "action": "decline",
+ "content": None,
+ }
+
+
+def test_native_form_rejects_invalid_documented_string_format():
+ prompt = NativePrompt(
+ "mcpServer/elicitation/request",
+ 1,
+ {
+ "threadId": "thread",
+ "mode": "form",
+ "serverName": "tool",
+ "message": "Email",
+ "requestedSchema": {
+ "type": "object",
+ "properties": {"email": {"type": "string", "format": "email"}},
+ },
+ },
+ )
+ with pytest.raises(CodeValidationError):
+ prompt.answer({"action": "accept", "values": {"email": "invalid"}})
+ assert (
+ prompt.answer({"action": "accept", "values": {"email": "[email protected]"}})[
+ "action"
+ ]
+ == "accept"
+ )
+
+
[email protected]("choices,supported", [(["one", "two"], True), ([1, 2], False)])
+def test_multiselect_projection_matches_the_negotiated_string_contract(
+ choices, supported
+):
+ prompt = NativePrompt(
+ "mcpServer/elicitation/request",
+ 1,
+ {
+ "threadId": "thread",
+ "mode": "form",
+ "serverName": "tool",
+ "requestedSchema": {
+ "type": "object",
+ "properties": {
+ "selection": {
+ "type": "array",
+ "items": {
+ "oneOf": [
+ {"const": value, "title": str(value)}
+ for value in choices
+ ]
+ },
+ }
+ },
+ },
+ },
+ )
+ assert prompt.form["unsupported"] is not supported
+ if supported:
+ assert prompt.answer({"action": "accept", "values": {"selection": choices}})[
+ "content"
+ ] == {"selection": choices}
+ else:
+ with pytest.raises(CodeValidationError, match="not supported"):
+ prompt.answer({"action": "accept", "values": {"selection": choices}})
+ for action in ("decline", "cancel"):
+ assert prompt.answer({"action": action}) == {"action": action, "content": None}
+
+
+def test_history_preserves_native_turns_client_ids_and_failure_details():
+ native = CodexProtocol("g").history(
+ {
+ "thread": {
+ "id": "thread",
+ "turns": [
+ {
+ "id": "first",
+ "status": "failed",
+ "error": {
+ "message": "Rejected",
+ "additionalDetails": "details",
+ },
+ "items": [
+ {
+ "id": "user",
+ "type": "userMessage",
+ "clientId": "operation",
+ "content": [{"type": "text", "text": "Hello"}],
+ }
+ ],
+ }
+ ],
+ }
+ }
+ )
+ assert native.turns[0].items[0].client_id == "operation"
+ assert native.turns[0].status == "failed"
+ assert native.turns[0].error_details == {
+ "message": "Rejected",
+ "additionalDetails": "details",
+ }
diff --git a/uv.lock b/uv.lock
index e0b5729e..210c3d6e 100644
--- a/uv.lock
+++ b/uv.lock
@@ -598,7 +598,7 @@ wheels = [
[[package]]
name = "free-claude-code"
-version = "5.22.10"
+version = "5.23.2"
source = { editable = "." }
dependencies = [
{ name = "aiohttp" },