codexcomp 0.3.0__py3-none-any.whl

codexcomp/cli.py

@@ -0,0 +1,108 @@
+"""codexcomp CLI entry point (installed via [project.scripts]).
+
+Usage:
+  codexcomp [--host H] [--port P] [--upstream U] [--log-level L]   run the proxy
+  codexcomp install-service   [same flags]   opt-in autostart for this platform
+  codexcomp uninstall-service                remove the autostart entry
+"""
+from __future__ import annotations
+
+import argparse
+import logging
+import os
+import socket
+
+from . import service
+
+PORT_SCAN_TRIES = 20
+
+
+def _add_run_flags(p: argparse.ArgumentParser) -> None:
+    p.add_argument("--host", default="127.0.0.1",
+                   help="bind address (default: 127.0.0.1; keep it loopback)")
+    p.add_argument("--port", type=int, default=8787,
+                   help="bind port (default: 8787). Must match Codex's openai_base_url; "
+                        "if busy the proxy exits (a wired proxy must own its exact port).")
+    p.add_argument("--auto-port", action="store_true",
+                   help="if --port is busy, scan for the next free port and print it. "
+                        "Only for interactive one-off runs — you must then wire Codex to "
+                        "the printed port. Not for a wired background service.")
+    p.add_argument("--upstream", default=None,
+                   help="upstream base URL (default: https://chatgpt.com/backend-api/codex)")
+    p.add_argument("--log-level", default="info",
+                   choices=["critical", "error", "warning", "info", "debug"])
+
+
+def _port_in_use(host: str, port: int) -> bool:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.settimeout(0.3)
+        return s.connect_ex((host, port)) == 0
+
+
+def _pick_port(host: str, start: int) -> int:
+    """First free port at or after `start` (scans up to PORT_SCAN_TRIES). Falls
+    back to `start` so the bind fails loudly if nothing free was found."""
+    for port in range(start, start + PORT_SCAN_TRIES):
+        if not _port_in_use(host, port):
+            return port
+    return start
+
+
+def _serve(args) -> int:
+    import uvicorn
+    if args.upstream:
+        os.environ["CODEXCOMP_UPSTREAM_BASE"] = args.upstream
+    port = args.port
+    if args.auto_port:
+        port = _pick_port(args.host, args.port)
+        if port != args.port:
+            print(f"port {args.port} in use; bound {port} instead — "
+                  f"wire Codex to  openai_base_url = \"http://{args.host}:{port}/v1\"",
+                  flush=True)
+    elif _port_in_use(args.host, args.port):
+        # A wired proxy must own its exact port — fail loudly, don't drift.
+        print(f"error: port {args.port} is already in use. Free it, or pick another "
+              f"port with --port N (and set Codex's openai_base_url to match). "
+              f"Use --auto-port only for interactive one-off runs.", flush=True)
+        return 1
+    logging.basicConfig(level=args.log_level.upper(),
+                        format="%(levelname)s:%(name)s:%(message)s")
+    uvicorn.run("codexcomp.server:app", host=args.host, port=port,
+                log_level=args.log_level)
+    return 0
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="codexcomp",
+        description=(
+            "Local Responses proxy for Codex CLI: detects the gpt-5.5 518n-2 "
+            "reasoning-truncation fingerprint, auto-continues thinking, and folds "
+            "all rounds into one response. Wire Codex to it with the top-level "
+            'config key: openai_base_url = "http://127.0.0.1:8787/v1". '
+            "Run with no subcommand to start the proxy."
+        ),
+    )
+    _add_run_flags(parser)
+    sub = parser.add_subparsers(dest="cmd")
+
+    p_install = sub.add_parser(
+        "install-service",
+        help="opt-in: register autostart (systemd user / launchd / scheduled task)")
+    _add_run_flags(p_install)
+
+    sub.add_parser("uninstall-service", help="remove the autostart entry")
+    p_run = sub.add_parser("run", help="start the proxy (default when no subcommand)")
+    _add_run_flags(p_run)
+
+    args = parser.parse_args()
+
+    if args.cmd == "install-service":
+        raise SystemExit(service.install(args.host, args.port, args.upstream, args.log_level))
+    if args.cmd == "uninstall-service":
+        raise SystemExit(service.uninstall())
+    raise SystemExit(_serve(args))
+
+
+if __name__ == "__main__":
+    main()

codexcomp/fold.py

@@ -0,0 +1,361 @@
+"""518n-2 truncation detection + round folding for the Codex Responses event stream.
+
+gpt-5.5 reasoning gets cut at reasoning_tokens == 518*n - 2 (openai/codex#30364).
+When a round ends on that fingerprint we replay the conversation plus the round's
+reasoning items and a phase:"commentary" nudge, then fold every round into ONE
+downstream response: reasoning streams live, each round's tentative final output
+(message / tool calls) is buffered and only the clean round's output is flushed.
+
+Transport-agnostic: `fold()` consumes upstream events as dicts and yields
+downstream events as dicts; serialization (SSE / WebSocket) lives in server.py.
+
+Mechanism credit: neteroster/CodexCont (MIT). Implementation is original.
+"""
+from __future__ import annotations
+
+import logging
+from typing import Any, AsyncIterator, Awaitable, Callable
+
+log = logging.getLogger("codexcomp.fold")
+
+STEP = 518
+MIN_N = 1          # continue only when truncation tier n >= MIN_N
+MAX_N = 6          # stop forcing once n > MAX_N (0 = no cap)
+MAX_CONTINUE = 3   # continuation rounds after round 1 (runaway guard)
+MARKER_TEXT = "Continue thinking..."
+ENC_INCLUDE = "reasoning.encrypted_content"
+
+TERMINAL_TYPES = ("response.completed", "response.failed", "response.incomplete")
+
+# An opener returns the upstream event iterator for one round's body.
+RoundOpener = Callable[[dict[str, Any]], Awaitable[AsyncIterator[dict[str, Any]]]]
+
+
+class RoundOpenError(Exception):
+    """Continuation round could not be opened (upstream HTTP >= 400)."""
+
+    def __init__(self, status: int, detail: str):
+        super().__init__(f"upstream {status}: {detail[:200]}")
+        self.status = status
+
+
+DONE = object()  # sentinel an opener may yield to signal upstream sent [DONE]
+
+
+# --- fingerprint -------------------------------------------------------------
+
+
+def reasoning_tokens(usage: dict[str, Any] | None) -> int | None:
+    val = ((usage or {}).get("output_tokens_details") or {}).get("reasoning_tokens")
+    return int(val) if val is not None else None
+
+
+def tier_n(tokens: int | None) -> int | None:
+    """n for reasoning_tokens == STEP*n - 2 (516, 1034, ...), else None."""
+    if tokens is None or tokens < STEP - 2 or (tokens + 2) % STEP != 0:
+        return None
+    return (tokens + 2) // STEP
+
+
+def in_continue_window(n: int | None) -> bool:
+    return n is not None and n >= MIN_N and (MAX_N == 0 or n <= MAX_N)
+
+
+# --- continuation payload ----------------------------------------------------
+
+
+def commentary_nudge() -> dict[str, Any]:
+    """phase:"commentary" assistant message that provokes the model to resume
+    reasoning when replayed together with the encrypted reasoning items."""
+    return {
+        "type": "message",
+        "role": "assistant",
+        "content": [{"type": "output_text", "text": MARKER_TEXT}],
+        "phase": "commentary",
+    }
+
+
+def next_round_body(base_body: dict[str, Any], input_items: list[Any]) -> dict[str, Any]:
+    """The agent's request re-shaped for a continuation round: explicit input,
+    always streamed, encrypted reasoning included, no previous_response_id
+    (state is carried in the replayed items)."""
+    body = dict(base_body)
+    body["stream"] = True
+    body["input"] = input_items
+    include = [str(x) for x in (base_body.get("include") or [])]
+    if ENC_INCLUDE not in include:
+        include.append(ENC_INCLUDE)
+    body["include"] = include
+    body.pop("previous_response_id", None)
+    return body
+
+
+# --- usage accounting --------------------------------------------------------
+
+
+def _sum_usage(acc: dict[str, Any], usage: dict[str, Any] | None) -> None:
+    if not usage:
+        return
+    for key in ("input_tokens", "output_tokens", "total_tokens"):
+        if usage.get(key) is not None:
+            acc[key] = acc.get(key, 0) + int(usage[key])
+    cached = (usage.get("input_tokens_details") or {}).get("cached_tokens")
+    if cached is not None:
+        acc.setdefault("input_tokens_details", {})
+        acc["input_tokens_details"]["cached_tokens"] = (
+            acc["input_tokens_details"].get("cached_tokens", 0) + int(cached)
+        )
+    rt = reasoning_tokens(usage)
+    if rt is not None:
+        acc.setdefault("output_tokens_details", {})
+        acc["output_tokens_details"]["reasoning_tokens"] = (
+            acc["output_tokens_details"].get("reasoning_tokens", 0) + rt
+        )
+
+
+def agent_usage(
+    first: dict[str, Any] | None,
+    summed: dict[str, Any],
+    final_round: dict[str, Any] | None,
+    flushed_final: bool,
+) -> dict[str, Any]:
+    """Usage as if the fold were one response. input/cached come from round 1
+    (summing hidden rounds would fake a blown context window); reasoning is
+    summed because every round's reasoning reached the agent; output adds only
+    the flushed final round's non-reasoning part."""
+    first = first or {}
+    in_tok = first.get("input_tokens") or 0
+    cached = (first.get("input_tokens_details") or {}).get("cached_tokens")
+    reason = (summed.get("output_tokens_details") or {}).get("reasoning_tokens") or 0
+    final_part = 0
+    if flushed_final and final_round:
+        out = final_round.get("output_tokens") or 0
+        final_part = max(0, out - (reasoning_tokens(final_round) or 0))
+    usage: dict[str, Any] = {
+        "input_tokens": in_tok,
+        "output_tokens": reason + final_part,
+        "total_tokens": in_tok + reason + final_part,
+        "output_tokens_details": {"reasoning_tokens": reason},
+    }
+    if cached is not None:
+        usage["input_tokens_details"] = {"cached_tokens": cached}
+    return usage
+
+
+def _fmt(usage: dict[str, Any] | None) -> str:
+    u = usage or {}
+    return (
+        f"in={u.get('input_tokens')} out={u.get('output_tokens')} "
+        f"reason={reasoning_tokens(u)} total={u.get('total_tokens')}"
+    )
+
+
+# --- terminal reconstruction ---------------------------------------------------
+
+
+def _terminal_event(
+    upstream_terminal: dict[str, Any] | None,
+    base_response: dict[str, Any] | None,
+    output: list[dict[str, Any]],
+    usage: dict[str, Any],
+    rounds: list[dict[str, Any]],
+    billed: dict[str, Any],
+    stopped_reason: str | None,
+    *,
+    incomplete_reason: str | None = None,
+) -> dict[str, Any]:
+    """Downstream terminal: round-1 response identity, upstream status (or a
+    synthetic incomplete), our reconstructed output + single-response usage,
+    true billed cost and per-round breakdown in metadata."""
+    tresp = (upstream_terminal or {}).get("response") or {}
+    resp = dict(base_response or tresp)
+    resp["output"] = output
+    resp["usage"] = usage
+    metadata = dict(resp.get("metadata") or {})
+    metadata["proxy_rounds"] = rounds
+    metadata["proxy_billed_usage"] = billed
+    if stopped_reason:
+        metadata["proxy_stopped_reason"] = stopped_reason
+    resp["metadata"] = metadata
+    if incomplete_reason is not None:
+        resp["status"] = "incomplete"
+        resp["incomplete_details"] = {"reason": incomplete_reason}
+        return {"type": "response.incomplete", "response": resp}
+    resp["status"] = tresp.get("status", "completed")
+    if "incomplete_details" in tresp:
+        resp["incomplete_details"] = tresp["incomplete_details"]
+    return {"type": (upstream_terminal or {}).get("type", "response.completed"), "response": resp}
+
+
+# --- the fold ----------------------------------------------------------------
+
+
+async def fold(
+    base_body: dict[str, Any],
+    open_round: RoundOpener,
+) -> AsyncIterator[dict[str, Any] | object]:
+    """Yield downstream events (dicts, plus the DONE sentinel when upstream sent
+    one). Every yielded event gets a proxy-owned sequence_number; output_index
+    is renumbered into one downstream space across rounds."""
+    orig_input = list(base_body.get("input") or [])
+    seq = 0
+    ds_oi = 0
+    base_response: dict[str, Any] | None = None
+    saw_done = False
+    final_output: list[dict[str, Any]] = []
+    replay_tail: list[Any] = []
+    summed_usage: dict[str, Any] = {}
+    first_usage: dict[str, Any] | None = None
+    rounds_info: list[dict[str, Any]] = []
+
+    def stamp(ev: dict[str, Any]) -> dict[str, Any]:
+        nonlocal seq
+        ev["sequence_number"] = seq
+        seq += 1
+        return ev
+
+    round_no = 0
+    events = await open_round(next_round_body(base_body, orig_input))
+
+    while True:
+        round_no += 1
+        oi_to_ds: dict[Any, int] = {}
+        kind: dict[Any, str] = {}
+        buffered: list[dict[str, Any]] = []  # {oi, item, events}
+        round_reasoning: list[dict[str, Any]] = []
+        terminal: dict[str, Any] | None = None
+        usage: dict[str, Any] | None = None
+
+        try:
+            async for ev in events:
+                if ev is DONE:
+                    saw_done = True
+                    continue
+                etype = ev.get("type", "")
+
+                if etype in ("response.created", "response.in_progress"):
+                    if round_no == 1:
+                        if etype == "response.created":
+                            base_response = ev.get("response") or {}
+                        yield stamp(ev)
+                    continue
+                if etype in TERMINAL_TYPES:
+                    terminal = ev
+                    usage = (ev.get("response") or {}).get("usage")
+                    break
+
+                oi = ev.get("output_index")
+                if etype == "response.output_item.added":
+                    item = ev.get("item") or {}
+                    if item.get("type") == "reasoning":
+                        kind[oi] = "reasoning"
+                        oi_to_ds[oi] = ds_oi
+                        ev["output_index"] = ds_oi
+                        ds_oi += 1
+                        yield stamp(ev)
+                    else:
+                        kind[oi] = "buffered"
+                        buffered.append({"oi": oi, "item": item, "events": [ev]})
+                    continue
+
+                k = kind.get(oi)
+                if k == "reasoning":
+                    if oi in oi_to_ds:
+                        ev["output_index"] = oi_to_ds[oi]
+                    if etype == "response.output_item.done":
+                        item = ev.get("item") or {}
+                        round_reasoning.append(item)
+                        final_output.append(item)
+                    yield stamp(ev)
+                elif k == "buffered":
+                    entry = next(e for e in buffered if e["oi"] == oi)
+                    entry["events"].append(ev)
+                    if etype == "response.output_item.done":
+                        entry["item"] = ev.get("item") or entry["item"]
+                else:
+                    yield stamp(ev)  # unknown scope: forward best-effort
+        except RoundOpenError:
+            raise  # only raised before any event; handled by caller for round 1
+        except Exception as exc:  # upstream died mid-stream
+            log.warning("round %d: upstream error mid-stream: %r", round_no, exc)
+            _sum_usage(summed_usage, usage)
+            yield stamp(_terminal_event(
+                None, base_response, final_output,
+                agent_usage(first_usage, summed_usage, usage, flushed_final=False),
+                rounds_info, summed_usage, "upstream_error",
+                incomplete_reason="upstream_error"))
+            return
+
+        # ---- round ended: decide continue / stop ----------------------------
+        _sum_usage(summed_usage, usage)
+        if round_no == 1:
+            first_usage = usage
+        rt = reasoning_tokens(usage)
+        n = tier_n(rt)
+        rounds_info.append({"round": round_no, "reasoning_tokens": rt, "n": n})
+        has_enc = bool(round_reasoning and round_reasoning[-1].get("encrypted_content"))
+
+        do_continue = (
+            terminal is not None
+            and in_continue_window(n)
+            and has_enc
+            and round_no <= MAX_CONTINUE
+        )
+        stopped_reason = None
+        if not do_continue and n is not None:
+            stopped_reason = (
+                "no_encrypted_content" if not has_enc
+                else "max_continue" if round_no > MAX_CONTINUE
+                else "tier_out_of_window"
+            )
+
+        log.info(
+            "round %d: %s | n=%s buffered=%s -> %s",
+            round_no, _fmt(usage), n,
+            [e["item"].get("type") for e in buffered],
+            "continue" if do_continue else
+            "upstream_eof" if terminal is None else stopped_reason or "clean",
+        )
+
+        if do_continue:
+            replay_tail.extend([*round_reasoning, commentary_nudge()])
+            try:
+                events = await open_round(next_round_body(base_body, orig_input + replay_tail))
+            except RoundOpenError as exc:
+                log.warning("continuation round %d failed to open: %s", round_no + 1, exc)
+                yield stamp(_terminal_event(
+                    None, base_response, final_output,
+                    agent_usage(first_usage, summed_usage, usage, flushed_final=False),
+                    rounds_info, summed_usage, "upstream_error",
+                    incomplete_reason="upstream_error"))
+                return
+            continue
+
+        if terminal is None:  # EOF with no terminal: tentative output is NOT an answer
+            log.warning("round %d: upstream EOF with no terminal event", round_no)
+            yield stamp(_terminal_event(
+                None, base_response, final_output,
+                agent_usage(first_usage, summed_usage, usage, flushed_final=False),
+                rounds_info, summed_usage, "upstream_eof",
+                incomplete_reason="upstream_eof"))
+            return
+
+        # Clean stop: flush this round's buffered output as the real answer.
+        for entry in buffered:
+            for ev in entry["events"]:
+                if "output_index" in ev:
+                    ev["output_index"] = ds_oi
+                yield stamp(ev)
+            ds_oi += 1
+            final_output.append(entry["item"])
+
+        status = (terminal.get("response") or {}).get("status", "completed")
+        log.info("done: %d round(s) | %s | status=%s stop=%s",
+                 round_no, _fmt(summed_usage), status, stopped_reason or "natural")
+        yield stamp(_terminal_event(
+            terminal, base_response, final_output,
+            agent_usage(first_usage, summed_usage, usage, flushed_final=True),
+            rounds_info, summed_usage, stopped_reason))
+        if saw_done:
+            yield DONE
+        return

codexcomp/server.py

@@ -0,0 +1,248 @@
+"""codexcomp transport layer.
+
+Downstream (Codex, wired via top-level `openai_base_url`):
+  * WebSocket /v1/responses  — Codex's preferred transport (openai-beta
+    responses_websockets): client sends {"type":"response.create", ...body...}
+    frames, we answer with response.* event frames; the connection is reused
+    for sequential requests (prewarm + turns).
+  * POST /v1/responses       — SSE fallback; request body may be zstd/gzip
+    compressed (built-in provider sends zstd when request compression is on).
+  * anything else under /v1/ — transparent passthrough to the upstream base
+    (Codex refreshes its model catalog via GET /v1/models).
+
+Upstream is always the SSE POST endpoint; the fold state machine (fold.py) is
+transport-agnostic.
+"""
+from __future__ import annotations
+
+import gzip
+import json
+import logging
+import os
+import zlib
+from typing import Any, AsyncIterator
+
+import httpx
+import zstandard
+from starlette.applications import Starlette
+from starlette.requests import Request
+from starlette.responses import JSONResponse, Response, StreamingResponse
+from starlette.routing import Route, WebSocketRoute
+from starlette.websockets import WebSocket, WebSocketDisconnect
+
+from .fold import DONE, RoundOpenError, fold
+
+log = logging.getLogger("codexcomp.server")
+
+UPSTREAM_BASE = os.environ.get(
+    "CODEXCOMP_UPSTREAM_BASE", "https://chatgpt.com/backend-api/codex"
+).rstrip("/")
+RESPONSES_URL = UPSTREAM_BASE + "/responses"
+
+# hop-by-hop / transport-specific headers never forwarded upstream
+_DROP_HEADERS = {
+    "host", "connection", "upgrade", "keep-alive", "te", "trailer",
+    "transfer-encoding", "proxy-authorization", "proxy-connection",
+    "content-length", "content-encoding", "accept-encoding",
+    "sec-websocket-key", "sec-websocket-version", "sec-websocket-extensions",
+    "sec-websocket-protocol",
+    "openai-beta",  # advertises the ws protocol; upstream round is plain SSE
+}
+
+
+def upstream_headers(raw: Any) -> dict[str, str]:
+    out = {}
+    for key, value in raw:
+        k = key.decode() if isinstance(key, bytes) else key
+        if k.lower() in _DROP_HEADERS:
+            continue
+        out[k] = value.decode() if isinstance(value, bytes) else value
+    out["accept"] = "text/event-stream"
+    return out
+
+
+def decompress_body(data: bytes, encoding: str | None) -> bytes:
+    enc = (encoding or "").lower().strip()
+    if not enc or enc == "identity":
+        return data
+    if enc == "zstd":
+        return zstandard.ZstdDecompressor().decompressobj().decompress(data)
+    if enc == "gzip":
+        return gzip.decompress(data)
+    if enc == "deflate":
+        return zlib.decompress(data)
+    raise ValueError(f"unsupported content-encoding: {enc}")
+
+
+# --- upstream SSE rounds ------------------------------------------------------
+
+
+def parse_sse(text_chunks: AsyncIterator[str]) -> AsyncIterator[dict | object]:
+    """Incremental SSE parser: yields event dicts (from data: lines) and the
+    DONE sentinel for `data: [DONE]`."""
+
+    async def gen():
+        buf = ""
+        async for chunk in text_chunks:
+            buf += chunk
+            while "\n\n" in buf:
+                block, buf = buf.split("\n\n", 1)
+                data_lines = [
+                    line[5:].lstrip()
+                    for line in block.splitlines()
+                    if line.startswith("data:")
+                ]
+                if not data_lines:
+                    continue
+                data = "\n".join(data_lines)
+                if data == "[DONE]":
+                    yield DONE
+                    continue
+                try:
+                    yield json.loads(data)
+                except json.JSONDecodeError:
+                    log.warning("unparseable SSE data (len=%d), dropped", len(data))
+
+    return gen()
+
+
+class UpstreamRounds:
+    """RoundOpener bound to one downstream request's headers; closes the
+    previous round's response before opening the next."""
+
+    def __init__(self, client: httpx.AsyncClient, headers: dict[str, str]):
+        self.client = client
+        self.headers = headers
+        self._resp: httpx.Response | None = None
+
+    async def open(self, body: dict[str, Any]) -> AsyncIterator[dict | object]:
+        await self.aclose()
+        req = self.client.build_request(
+            "POST", RESPONSES_URL,
+            content=json.dumps(body, ensure_ascii=False).encode(),
+            headers={**self.headers, "content-type": "application/json"},
+            timeout=httpx.Timeout(connect=30, read=600, write=60, pool=30),
+        )
+        resp = await self.client.send(req, stream=True)
+        if resp.status_code >= 400:
+            detail = (await resp.aread()).decode(errors="replace")
+            await resp.aclose()
+            raise RoundOpenError(resp.status_code, detail)
+        self._resp = resp
+        return parse_sse(resp.aiter_text())
+
+    async def aclose(self) -> None:
+        if self._resp is not None:
+            try:
+                await self._resp.aclose()
+            except Exception:
+                pass
+            self._resp = None
+
+
+# --- downstream endpoints -----------------------------------------------------
+
+
+def sse_bytes(ev: dict | object) -> bytes:
+    if ev is DONE:
+        return b"data: [DONE]\n\n"
+    etype = ev.get("type", "message")  # type: ignore[union-attr]
+    return f"event: {etype}\ndata: {json.dumps(ev, ensure_ascii=False)}\n\n".encode()
+
+
+async def responses_post(request: Request) -> Response:
+    raw = await request.body()
+    try:
+        raw = decompress_body(raw, request.headers.get("content-encoding"))
+        body = json.loads(raw)
+    except (ValueError, json.JSONDecodeError) as exc:
+        return JSONResponse({"error": f"bad request body: {exc}"}, status_code=400)
+
+    rounds = UpstreamRounds(request.app.state.client, upstream_headers(request.headers.raw))
+
+    async def stream() -> AsyncIterator[bytes]:
+        try:
+            async for ev in fold(body, rounds.open):
+                yield sse_bytes(ev)
+        except RoundOpenError as exc:  # round 1 rejected: surface upstream error
+            yield sse_bytes({
+                "type": "response.failed",
+                "response": {"status": "failed",
+                             "error": {"message": str(exc), "code": exc.status}},
+            })
+        finally:
+            await rounds.aclose()
+
+    return StreamingResponse(stream(), media_type="text/event-stream")
+
+
+async def responses_ws(ws: WebSocket) -> None:
+    await ws.accept()
+    headers = upstream_headers(ws.headers.raw)
+    rounds = UpstreamRounds(ws.app.state.client, headers)
+    try:
+        while True:
+            try:
+                envelope = json.loads(await ws.receive_text())
+            except (WebSocketDisconnect, json.JSONDecodeError):
+                return
+            if envelope.get("type") != "response.create":
+                log.info("ws: ignoring frame type %s", envelope.get("type"))
+                continue
+            body = {k: v for k, v in envelope.items() if k != "type"}
+            try:
+                async for ev in fold(body, rounds.open):
+                    if ev is DONE:
+                        continue
+                    await ws.send_text(json.dumps(ev, ensure_ascii=False))
+            except RoundOpenError as exc:
+                await ws.send_text(json.dumps({
+                    "type": "response.failed",
+                    "response": {"status": "failed",
+                                 "error": {"message": str(exc), "code": exc.status}},
+                }))
+    except WebSocketDisconnect:
+        pass
+    finally:
+        await rounds.aclose()
+
+
+async def passthrough(request: Request) -> Response:
+    """Transparent proxy for every other /v1/* call (e.g. GET /v1/models)."""
+    suffix = request.path_params["path"]
+    url = f"{UPSTREAM_BASE}/{suffix}"
+    if request.url.query:
+        url += "?" + request.url.query
+    content = await request.body()
+    if content:
+        content = decompress_body(content, request.headers.get("content-encoding"))
+    headers = upstream_headers(request.headers.raw)
+    headers.pop("accept", None)
+    upstream = await request.app.state.client.request(
+        request.method, url, content=content or None, headers=headers,
+        timeout=httpx.Timeout(60),
+    )
+    drop = {"content-encoding", "transfer-encoding", "connection", "content-length"}
+    return Response(
+        upstream.content, status_code=upstream.status_code,
+        headers={k: v for k, v in upstream.headers.items() if k.lower() not in drop},
+    )
+
+
+async def health(_: Request) -> JSONResponse:
+    return JSONResponse({"ok": True, "upstream": UPSTREAM_BASE})
+
+
+def build_app() -> Starlette:
+    app = Starlette(routes=[
+        Route("/healthz", health),
+        Route("/v1/responses", responses_post, methods=["POST"]),
+        WebSocketRoute("/v1/responses", responses_ws),
+        Route("/v1/{path:path}", passthrough,
+              methods=["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD"]),
+    ])
+    app.state.client = httpx.AsyncClient(trust_env=True, http2=False)
+    return app
+
+
+app = build_app()

codexcomp/service.py

@@ -0,0 +1,231 @@
+"""Optional autostart registration — strictly opt-in.
+
+`codexcomp install-service` writes and activates a per-user autostart entry
+for the current platform; `uninstall-service` removes it. Plain `uv tool install`
+never touches any of this — autostart is always the user's explicit choice.
+
+Per-user (not system-wide) on every platform: the proxy is a loopback service
+used by Codex inside the user's own login session, needs the user's proxy
+environment to reach upstream, and requires no root.
+"""
+from __future__ import annotations
+
+import os
+import platform
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+LABEL = "codexcomp"
+MAC_LABEL = "com.dzshzx.codexcomp"
+
+
+def _resolve_exe() -> str:
+    """Absolute path to the installed console-script executable.
+
+    Prefer PATH lookup (stable ~/.local/bin entry). Fall back to sys.argv[0]
+    when the tool dir isn't on PATH — and on Windows re-attach the .exe suffix,
+    which sys.argv[0] drops for console-script launchers.
+    """
+    found = shutil.which(LABEL)
+    if found:
+        return found
+    cand = os.path.abspath(sys.argv[0])
+    if os.name == "nt" and not cand.lower().endswith(".exe") and os.path.exists(cand + ".exe"):
+        cand += ".exe"
+    return cand
+
+
+def _exe_and_args(host: str | None, port: int | None,
+                  upstream: str | None, log_level: str | None) -> list[str]:
+    """Resolved executable path plus any non-default run flags."""
+    argv = [_resolve_exe()]
+    if host and host != "127.0.0.1":
+        argv += ["--host", host]
+    if port and port != 8787:
+        argv += ["--port", str(port)]
+    if upstream:
+        argv += ["--upstream", upstream]
+    if log_level and log_level != "info":
+        argv += ["--log-level", log_level]
+    return argv
+
+
+def _run(cmd: list[str], *, check: bool = True) -> subprocess.CompletedProcess:
+    # errors="replace": Windows tools (taskkill/schtasks) emit localized,
+    # non-UTF-8 output that would otherwise raise UnicodeDecodeError.
+    return subprocess.run(cmd, check=check, capture_output=True,
+                          text=True, errors="replace")
+
+
+# --- Linux (systemd user unit) ----------------------------------------------
+
+
+def _systemd_unit_path() -> Path:
+    base = Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config"))
+    return base / "systemd" / "user" / f"{LABEL}.service"
+
+
+def _install_linux(argv: list[str]) -> None:
+    if not shutil.which("systemctl"):
+        raise RuntimeError(
+            "systemctl not found. Write a unit manually or use your init system; "
+            "see the systemd example in the project README.")
+    exec_start = " ".join(argv)
+    unit = f"""[Unit]
+Description=codexcomp: local Responses proxy folding gpt-5.5 518n-2 reasoning truncation
+After=network-online.target
+
+[Service]
+ExecStart={exec_start}
+Restart=on-failure
+RestartSec=2
+# Drop a possible SOCKS proxy from the user manager env; httpx honors HTTP(S)_PROXY.
+UnsetEnvironment=ALL_PROXY all_proxy SOCKS_PROXY socks_proxy
+
+[Install]
+WantedBy=default.target
+"""
+    path = _systemd_unit_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(unit)
+    _run(["systemctl", "--user", "daemon-reload"])
+    _run(["systemctl", "--user", "enable", "--now", f"{LABEL}.service"])
+    print(f"installed + started systemd user service: {path}")
+    print("  tip: run 'loginctl enable-linger' once to start it at boot without login")
+    print(f"  disable: codexcomp uninstall-service   (or systemctl --user disable --now {LABEL})")
+
+
+def _uninstall_linux() -> None:
+    if shutil.which("systemctl"):
+        _run(["systemctl", "--user", "disable", "--now", f"{LABEL}.service"], check=False)
+    path = _systemd_unit_path()
+    existed = path.exists()
+    path.unlink(missing_ok=True)
+    if shutil.which("systemctl"):
+        _run(["systemctl", "--user", "daemon-reload"], check=False)
+    print(f"removed systemd user service{'' if existed else ' (was not present)'}: {path}")
+
+
+# --- macOS (launchd LaunchAgent) --------------------------------------------
+
+
+def _plist_path() -> Path:
+    return Path.home() / "Library" / "LaunchAgents" / f"{MAC_LABEL}.plist"
+
+
+def _install_macos(argv: list[str]) -> None:
+    args_xml = "\n".join(f"        <string>{a}</string>" for a in argv)
+    log = f"/tmp/{LABEL}.log"
+    plist = f"""<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>            <string>{MAC_LABEL}</string>
+    <key>ProgramArguments</key>
+    <array>
+{args_xml}
+    </array>
+    <key>RunAtLoad</key>        <true/>
+    <key>KeepAlive</key>        <true/>
+    <key>StandardOutPath</key>  <string>{log}</string>
+    <key>StandardErrorPath</key><string>{log}</string>
+</dict>
+</plist>
+"""
+    path = _plist_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(plist)
+    uid = os.getuid()
+    _run(["launchctl", "bootstrap", f"gui/{uid}", str(path)], check=False)
+    _run(["launchctl", "enable", f"gui/{uid}/{MAC_LABEL}"], check=False)
+    _run(["launchctl", "kickstart", "-k", f"gui/{uid}/{MAC_LABEL}"], check=False)
+    print(f"installed + started launchd LaunchAgent: {path}")
+    print(f"  logs: {log}")
+    print("  disable: codexcomp uninstall-service")
+
+
+def _uninstall_macos() -> None:
+    path = _plist_path()
+    uid = os.getuid()
+    _run(["launchctl", "bootout", f"gui/{uid}/{MAC_LABEL}"], check=False)
+    existed = path.exists()
+    path.unlink(missing_ok=True)
+    print(f"removed launchd LaunchAgent{'' if existed else ' (was not present)'}: {path}")
+
+
+# --- Windows (manual autostart, by design) ----------------------------------
+#
+# We intentionally do NOT register Windows autostart programmatically. Writing an
+# autostart entry (Startup VBS / Run key / task) and launching a hidden process
+# is exactly the persistence pattern behavioral antivirus flags as a trojan
+# (observed: Kaspersky PDM:Trojan.Win32.Generic on the launching python.exe).
+# A user-created Startup shortcut is trusted by the same AV. So print the steps,
+# pointing at the windowless launcher, and register nothing.
+
+
+def _guiw_exe() -> str:
+    """The windowless launcher (codexcompw.exe) beside the console exe."""
+    console = _resolve_exe()
+    if console.lower().endswith(".exe"):
+        cand = console[:-4] + "w.exe"
+        if os.path.exists(cand):
+            return cand
+    return shutil.which(LABEL + "w") or (console[:-4] + "w.exe"
+                                         if console.lower().endswith(".exe") else console)
+
+
+def _install_windows(argv: list[str]) -> None:
+    exe_w = _guiw_exe()
+    extra = subprocess.list2cmdline(argv[1:])
+    print("Windows autostart is not registered automatically — behavioral antivirus")
+    print("flags programmatic startup persistence as trojan-like. Set it up by hand")
+    print("(a user-created shortcut is AV-trusted):")
+    print("  1. press Win+R, run:  shell:startup")
+    print(f"  2. create a shortcut whose target is:  {exe_w}")
+    if extra:
+        print(f"     append these arguments:  {extra}")
+    print("  (…codexcompw.exe is windowless — no console window at logon)")
+
+
+def _uninstall_windows() -> None:
+    print("Windows autostart is manual: delete your codexcomp shortcut from")
+    print("the Startup folder (Win+R -> shell:startup).")
+
+
+# --- dispatch ----------------------------------------------------------------
+
+
+def install(host=None, port=None, upstream=None, log_level=None) -> int:
+    argv = _exe_and_args(host, port, upstream, log_level)
+    system = platform.system()
+    try:
+        if system == "Linux":
+            _install_linux(argv)
+        elif system == "Darwin":
+            _install_macos(argv)
+        elif system == "Windows":
+            _install_windows(argv)
+        else:
+            print(f"unsupported platform: {system}", file=sys.stderr)
+            return 2
+    except (RuntimeError, subprocess.CalledProcessError) as exc:
+        detail = getattr(exc, "stderr", "") or str(exc)
+        print(f"install-service failed: {detail}", file=sys.stderr)
+        return 1
+    return 0
+
+
+def uninstall() -> int:
+    system = platform.system()
+    if system == "Linux":
+        _uninstall_linux()
+    elif system == "Darwin":
+        _uninstall_macos()
+    elif system == "Windows":
+        _uninstall_windows()
+    else:
+        print(f"unsupported platform: {system}", file=sys.stderr)
+        return 2
+    return 0

codexcomp-0.3.0.dist-info/METADATA

@@ -0,0 +1,259 @@
+Metadata-Version: 2.4
+Name: codexcomp
+Version: 0.3.0
+Summary: Local Responses proxy for OpenAI Codex CLI: folds gpt-5.5 518n-2 reasoning truncation (516 degradation) via the official openai_base_url wiring — no provider change, WebSocket-first, no fallback noise.
+Project-URL: Homepage, https://github.com/dzshzx/codexcomp
+Project-URL: Repository, https://github.com/dzshzx/codexcomp
+Project-URL: Issues, https://github.com/dzshzx/codexcomp/issues
+Author: dzshzx
+License-Expression: MIT
+License-File: LICENSE
+Keywords: 516,codex,gpt-5.5,openai,proxy,reasoning
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet :: Proxy Servers
+Requires-Python: >=3.12
+Requires-Dist: httpx>=0.27
+Requires-Dist: starlette>=0.41
+Requires-Dist: uvicorn[standard]>=0.32
+Requires-Dist: zstandard>=0.23
+Description-Content-Type: text/markdown
+
+# codexcomp
+
+[![PyPI](https://img.shields.io/pypi/v/codexcomp.svg)](https://pypi.org/project/codexcomp/)
+[![Python](https://img.shields.io/pypi/pyversions/codexcomp.svg)](https://pypi.org/project/codexcomp/)
+[![License: MIT](https://img.shields.io/pypi/l/codexcomp.svg)](https://github.com/dzshzx/codexcomp/blob/main/LICENSE)
+
+**English** · [简体中文](README.zh-CN.md)
+
+A tiny local Responses proxy for the **OpenAI Codex CLI** that cures the gpt-5.5
+**"516" reasoning-truncation degradation** — while leaving your `model_provider`
+untouched, so session grouping, remote compaction and remote-control keep working.
+
+```bash
+uv tool install codexcomp      # install
+codexcomp                      # run (127.0.0.1:8787)
+# then add one line to ~/.codex/config.toml:  openai_base_url = "http://127.0.0.1:8787/v1"
+```
+
+> **Credits.** The detection-and-continue idea comes from
+> [**neteroster/CodexCont**](https://github.com/neteroster/CodexCont) (MIT) — thank you.
+> This project is an independent, from-scratch implementation that keeps the built-in
+> provider intact; see [Differences](#differences-from-codexcont).
+
+---
+
+## The problem: gpt-5.5 "516" degradation
+
+On the OpenAI Codex CLI, gpt-5.5's reasoning sometimes gets cut short at a very
+specific token count — `reasoning_tokens == 518 * n − 2` (i.e. **516, 1034, 1552, …**).
+When a turn lands on that fingerprint, the model stops thinking early and the answer
+quality drops sharply. It is an upstream issue with no official fix
+([openai/codex#30364](https://github.com/openai/codex/issues/30364)).
+
+`codexcomp` sits on `127.0.0.1` between Codex and the upstream Responses API.
+When it sees a turn truncate on the `518n−2` fingerprint, it **makes the model keep
+thinking** and **folds the extra rounds into a single downstream response**, so Codex
+sees one clean, complete answer.
+
+## How it works
+
+The proxy streams every upstream round and runs a small state machine (`codexcomp/fold.py`):
+
+1. **Detect.** At the end of each round it reads
+   `usage.output_tokens_details.reasoning_tokens`. If it equals `518n − 2` (with
+   `1 ≤ n ≤ 6`, and at most 3 continuation rounds), the round was truncated.
+2. **Continue.** It discards that round's *tentative* output (the message / tool calls —
+   they were produced on truncated thinking), then replays the round's reasoning items
+   (including `encrypted_content`) plus a single `phase:"commentary"` assistant message
+   (`"Continue thinking..."`) as the next round's input. That nudges the model to resume
+   reasoning where it left off.
+3. **Fold.** Reasoning is streamed live to Codex the whole time; only the *clean* final
+   round's output is flushed. The terminal event is rebuilt as if the whole thing were
+   one response — `input`/`cached` come from round 1 (so it never looks like a blown
+   context window), reasoning is summed, and the true cumulative cost is recorded under
+   `metadata.proxy_billed_usage`.
+
+### Wiring: why the built-in provider stays intact
+
+Codex is pointed at the proxy with **one top-level config key**, not a new provider:
+
+```toml
+# ~/.codex/config.toml  (top level, before the first [table])
+openai_base_url = "http://127.0.0.1:8787/v1"
+```
+
+`openai_base_url` overrides the base URL of the **built-in `openai` provider** in place.
+This is the officially supported key
+([openai/codex#16719](https://github.com/openai/codex/issues/16719); the same-name
+`[model_providers.openai]` override is rejected by the maintainers, and the
+`OPENAI_BASE_URL` env var was removed). Because the provider id stays `openai`:
+
+- your conversation history is **not** re-bucketed/hidden by provider,
+- **remote compaction** keeps working (`supports_remote_compaction` stays true),
+- **remote-control** is unaffected (it uses the separate `chatgpt_base_url`).
+
+### Differences from CodexCont
+
+The 518n−2 detection + fold-continuation mechanism is [CodexCont]'s idea; the
+implementation here is new and diverges on a few deliberate points:
+
+|  | codexcomp | CodexCont |
+| --- | --- | --- |
+| **Codex wiring** | top-level `openai_base_url` (**built-in provider unchanged**) | a new `[model_providers]` entry (history hidden per-provider, remote-control unusable, remote compaction lost) |
+| **Downstream transport** | **WebSocket-first** — full `responses_websockets` protocol, plus SSE fallback | SSE only (Codex tries ws → 405 → ~5 reconnect warnings per session, then falls back) |
+| **zstd request bodies** (0.142.x built-in provider) | decompressed natively, no Codex config change | needs `[features] enable_request_compression = false` |
+| **`GET /v1/models`** (model-catalog refresh) | passed through (`/v1/*`) | not proxied (silently fails, relies on cache) |
+| **Continuation** | commentary method only | commentary + legacy tool-pair + cross-turn repair, more knobs |
+
+[CodexCont]: https://github.com/neteroster/CodexCont
+
+## Install
+
+Requires [uv](https://docs.astral.sh/uv/) (which manages Python for you) and the Codex
+CLI (ChatGPT OAuth login; tested on 0.142.x).
+
+```bash
+uv tool install codexcomp          # from PyPI
+# or straight from source:
+# uv tool install git+https://github.com/dzshzx/codexcomp
+```
+
+uv puts the executable in its bin dir (`~/.local/bin` on Unix/macOS; on Windows run
+`where.exe codexcomp`; `uv tool update-shell` adds it to PATH). Then:
+
+```bash
+codexcomp                          # run in foreground (default 127.0.0.1:8787)
+codexcomp --port 8790 --log-level debug
+```
+
+Wire Codex to it (one line in `~/.codex/config.toml`, see above), and you're done.
+**Disable** by commenting out the `openai_base_url` line and stopping the proxy. (If the
+key stays but the proxy is down, Codex errors on an unreachable upstream.)
+
+Upgrade / uninstall: `uv tool upgrade codexcomp` / `uv tool uninstall codexcomp`.
+
+### Ports
+
+The proxy's port **must match** the port in Codex's `openai_base_url`. If the default
+port (8787) is busy, the proxy **exits with a clear message** rather than drifting — a
+wired proxy that silently binds another port would just be unreachable. To use a
+different port, pass `--port N` and set `openai_base_url` to the same `N`.
+
+`--auto-port` is for interactive one-off runs only: on a conflict it scans for the next
+free port and prints which `openai_base_url` to use. Don't use it for a wired service.
+
+## Autostart (optional, off by default)
+
+Installing registers **no** autostart — it's entirely your choice.
+
+```bash
+codexcomp install-service     # register + start (current platform)
+codexcomp uninstall-service   # remove
+```
+
+`install-service` picks the per-user, runs-in-your-session mechanism (a system service
+runs in a session with no user environment and can't reach the uv executable or your
+proxy settings under your profile):
+
+- **Linux / WSL** → a systemd **user** unit (`~/.config/systemd/user/`). Run
+  `loginctl enable-linger` once to start it at boot without logging in. Manual equivalent:
+  see `systemd/codexcomp.service.example`.
+- **macOS** → a launchd **LaunchAgent** in `~/Library/LaunchAgents/` (starts at login, in
+  your GUI session). Load with `launchctl bootstrap gui/$(id -u) <plist>` /
+  `launchctl kickstart -k …`; remove with `launchctl bootout …`.
+- **Windows** → **prints manual steps, registers nothing** (see below).
+
+### Windows autostart is manual — on purpose
+
+A program that writes an autostart entry (Startup VBS / Run key / scheduled task) and
+launches a hidden process trips behavioral antivirus as trojan-like persistence —
+Kaspersky's proactive-defense module flags the launching `python.exe` as
+`PDM:Trojan.Win32.Generic`. A **user-created** Startup shortcut is trusted by the same AV.
+
+So this package ships a windowless launcher, `codexcompw` (a Windows GUI-subsystem
+exe — no console window at logon), and `install-service` just tells you how to point a
+shortcut at it:
+
+1. `Win+R` → `shell:startup` (opens the Startup folder).
+2. New → Shortcut → target = the path from `where.exe codexcompw` (append
+   `--port N` if you use a custom port).
+
+Delete the shortcut to disable it.
+
+### Mirrored-networking shortcut (WSL ↔ Windows)
+
+If your WSL2 uses `networkingMode=mirrored`, Windows and WSL **share `127.0.0.1`**. Then
+you only need **one** proxy on either side — run it in WSL (as a systemd service), and on
+the Windows side just add the `openai_base_url` line to `~/.codex/config.toml` pointing at
+the same `127.0.0.1:8787`. No second proxy or Windows autostart needed (the only cost is
+that Windows Codex depends on the WSL proxy being up).
+
+## Verify
+
+```bash
+curl -sS http://127.0.0.1:8787/healthz            # {"ok":true,...}
+journalctl --user -u codexcomp -f | grep -E 'round|done'   # Linux/WSL
+```
+
+A live fold looks like this (two chained 516s beaten, answer correct):
+
+```
+round 1: in=21550 out=664 reason=516 total=22214 | n=1 buffered=['function_call'] -> continue
+round 2: in=22078 out=652 reason=516 total=22730 | n=1 buffered=['function_call'] -> continue
+round 3: in=22606 out=566 reason=291 total=23172 | n=None buffered=[...] -> clean
+done: 3 round(s) | ... | status=completed stop=natural
+```
+
+## Develop
+
+```bash
+git clone https://github.com/dzshzx/codexcomp && cd codexcomp
+uv sync
+uv run python test_fold.py        # fold state-machine self-test → ALL PASS
+uv run codexcomp            # run locally
+```
+
+Releases go out via PyPI Trusted Publishing (`.github/workflows/release.yml`, OIDC, no
+stored token): push a `v*` tag and it builds + publishes automatically.
+
+Layout:
+
+- `codexcomp/fold.py` — fingerprint detection + fold state machine (transport-agnostic;
+  covered by `test_fold.py`).
+- `codexcomp/server.py` — starlette transport: ws / SSE downstream, SSE upstream,
+  zstd/gzip request decompression, `/v1/*` passthrough.
+- `codexcomp/cli.py` — CLI entry (`codexcomp`; loopback only; auth passthrough, stores
+  no credentials).
+
+## Security & disclaimer
+
+- The proxy is **auth passthrough** only: it forwards Codex's `Authorization` header and
+  never reads, stores, or logs any credential.
+- It listens on the **loopback** address only — do not expose it on a non-loopback interface.
+- **Unofficial**: it depends on upstream behavior that isn't a public contract (the
+  truncation fingerprint, the ws frame format). An OpenAI-side change may break it. Use at
+  your own risk.
+- Continuation spends **extra real tokens** (see `metadata.proxy_billed_usage`); codexcomp
+  bounds this with an `n` window and a 3-round cap.
+
+## Community
+
+Built for and shared with the [**LINUX DO**](https://linux.do) community, where the
+gpt-5.5 "516" degradation was diagnosed and discussed. Feedback and issues welcome there
+and on [GitHub Issues](https://github.com/dzshzx/codexcomp/issues).
+
+## License
+
+[MIT](LICENSE). Fully open source, no closed parts.
+
+Mechanism credit: [**neteroster/CodexCont**](https://github.com/neteroster/CodexCont) (MIT) —
+this project reuses its 518n−2 detect-and-continue *idea* with an independent, from-scratch
+implementation, and keeps the built-in provider intact (see [Differences](#differences-from-codexcont)).
+CodexCont's MIT copyright notice is retained in [LICENSE](LICENSE).

codexcomp-0.3.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+codexcomp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+codexcomp/cli.py,sha256=-g4fgzpaiIkVEagcFmCIOyxhZQ0Uju1sS0EcC3mTThE,4317
+codexcomp/fold.py,sha256=yhsqYj8PYxeLcyeO5Nrg9-HYf3gPvaS3SWPb6OC9va4,14475
+codexcomp/server.py,sha256=TpgoDGjjWve1bpn3UoEhIY2tk9vC8JawIoKM4TvjKSs,9105
+codexcomp/service.py,sha256=lLxdlmOoejGJDfpg7xoPex_okfnAIGw0sfYdAxNPprY,8500
+codexcomp-0.3.0.dist-info/METADATA,sha256=n7V-xkCmqcBng1_AMMstAyWp5kyWzX_0G68b8LA18UY,12259
+codexcomp-0.3.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+codexcomp-0.3.0.dist-info/entry_points.txt,sha256=HT7pEwUVjp7ijkwsmI9qWHJR_v-6m0lOf9kvFFHI-20,96
+codexcomp-0.3.0.dist-info/licenses/LICENSE,sha256=xUs31HROJwQ3ywBsM36wSEgCHZbFGQLJXm0iiR06iJY,1258
+codexcomp-0.3.0.dist-info/RECORD,,

codexcomp-0.3.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

codexcomp-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+codexcomp = codexcomp.cli:main
+
+[gui_scripts]
+codexcompw = codexcomp.cli:main

codexcomp-0.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,27 @@
+MIT License
+
+Copyright (c) 2026 dzshzx
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+Mechanism inspiration: the 518n-2 truncation detection + fold-continuation
+approach originates from neteroster/CodexCont (MIT). This project is an
+independent, from-scratch implementation.