claudex-export 0.1.0__py3-none-any.whl

claudex_export-0.1.0.dist-info/METADATA

@@ -0,0 +1,223 @@
+Metadata-Version: 2.4
+Name: claudex-export
+Version: 0.1.0
+Summary: Export Codex and Claude Code sessions with a Textual browser and prompt previews
+Author: matplo
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/matplo/claudex-export
+Project-URL: Repository, https://github.com/matplo/claudex-export
+Project-URL: Issues, https://github.com/matplo/claudex-export/issues
+Project-URL: Changelog, https://github.com/matplo/claudex-export/releases
+Keywords: codex,claude,sessions,markdown,html,textual
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: markdown-it-py<5,>=3
+Requires-Dist: Pygments<3,>=2.17
+Requires-Dist: textual<7,>=6.12
+Provides-Extra: dev
+Requires-Dist: pytest<10,>=8; extra == "dev"
+Dynamic: license-file
+
+# Claudex Export
+
+Export local Codex and Claude Code conversations to readable **standalone HTML**
+or **Markdown**. Run `claudex-export`
+without a filename to browse both providers in a full-screen Textual picker.
+Preview the first and last 10 user prompts before choosing a session.
+
+Requires Python 3.10 or later. No API key or service is needed.
+
+## Install
+
+```bash
+python -m pip install claudex-export
+```
+
+Or install it as an isolated command-line application with
+`pipx install claudex-export`. The commands `claudex-export`, `claude-export`,
+`codex-export`, and the compatibility alias `session-export` launch the same
+tool and support both providers. Python and its dependencies are sufficient; `henv` is
+only used for development in this repository.
+
+## Usage
+
+```bash
+# Browse and search local sessions; HTML is the default
+claudex-export
+
+# Browse only Claude Code sessions
+claudex-export --source claude
+
+# Auto-detect a Claude Code file and export both formats
+claudex-export /path/to/claude-session.jsonl --format both -o exports
+
+# Export a specified rollout
+claudex-export /path/to/rollout.jsonl -o conversation.html
+
+# Markdown, without tool calls/results
+claudex-export /path/to/rollout.jsonl --format md --no-tools -o conversation.md
+
+# Both formats, into a directory
+claudex-export /path/to/rollout.jsonl --format both -o exports
+
+# Include archived sessions, or use another Codex home
+claudex-export --include-archived
+claudex-export --codex-home /path/to/.codex
+```
+
+The Textual picker supports arrow keys, Page Up/Down, and mouse navigation.
+Press `/` to focus live search; search matches titles, directories, IDs, and
+provider names. Enter in the search box returns focus to the results.
+
+| Key | Action |
+| --- | --- |
+| `↑` / `↓` | Move between sessions |
+| `Enter` on a session | Select and export |
+| `v` | Preview the selected session's user prompts |
+| `Esc` / `v` in preview | Return to the list |
+| `e` in preview | Select and export the previewed session |
+| `/` | Focus search |
+| `Esc` in list | Clear search and focus the list |
+| `q` / `Ctrl+C` | Cancel |
+
+Previews are scrollable and loaded in a background worker. They show complete
+prompt text with original numbering and timestamps: the first 10 and last 10,
+without duplicates where those ranges overlap. For longer sessions a marker
+shows how many middle prompts were omitted. Tool results, injected context, and
+compaction summaries are excluded from the prompt preview. Images are counted,
+not opened. Reading a preview does not write an export.
+
+Use `--plain-picker` for the original numbered terminal picker (`/search`,
+`n`/`p`, number to select, `q` to cancel); prompt previews require the Textual
+picker. Without an interactive terminal, supply an explicit input file.
+
+By default, exports are written to the current directory with a sanitized title
+and session ID in the filename. `-o` is a file path for a single format and a
+directory for `--format both`. Parent directories are created as needed.
+Existing files require `--force`; the source session is never overwritten.
+
+## Supported content
+
+- Native Codex rollout and Claude Code `.jsonl` files, containing one JSON
+  record per line. File content determines the format automatically; use
+  `--source codex` or `--source claude` to specify it explicitly.
+- `.json` containing a single native session record or an array of records.
+  Codex records use `type`/`payload`; Claude Code uses `type`/`message` and
+  session metadata. Arbitrary chat JSON formats are not supported.
+- User messages, assistant progress and final replies, tool inputs/results,
+  and markers for compaction/interruption, in recorded order.
+- Native transcript records take priority over matching completion events.
+  Duplicates are matched by IDs and by content within each turn, one occurrence
+  at a time. Separate repeated messages remain present.
+- System/developer messages, reasoning, usage records, and replacement history
+  from compaction are omitted. Instructions stored as actual **user** messages
+  remain part of the transcript.
+- Tools invoked inside an orchestration tool may appear as separate execution
+  events as well as in that tool's output: these describe nested operations.
+- Claude Code tool-use blocks pair with tool results by tool-use ID. Replayed
+  UUIDs are deduplicated while separate blocks sharing a message ID survive.
+  Thinking blocks, metadata, and compacted summaries are omitted. End-of-turn
+  replies use the light blue final-answer styling.
+
+HTML includes responsive styling, highlighted code, tables, links, message
+anchors, collapsed tool details, expand/collapse buttons, and a print button.
+It uses embedded CSS/JavaScript and works offline. Printing expands tool details.
+Markdown keeps conversation formatting and uses fenced blocks for tool data.
+
+Embedded PNG, JPEG, GIF, and WebP data images are preserved. Other image
+references become placeholders; the exporter does not fetch remote images or
+read image paths from the transcript. Raw HTML is escaped in conversation prose;
+HTML exports restrict scripts and resource loads with a Content Security Policy.
+
+Codex discovery respects `--codex-home`, then `CODEX_HOME`, then `~/.codex`.
+It scans `sessions/` (and optionally `archived_sessions/`) and uses
+`session_index.jsonl` titles when available. Sessions are sorted by recent
+activity. Each export covers one file; child/subagent sessions are not recursively
+included. Claude Code discovery respects `--claude-home`, then
+`CLAUDE_CONFIG_DIR`, then `~/.claude`, and reads main session files under
+`projects/`. Custom or automatic session titles take priority over the first
+prompt. Subagent logs are excluded from discovery; pass a subagent file explicitly
+to export it. `--source all` (the default) combines both providers; archived
+session inclusion applies to Codex. Source files and databases are never modified.
+
+Unknown record types and malformed JSONL lines produce warnings. An incomplete
+final line in a running session is skipped; rerun the export later to include it.
+Local session formats can evolve, so inspect export notes when a newer record type
+appears. Exports contain the selected conversation and tool data as stored;
+there is no automatic secret redaction.
+
+## Development
+
+```bash
+henv -n export_codex_session_dev -x python -m pip install -e '.[dev]'
+henv -n export_codex_session_dev -x python -m pytest
+```
+
+Tests use synthetic sessions, including headless Textual keyboard/preview tests.
+Keep private session files and generated exports
+out of source control; `exports/` is ignored for local previews.
+
+## Releases to PyPI
+
+Pushing a version tag triggers `.github/workflows/release.yml`. It runs tests
+on Python 3.10–3.14, builds an sdist and wheel, checks package metadata, and
+smoke-tests an installation of the built wheel. The tag must exactly match
+`v` followed by the package version. Only then does it publish to PyPI and
+create a GitHub release with both distribution files attached.
+
+### One-time PyPI setup
+
+In your PyPI account, open [Publishing](https://pypi.org/manage/account/publishing/)
+and add a **pending GitHub publisher** with these exact values:
+
+| Field | Value |
+| --- | --- |
+| PyPI project name | `claudex-export` |
+| GitHub owner | `matplo` |
+| Repository | `claudex-export` |
+| Workflow filename | `release.yml` |
+| Environment name | `pypi` |
+
+If the PyPI project already exists in your account, add the same publisher
+under that project's Publishing settings. The GitHub workflow uses OIDC
+Trusted Publishing; no `PYPI_API_TOKEN` secret is needed. The GitHub environment
+`pypi` must not require reviewer approval if you want fully automatic releases.
+The PyPI project is created by the first successful publish, not by registering
+the pending publisher.
+
+### Publish a version
+
+Set `__version__` in `src/codex_export/__init__.py` (the single version source),
+commit the change, and push a matching tag. For the initial `0.1.0` release:
+
+```bash
+henv -n export_codex_session_dev -x git push origin main
+henv -n export_codex_session_dev -x git tag -a v0.1.0 -m 'Release 0.1.0'
+henv -n export_codex_session_dev -x git push origin v0.1.0
+```
+
+For later releases, change the version and tag together. Prereleases such as
+`0.2.0rc1` use `v0.2.0rc1`. PyPI versions are immutable: publish a new version
+for changed artifacts. If publishing fails before upload, fix the configuration
+and rerun the failed workflow jobs. If only GitHub release creation fails after
+PyPI succeeds, rerun that failed job rather than publishing again.
+
+See [PyPI's Trusted Publishing documentation](https://docs.pypi.org/trusted-publishers/)
+for account setup details. Ordinary pushes to `main` and pull requests run the
+same tests and packaging checks without publishing.
+
+## License
+
+MIT; see [LICENSE](LICENSE).

claudex_export-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+claudex_export-0.1.0.dist-info/licenses/LICENSE,sha256=FdvapQASUK3J-7zKooV8mCVgxSTQvLoNS4JV7YAiDvw,1063
+codex_export/__init__.py,sha256=9R4bR64UPYgLlZHQL12l1leIMILZWmL6haZegVRD2Ys,90
+codex_export/__main__.py,sha256=k1ocEWawweo1qCJWNFAAvyxz3tcY13dzvCenHszij30,48
+codex_export/claude.py,sha256=f-hAdOYkBtfLzuTWy3pYoB_U32INEWY4NHMxVXVQETM,6412
+codex_export/cli.py,sha256=y9yb7K4ebDoyUzMNXkV65DQmLFVHXMJpDXi8UOyUjLs,6372
+codex_export/controls.js,sha256=3dGmFcrBSAKakF3XDCDsJtas7aVUKPjJTd2M5KvAg_E,807
+codex_export/discovery.py,sha256=8xSNHGpyxoW7sm4dEhuQTZzRw398V-QPU7vB2OYZXVI,8430
+codex_export/render.py,sha256=Rc_PNjHYCLjgUtVnri-OIXQ3uMURAlKmN9UmIiNkWX4,12298
+codex_export/session.py,sha256=mTkASj_jBBMH1PTh0WHLhJDhoPvgzQt89ThcQdmFTww,15291
+codex_export/style.css,sha256=bl4-sZWUM6CAy6n6TttQAoLoMXlbRt3hwKaw4rAeQ2M,4801
+codex_export/tui.py,sha256=vSJUuY9jkGyeS5_VStr7PHsfW7pIJ0xsEWEbIfwnDE8,7354
+claudex_export-0.1.0.dist-info/METADATA,sha256=di_1tadtP8XdrMLpmfHRttpnYX6g2wNlLoHyXrPcjgI,10129
+claudex_export-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+claudex_export-0.1.0.dist-info/entry_points.txt,sha256=pPngFgo6bEoAO8St2fYq-TeQ0s00v70NHpdKthqXzk0,171
+claudex_export-0.1.0.dist-info/top_level.txt,sha256=AzRVAIGQm38psLpvQo2ekzQVOldgc0PHjtIvU943xYA,13
+claudex_export-0.1.0.dist-info/RECORD,,

claudex_export-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

claudex_export-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+claude-export = codex_export.cli:main
+claudex-export = codex_export.cli:main
+codex-export = codex_export.cli:main
+session-export = codex_export.cli:main

claudex_export-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 matplo
+
+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.

claudex_export-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+codex_export

codex_export/__init__.py

@@ -0,0 +1,3 @@
+"""Claudex Export: local Codex and Claude Code session exports."""
+
+__version__ = "0.1.0"

codex_export/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

codex_export/claude.py

@@ -0,0 +1,125 @@
+"""Normalize Claude Code's local JSONL records into the shared transcript."""
+
+from collections import Counter
+from pathlib import Path
+
+from .session import Entry, Session, SessionError, fallback_title, iter_records, pretty
+
+
+def parts(content) -> tuple[str, list[str]]:
+    if isinstance(content, str):
+        return content, []
+    text, images = [], []
+    for block in content if isinstance(content, list) else []:
+        if not isinstance(block, dict):
+            continue
+        kind = block.get("type")
+        if kind == "text":
+            text.append(str(block.get("text", "")))
+        elif kind == "image":
+            source = block.get("source", {})
+            if isinstance(source, dict):
+                images.append(f"data:{source.get('media_type', '')};base64,{source.get('data', '')}" if source.get("type") == "base64" else str(source.get("url", "")))
+        elif kind not in {"thinking", "redacted_thinking", "tool_use", "tool_result"}:
+            text.append(f"[Unsupported content: {kind or 'unknown'}]")
+    return "\n\n".join(text), images
+
+
+def read_claude_session(path: Path) -> Session:
+    session = Session(source=path, id=path.stem, provider="claude")
+    seen, calls, results = set(), {}, {}
+    ignored = Counter()
+    metadata = {"attachment", "file-history-snapshot", "file-history-delta", "queue-operation", "mode", "permission-mode", "bridge-session", "agent-name", "last-prompt", "atis-latch", "pr-link", "cost-state", "progress"}
+    count, custom_title = 0, ""
+    for position, record in enumerate(iter_records(path, session.warnings, require_payload=False)):
+        if "payload" in record:
+            raise SessionError("This file contains Codex records. Omit --source claude to auto-detect its format.")
+        count += 1
+        kind = record.get("type")
+        session.id = str(record.get("sessionId") or session.id)
+        session.cwd = str(record.get("cwd") or session.cwd)
+        timestamp = str(record.get("timestamp") or "")
+        if timestamp and not session.timestamp:
+            session.timestamp = timestamp
+        if kind in {"ai-title", "custom-title", "summary"}:
+            title = record.get("customTitle") or record.get("aiTitle") or record.get("summary")
+            if title:
+                session.title = str(title)
+                if kind == "custom-title":
+                    custom_title = str(title)
+            continue
+        identity = str(record.get("uuid") or "")
+        if identity:
+            if identity in seen:
+                continue
+            seen.add(identity)
+        common = dict(timestamp=timestamp, position=position, id=identity)
+        if kind == "system":
+            if record.get("subtype") == "compact_boundary":
+                session.entries.append(Entry(kind="marker", text="Context compacted", **common))
+            continue
+        if kind == "continued-in":
+            session.entries.append(Entry(kind="marker", text=f"Conversation continued in session {record.get('continuedInSessionId', 'unknown')} (separate export).", **common))
+            continue
+        if kind in metadata:
+            continue
+        if kind not in {"user", "assistant"}:
+            ignored[str(kind)] += 1
+            continue
+        message = record.get("message")
+        if not isinstance(message, dict):
+            session.warnings.append(f"Skipped Claude record {position + 1}: message must be an object.")
+            continue
+        if record.get("isMeta") or record.get("isCompactSummary"):
+            continue
+        content = message.get("content", [])
+        blocks = content if isinstance(content, list) else [{"type": "text", "text": str(content)}]
+        # A Claude message ID may span multiple records/blocks. Only record UUIDs
+        # identify replayed records; deduplicating message IDs loses content.
+        phase = "final_answer" if message.get("stop_reason") in {"end_turn", "stop_sequence"} else "commentary"
+        for block in blocks:
+            if not isinstance(block, dict):
+                continue
+            block_type = block.get("type")
+            if block_type in {"thinking", "redacted_thinking"}:
+                continue
+            if block_type == "tool_use":
+                call_id = str(block.get("id") or "")
+                entry = Entry(kind="tool", name=str(block.get("name") or "Tool"), text=pretty(block.get("input", {})), call_id=call_id, **common)
+                if call_id and call_id in calls:
+                    continue
+                if call_id:
+                    calls[call_id] = entry
+                session.entries.append(entry)
+            elif block_type == "tool_result":
+                text, images = parts(block.get("content", ""))
+                if block.get("is_error"):
+                    text = "Tool error\n" + text
+                entry = Entry(kind="tool", name="Unmatched tool result", result=text, images=images, call_id=str(block.get("tool_use_id") or ""), **common)
+                if entry.call_id:
+                    results[entry.call_id] = entry
+                else:
+                    session.entries.append(entry)
+            else:
+                text, images = parts([block])
+                if text or images:
+                    # Adjacent content blocks in the same record form one message.
+                    previous = session.entries[-1] if session.entries else None
+                    if previous and previous.kind == kind and previous.position == position:
+                        previous.text = "\n\n".join(filter(None, (previous.text, text)))
+                        previous.images.extend(images)
+                    else:
+                        session.entries.append(Entry(kind=kind, text=text, images=images, phase=phase if kind == "assistant" else "", **common))
+    if not count:
+        raise SessionError("No valid Claude Code session records found.")
+    for call_id, result in results.items():
+        if call_id in calls:
+            calls[call_id].result = result.result
+            calls[call_id].images.extend(result.images)
+        else:
+            session.entries.append(result)
+    session.entries.sort(key=lambda e: e.position)
+    session.title = custom_title or session.title or fallback_title(session)
+    for kind, number in sorted(ignored.items()):
+        session.warnings.append(f"Skipped {number} unsupported Claude {kind} record(s).")
+    return session

codex_export/cli.py

@@ -0,0 +1,118 @@
+"""Command-line interface for Claudex Export and its aliases."""
+
+from __future__ import annotations
+
+import argparse
+import os
+from pathlib import Path
+import re
+import sys
+import tempfile
+import unicodedata
+
+from . import __version__
+from .discovery import claude_home, codex_home, discover_all, pick, read_index, terminal_text
+from .render import render_html, render_markdown
+from .session import Session, SessionError, read_session
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(description="Export a local Codex or Claude Code session to offline HTML or Markdown. Omit SESSION_FILE to browse local sessions.")
+    result.add_argument("session_file", nargs="?", type=Path, metavar="SESSION_FILE")
+    result.add_argument("--format", choices=("html", "md", "both"), default="html", help="output format (default: html)")
+    result.add_argument("-o", "--output", type=Path, help="output file; for --format both, an output directory")
+    result.add_argument("--no-tools", action="store_true", help="omit tool calls and results")
+    result.add_argument("--codex-home", type=Path, metavar="DIRECTORY", help="override CODEX_HOME (default: ~/.codex)")
+    result.add_argument("--claude-home", type=Path, metavar="DIRECTORY", help="override CLAUDE_CONFIG_DIR (default: ~/.claude)")
+    result.add_argument("--source", choices=("all", "codex", "claude"), default="all", help="filter picker or specify input format (default: all / auto-detect)")
+    result.add_argument("--plain-picker", action="store_true", help="use the original numbered picker instead of Textual")
+    result.add_argument("--include-archived", action="store_true", help="include archived sessions in the picker")
+    result.add_argument("--force", action="store_true", help="replace existing output files")
+    result.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    return result
+
+
+def slug(text: str, limit: int) -> str:
+    text = unicodedata.normalize("NFKD", text).encode("ascii", "ignore").decode().lower()
+    return re.sub(r"[^a-z0-9]+", "-", text).strip("-")[:limit].rstrip("-") or "session"
+
+
+def destinations(session: Session, format: str, output: Path | None) -> list[tuple[Path, str]]:
+    name = f"{slug(session.title, 70)}-{slug(session.id, 80)}"
+    formats = ("html", "md") if format == "both" else (format,)
+    if output and format != "both":
+        return [(output.expanduser(), format)]
+    directory = output.expanduser() if output else Path.cwd()
+    if directory.exists() and not directory.is_dir():
+        raise SessionError(f"Expected an output directory: {directory}")
+    return [(directory / f"{name}.{extension}", extension) for extension in formats]
+
+
+def write_exports(session: Session, targets: list[tuple[Path, str]], include_tools: bool, force: bool) -> list[Path]:
+    # Check every destination before writing either format.
+    for path, _ in targets:
+        if path.resolve() == session.source.resolve() or (path.exists() and os.path.samefile(path, session.source)):
+            raise SessionError("Output cannot replace the source session, even with --force.")
+        if path.is_symlink():
+            raise SessionError(f"Refusing to replace a symbolic link: {path}")
+        if path.exists() and (not force or not path.is_file()):
+            raise SessionError(f"Output already exists: {path}. Use --force to replace a file.")
+    rendered = [(path, render_html(session, include_tools) if format == "html" else render_markdown(session, include_tools)) for path, format in targets]
+    written = []
+    for path, content in rendered:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        # Stage on the destination filesystem. Link provides exclusive creation
+        # without a check/write race; replace handles explicit overwrites.
+        descriptor, temporary = tempfile.mkstemp(prefix=".codex-export-", dir=path.parent)
+        try:
+            with os.fdopen(descriptor, "w", encoding="utf-8", newline="\n") as stream:
+                stream.write(content)
+            if force:
+                os.replace(temporary, path)
+            else:
+                os.link(temporary, path)
+            written.append(path.resolve())
+        finally:
+            Path(temporary).unlink(missing_ok=True)
+    return written
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parser().parse_args(argv)
+    home = codex_home(args.codex_home)
+    try:
+        selected = None
+        source = args.session_file
+        if source is None:
+            if not sys.stdin.isatty() or not sys.stdout.isatty():
+                raise SessionError("No session file supplied. In a noninteractive terminal, pass a .jsonl or .json path: claudex-export SESSION_FILE")
+            candidates, warnings = discover_all(home, claude_home(args.claude_home), args.source, args.include_archived)
+            for warning in warnings:
+                print(f"Warning: {terminal_text(warning)}", file=sys.stderr)
+            if not candidates:
+                raise SessionError("No local sessions found. Supply a session file or use --codex-home / --claude-home.")
+            if args.plain_picker:
+                selected = pick(candidates)
+            else:
+                from .tui import pick_tui
+                selected = pick_tui(candidates)
+            if selected is None:
+                print("Cancelled; no export written.")
+                return 0
+            source = selected.path
+        session = read_session(source.expanduser(), "auto" if args.source == "all" else args.source)
+        indexed = read_index(home).get(session.id, {}).get("thread_name") if session.provider == "codex" else None
+        session.title = str(indexed or (selected.title if selected else session.title))
+        targets = destinations(session, args.format, args.output)
+        paths = write_exports(session, targets, not args.no_tools, args.force)
+        for warning in session.warnings:
+            print(f"Warning: {terminal_text(warning)}", file=sys.stderr)
+        for path in paths:
+            print(f"Exported: {terminal_text(str(path))}")
+        return 0
+    except KeyboardInterrupt:
+        print("\nCancelled.", file=sys.stderr)
+        return 130
+    except (OSError, UnicodeError, SessionError) as exc:
+        print(f"Error: {terminal_text(str(exc))}", file=sys.stderr)
+        return 1

codex_export/controls.js

@@ -0,0 +1,15 @@
+document.getElementById('expand')?.addEventListener('click', () => {
+  document.querySelectorAll('details.tool').forEach(item => { item.open = true; });
+});
+document.getElementById('collapse')?.addEventListener('click', () => {
+  document.querySelectorAll('details.tool').forEach(item => { item.open = false; });
+});
+document.getElementById('print')?.addEventListener('click', () => { window.print(); });
+let previouslyOpen = [];
+window.addEventListener('beforeprint', () => {
+  previouslyOpen = [...document.querySelectorAll('details.tool')].map(item => item.open);
+  document.querySelectorAll('details.tool').forEach(item => { item.open = true; });
+});
+window.addEventListener('afterprint', () => {
+  document.querySelectorAll('details.tool').forEach((item, i) => { item.open = previouslyOpen[i]; });
+});