claudexer 0.4.0__py3-none-any.whl

claudexer/__init__.py

@@ -0,0 +1,3 @@
+"""Claudexer: browse, resume, and export local Codex and Claude Code sessions."""
+
+__version__ = "0.4.0"

claudexer/__main__.py

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

claudexer/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

claudexer/cli.py

@@ -0,0 +1,155 @@
+"""Command-line interface for Claudexer."""
+
+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
+from .privacy import prepare_export
+
+
+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("--full", action="store_true", help="include identifying metadata, original messages, tools, and images (default: sanitized conversation)")
+    result.add_argument("--redact", action="append", default=[], metavar="TEXT", help="also redact this name or literal text in sanitized mode; repeatable")
+    result.add_argument("--no-tools", action="store_true", help="omit tool calls and results even with --full")
+    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, *, full: bool = False, redact=()) -> list[tuple[Path, str]]:
+    public = prepare_export(session, full=full, redact=redact)
+    name = f"{slug(public.title, 70)}-{slug(public.id, 80)}" if full else (f"{public.timestamp}-" if public.timestamp else "") + slug(public.title, 70)
+    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 export_selection(candidate, home: Path, format: str, output: Path | None, no_tools: bool, force: bool, *, full: bool = False, redact=()) -> tuple[list[Path], list[str]]:
+    """Export a picker-discovered candidate. Its provider is already known, so
+    unlike the explicit-SESSION_FILE path there is no format to auto-detect."""
+    session = read_session(candidate.path.expanduser(), candidate.provider)
+    indexed = read_index(home).get(session.id, {}).get("thread_name") if session.provider == "codex" else None
+    session.title = str(indexed or candidate.title)
+    targets = destinations(session, format, output, full=full, redact=redact)
+    paths = write_exports(session, targets, not no_tools, force, full=full, redact=redact)
+    return paths, session.warnings
+
+
+def write_exports(session: Session, targets: list[tuple[Path, str]], include_tools: bool, force: bool, *, full: bool = False, redact=()) -> 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, full=full, redact=redact) if format == "html" else render_markdown(session, include_tools, full=full, redact=redact)) 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=".claudexer-", 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 resume_command(candidate) -> list[str]:
+    if candidate.provider == "claude":
+        return ["claude", "--resume", candidate.id]
+    return ["codex", "resume", candidate.id]
+
+
+def resume_session(candidate) -> None:
+    """Replace this process with the provider CLI resuming the given session.
+    Never returns on success; a missing binary or bad cwd raises OSError,
+    which the caller's existing error handling already reports."""
+    if candidate.cwd and os.path.isdir(candidate.cwd):
+        os.chdir(candidate.cwd)
+    argv = resume_command(candidate)
+    os.execvp(argv[0], argv)
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parser().parse_args(argv)
+    home = codex_home(args.codex_home)
+    try:
+        source = args.session_file
+        if source is not None:
+            session = read_session(source.expanduser(), "auto" if args.source == "all" else args.source)
+            targets = destinations(session, args.format, args.output, full=args.full, redact=args.redact)
+            paths = write_exports(session, targets, not args.no_tools, args.force, full=args.full, redact=args.redact)
+            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
+        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: claudexer 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)
+            if selected is None:
+                print("Cancelled; no export written.")
+                return 0
+            paths, session_warnings = export_selection(selected, home, args.format, args.output, args.no_tools, args.force, full=args.full, redact=args.redact)
+            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
+        from .tui import pick_tui
+        selected, args.full = pick_tui(candidates, full=args.full, redact=args.redact, home=home, format=args.format, output=args.output, no_tools=args.no_tools, force=args.force)
+        if selected is None:
+            print("Cancelled.")
+            return 0
+        resume_session(selected)
+        return 0  # pragma: no cover - unreachable once execvp succeeds
+    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

claudexer/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]; });
+});

claudexer/discovery.py

@@ -0,0 +1,179 @@
+"""Read session metadata and provide a dependency-free terminal picker."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+import json
+import os
+from pathlib import Path
+import re
+import sys
+from typing import TextIO
+
+from .session import content_parts
+
+
+@dataclass
+class Candidate:
+    path: Path
+    id: str
+    title: str
+    cwd: str
+    updated: float
+    archived: bool = False
+    provider: str = "codex"
+
+
+def codex_home(override: Path | None = None) -> Path:
+    return (override or Path(os.environ.get("CODEX_HOME") or Path.home() / ".codex")).expanduser()
+
+
+def read_index(home: Path) -> dict[str, dict]:
+    index = {}
+    try:
+        with (home / "session_index.jsonl").open(encoding="utf-8") as stream:
+            for line in stream:
+                try:
+                    item = json.loads(line)
+                    if isinstance(item, dict) and item.get("id"):
+                        index[str(item["id"])] = item
+                except ValueError:
+                    continue
+    except OSError:
+        pass
+    return index
+
+
+def discover(home: Path, include_archived: bool = False) -> tuple[list[Candidate], list[str]]:
+    index, found, warnings = read_index(home), [], []
+    roots = [(home / "sessions", False)]
+    if include_archived:
+        roots.append((home / "archived_sessions", True))
+    for root, archived in roots:
+        for path in root.rglob("*.jsonl"):
+            try:
+                identity, cwd, title = path.stem, "", ""
+                # Metadata and the first prompt normally occur near the start.
+                # Bound discovery work; full parsing happens after selection.
+                with path.open(encoding="utf-8-sig") as stream:
+                    for number, line in enumerate(stream):
+                        if number >= 200:
+                            break
+                        try:
+                            record = json.loads(line)
+                        except ValueError:
+                            continue
+                        if not isinstance(record, dict):
+                            continue
+                        p = record.get("payload", {})
+                        if not isinstance(p, dict):
+                            continue
+                        if record.get("type") == "session_meta":
+                            identity = str(p.get("id") or p.get("session_id") or identity)
+                            cwd = str(p.get("cwd") or "")
+                            title = str(p.get("thread_name") or p.get("title") or "")
+                        if record.get("type") == "response_item" and p.get("role") == "user":
+                            text, _ = content_parts(p.get("content", []))
+                            if text and not text.lstrip().startswith(("# AGENTS.md instructions", "<environment_context>", "<INSTRUCTIONS>")):
+                                title = title or " ".join(text.split())[:100]
+                                break
+                item = index.get(identity, {})
+                title = str(item.get("thread_name") or title or identity)
+                updated = path.stat().st_mtime
+                try:
+                    updated = max(updated, datetime.fromisoformat(item["updated_at"].replace("Z", "+00:00")).timestamp())
+                except (KeyError, ValueError, TypeError, AttributeError):
+                    pass
+                found.append(Candidate(path, identity, title, cwd, updated, archived))
+            except (OSError, UnicodeError) as exc:
+                warnings.append(f"Could not inspect {path.name}: {exc}")
+    found.sort(key=lambda c: (c.updated, str(c.path)), reverse=True)
+    # Prefer the most recently updated copy if a rollout was moved/duplicated.
+    unique = {}
+    for candidate in found:
+        unique.setdefault(candidate.id, candidate)
+    return list(unique.values()), warnings
+
+
+def terminal_text(text: str) -> str:
+    # Session titles are untrusted text; strip terminal control sequences.
+    text = re.sub(r"\x1b\[[0-?]*[ -/]*[@-~]", "", text)
+    return " ".join("".join(c for c in text if c.isprintable() or c.isspace()).split())
+
+
+def claude_home(override: Path | None = None) -> Path:
+    return (override or Path(os.environ.get("CLAUDE_CONFIG_DIR") or Path.home() / ".claude")).expanduser()
+
+
+def discover_claude(home: Path) -> tuple[list[Candidate], list[str]]:
+    from .claude import parts
+    from .session import iter_records
+
+    found, warnings = [], []
+    # Nested subagent logs and legacy agent-*.jsonl files are separate sessions.
+    for path in (home / "projects").glob("*/*.jsonl"):
+        if path.name.startswith("agent-"):
+            continue
+        try:
+            identity, cwd, title, custom, prompt = path.stem, "", "", "", ""
+            for record in iter_records(path, [], require_payload=False):
+                identity = str(record.get("sessionId") or identity)
+                cwd = str(record.get("cwd") or cwd)
+                kind = record.get("type")
+                if kind in {"ai-title", "summary"}:
+                    title = str(record.get("aiTitle") or record.get("summary") or title)
+                elif kind == "custom-title":
+                    custom = str(record.get("customTitle") or custom)
+                elif kind == "user" and not prompt and not record.get("isMeta") and not record.get("isCompactSummary"):
+                    message = record.get("message", {})
+                    if isinstance(message, dict):
+                        text, _ = parts(message.get("content", []))
+                        if not text.lstrip().startswith(("<local-command-caveat>", "<local-command-stdout>", "[Request interrupted")):
+                            prompt = " ".join(text.split())[:100]
+            found.append(Candidate(path, identity, custom or title or prompt or identity, cwd, path.stat().st_mtime, provider="claude"))
+        except (OSError, UnicodeError, ValueError) as exc:
+            warnings.append(f"Could not inspect {path.name}: {exc}")
+    return sorted(found, key=lambda c: c.updated, reverse=True), warnings
+
+
+def discover_all(codex: Path, claude: Path, source: str = "all", include_archived: bool = False) -> tuple[list[Candidate], list[str]]:
+    candidates, warnings = [], []
+    if source in {"all", "codex"}:
+        found, notes = discover(codex, include_archived)
+        candidates.extend(found)
+        warnings.extend(notes)
+    if source in {"all", "claude"}:
+        found, notes = discover_claude(claude)
+        candidates.extend(found)
+        warnings.extend(notes)
+    return sorted(candidates, key=lambda c: c.updated, reverse=True), warnings
+
+
+def pick(candidates: list[Candidate], stdin: TextIO | None = None, stdout: TextIO | None = None, page_size: int = 10) -> Candidate | None:
+    stdin, stdout = stdin or sys.stdin, stdout or sys.stdout
+    query, page = "", 0
+    while True:
+        matches = [c for c in candidates if query.casefold() in f"{c.title} {c.cwd} {c.id}".casefold()]
+        pages = max(1, (len(matches) + page_size - 1) // page_size)
+        page = min(page, pages - 1)
+        print(f"\nSessions · {len(matches)} match(es) · page {page + 1}/{pages}", file=stdout)
+        for i, candidate in enumerate(matches[page * page_size:(page + 1) * page_size], page * page_size + 1):
+            date = datetime.fromtimestamp(candidate.updated).strftime("%Y-%m-%d %H:%M")
+            archive = " · archived" if candidate.archived else ""
+            print(f" {i:>3}. [{candidate.provider}] {terminal_text(candidate.title)[:90]}{archive}\n      {date} · {terminal_text(candidate.cwd) or 'unknown directory'} · {terminal_text(candidate.id)[:8]}", file=stdout)
+        print("Number to export · /text to search · / to clear · n/p pages · q to cancel\n> ", end="", file=stdout, flush=True)
+        answer = stdin.readline()
+        if not answer or answer.strip().lower() in {"q", "quit"}:
+            return None
+        answer = answer.strip()
+        if answer.startswith("/"):
+            query, page = answer[1:], 0
+        elif answer.lower() == "n":
+            page = min(page + 1, pages - 1)
+        elif answer.lower() == "p":
+            page = max(0, page - 1)
+        elif answer.isdigit() and 1 <= int(answer) <= len(matches):
+            return matches[int(answer) - 1]
+        else:
+            print("Enter a listed number, /search, n, p, or q.", file=stdout)

claudexer/privacy.py

@@ -0,0 +1,136 @@
+"""Deterministic, local redaction for conversation-only exports.
+
+This is best-effort identifier removal, not semantic anonymization of prose.
+"""
+
+from dataclasses import replace
+from datetime import datetime, timezone
+import getpass
+import html
+import ipaddress
+from pathlib import Path
+import re
+import socket
+from urllib.parse import unquote
+
+from .session import Session, iter_records, user_prompts
+
+
+HOME_USER = re.compile(r"(?:/(?:Users|home)/|[A-Za-z]:[\\/]+Users[\\/]+)([^\\/\s\"'`<>]+)", re.I)
+IDENTITY_KEYS = {"username", "user_name", "hostname", "host_name", "computer_name", "email", "user_email", "full_name", "home", "home_dir", "cwd"}
+
+
+def timestamp(value):
+    try:
+        parsed = datetime.fromisoformat(str(value).replace("Z", "+00:00"))
+        return parsed.replace(tzinfo=timezone.utc) if parsed.tzinfo is None else parsed
+    except (TypeError, ValueError):
+        return None
+
+
+def collect_metadata(session: Session) -> None:
+    """Read only structured identifiers and timestamp bounds; retain no raw log."""
+    moments = []
+    values = set()
+
+    def visit(value):
+        if isinstance(value, dict):
+            for key, item in value.items():
+                if key.lower() in IDENTITY_KEYS and isinstance(item, str) and item:
+                    values.add(item)
+                elif isinstance(item, (dict, list)):
+                    visit(item)
+        elif isinstance(value, list):
+            for item in value:
+                if isinstance(item, (dict, list)):
+                    visit(item)
+
+    for record in iter_records(session.source, [], require_payload=False):
+        visit(record)
+        if moment := timestamp(record.get("timestamp")):
+            moments.append(moment)
+    if started := timestamp(session.timestamp):
+        moments.append(started)
+    if moments:
+        if not session.timestamp:
+            session.timestamp = min(moments).isoformat()
+        if len(set(moments)) > 1:
+            session.duration_seconds = (max(moments) - min(moments)).total_seconds()
+    session.identifiers = sorted(values)
+
+
+def duration_text(seconds: float | None) -> str:
+    if seconds is None:
+        return ""
+    minutes, seconds = divmod(max(0, int(seconds)), 60)
+    hours, minutes = divmod(minutes, 60)
+    return (f"{hours}h " if hours else "") + (f"{minutes}m " if minutes or hours else "") + f"{seconds}s"
+
+
+class Redactor:
+    def __init__(self, session: Session, extra=()):
+        values = {session.id, str(session.source), session.cwd, *session.identifiers}
+        # Infer usernames from imported session paths as well as the local host.
+        for text in [session.title, *values, *(e.text for e in session.entries)]:
+            values.update(HOME_USER.findall(text))
+        values.update({str(Path.home()), Path.home().name, socket.gethostname()})
+        try:
+            values.add(getpass.getuser())
+            import pwd
+            import os
+            values.add(pwd.getpwuid(os.getuid()).pw_gecos.split(",")[0])
+        except (ImportError, KeyError, OSError):
+            pass
+        common = {"user", "root", "admin", "home", "codex", "claude", "assistant"}
+        self.values = sorted((v for v in values if len(v) >= 3 and v.casefold() not in common), key=len, reverse=True)
+        self.extra = [v for v in extra if v]
+
+    def __call__(self, text: str) -> str:
+        for _ in range(2):
+            text = html.unescape(unquote(text))
+        text = re.sub(r"[\w.+%\-]+@[\w.\-]+", "[identity]", text)
+        for value in self.values:
+            text = re.sub(r"(?<!\w)" + re.escape(value) + r"(?!\w)", "[identity]", text, flags=re.I)
+        for value in self.extra:
+            text = re.sub(re.escape(value), "[redacted]", text, flags=re.I)
+        # Omit all image payloads and destinations, including those in code.
+        text = re.sub(r"data:[^\s<>\"'`]+", "[image omitted]", text, flags=re.I)
+        text = re.sub(r"(?:https?|ftp|ssh|file)://[^\s<>\"'`]+", "[link removed]", text, flags=re.I)
+        text = re.sub(r"[\w.+%\-]+@[\w.\-]+", "[identity]", text)
+        text = re.sub(r"\b[\w-]+\.(?:local|lan|internal)\b", "[host]", text, flags=re.I)
+        text = re.sub(r'''(?P<q>["'`])(?:[A-Za-z]:[\\/]|~[/\\]|/(?!\s)|\\\\)[^\n]*?(?P=q)''', lambda m: m['q'] + '[path]' + m['q'], text)
+        text = re.sub(r'''(?<![\w/<])(?:[A-Za-z]:[\\/]|~[/\\]|\\\\|/(?![/\s]))[^\s<>"'`()\[\]{};,]+''', "[path]", text)
+        text = re.sub(r"\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b", "[id]", text, flags=re.I)
+        text = re.sub(r"\b(?:[0-9a-f]{2}[:-]){5}[0-9a-f]{2}\b", "[device]", text, flags=re.I)
+
+        def ip(match):
+            try:
+                ipaddress.ip_address(match[0])
+                return "[address]"
+            except ValueError:
+                return match[0]
+
+        text = re.sub(r"(?<![\w:])(?:\d{1,3}\.){3}\d{1,3}(?![\w.])|(?<![\w:])[0-9a-fA-F]*:[0-9a-fA-F:]+(?![\w:])", ip, text)
+        text = re.sub(r"(?<!\w)(?:\+\d{1,3}[ .-])?(?:\(\d{3}\)[ .-]?|\d{3}[ .-])\d{3}[ .-]\d{4}\b", "[phone]", text)
+        return text
+
+
+def prepare_export(session: Session, *, full: bool = False, redact=()) -> Session:
+    if full:
+        return session
+    # Resolve link/image syntax before redaction changes its delimiters. The
+    # import is local because renderers also call this export-policy function.
+    from .render import markdown_text
+    scrub = Redactor(session, redact)
+    prompt_ids = {id(e) for e in user_prompts(session)}
+    entries = []
+    for entry in session.entries:
+        if id(entry) not in prompt_ids and not (entry.kind == "assistant" and entry.phase in {"", "commentary", "final", "final_answer"}):
+            continue
+        text = scrub(markdown_text(entry.text, omit_links=True))
+        if entry.images:
+            text += "\n\n[Image omitted]"
+        entries.append(replace(entry, text=text, timestamp="", images=[], id="", call_id="", turn="", name="", result=None))
+    date = timestamp(session.timestamp)
+    title = "Conversation" if session.title in {session.id, session.source.stem} else scrub(markdown_text(session.title, omit_links=True))
+    return replace(session, title=title, id="", cwd="", timestamp=date.date().isoformat() if date else "", entries=entries, warnings=[], identifiers=[])