reasonwork 0.6.0__tar.gz → 0.6.2__tar.gz

{reasonwork-0.6.0/src/reasonwork.egg-info → reasonwork-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reasonwork
-Version: 0.6.0
+Version: 0.6.2
 Summary: Reasonwork CLI: safely contribute Codex, Claude Code, and Cursor trajectories to Reasonwork.
 Author: ReasonworkAI, Inc.
 License-Expression: LicenseRef-Proprietary

{reasonwork-0.6.0 → reasonwork-0.6.2/src/reasonwork.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reasonwork
-Version: 0.6.0
+Version: 0.6.2
 Summary: Reasonwork CLI: safely contribute Codex, Claude Code, and Cursor trajectories to Reasonwork.
 Author: ReasonworkAI, Inc.
 License-Expression: LicenseRef-Proprietary

{reasonwork-0.6.0 → reasonwork-0.6.2}/src/reasonwork_exchange/__init__.py

@@ -1,3 +1,3 @@
 """Public package for the standalone Reasonwork CLI (by ReasonworkAI)."""
 
-__version__ = "0.6.0"
+__version__ = "0.6.2"

{reasonwork-0.6.0 → reasonwork-0.6.2}/src/reasonwork_exchange/analyzer.py

@@ -6,6 +6,7 @@ import hashlib
 import json
 import re
 from collections import Counter
+from collections.abc import Callable
 from dataclasses import asdict, dataclass, field
 from pathlib import Path
 from typing import Any
@@ -35,6 +36,48 @@ def _luhn_valid(candidate: str) -> bool:
         total += digit
     return total % 10 == 0
 
+
+# Dihedral-group tables for the Verhoeff checksum Aadhaar numbers carry.
+_VERHOEFF_D = (
+    (0, 1, 2, 3, 4, 5, 6, 7, 8, 9),
+    (1, 2, 3, 4, 0, 6, 7, 8, 9, 5),
+    (2, 3, 4, 0, 1, 7, 8, 9, 5, 6),
+    (3, 4, 0, 1, 2, 8, 9, 5, 6, 7),
+    (4, 0, 1, 2, 3, 9, 5, 6, 7, 8),
+    (5, 9, 8, 7, 6, 0, 4, 3, 2, 1),
+    (6, 5, 9, 8, 7, 1, 0, 4, 3, 2),
+    (7, 6, 5, 9, 8, 2, 1, 0, 4, 3),
+    (8, 7, 6, 5, 9, 3, 2, 1, 0, 4),
+    (9, 8, 7, 6, 5, 4, 3, 2, 1, 0),
+)
+_VERHOEFF_P = (
+    (0, 1, 2, 3, 4, 5, 6, 7, 8, 9),
+    (1, 5, 7, 6, 2, 8, 3, 0, 9, 4),
+    (5, 8, 0, 3, 7, 9, 6, 1, 4, 2),
+    (8, 9, 1, 6, 0, 4, 3, 5, 2, 7),
+    (9, 4, 5, 3, 1, 2, 6, 8, 7, 0),
+    (4, 2, 8, 6, 5, 7, 3, 9, 0, 1),
+    (2, 7, 9, 3, 8, 0, 6, 4, 1, 5),
+    (7, 0, 4, 6, 9, 1, 3, 2, 5, 8),
+)
+
+
+def _aadhaar_valid(candidate: str) -> bool:
+    """Verhoeff-validate a digit run shaped like an Aadhaar number.
+
+    Any 12-digit run (timestamps, ids, byte counts) matches the pattern, so
+    without the checksum the contiguous form would flood with false
+    positives -- the same reason credit_card goes through _luhn_valid.
+    """
+    digits = re.sub(r"\D", "", candidate)
+    if len(digits) != 12:
+        return False
+    checksum = 0
+    for index, char in enumerate(reversed(digits)):
+        checksum = _VERHOEFF_D[checksum][_VERHOEFF_P[index % 8][int(char)]]
+    return checksum == 0
+
+
 _SECRET_PATTERNS = {
     # Matches the whole PEM block through its matching END marker so the base64 body
     # isn't left in plaintext after redaction; falls back to the header alone if no
@@ -53,6 +96,7 @@ _SECRET_PATTERNS = {
     "stripe_key": re.compile(r"\b(?:sk|rk)_live_[A-Za-z0-9]{20,}\b"),
     "google_api_key": re.compile(r"\bAIza[0-9A-Za-z_-]{35}\b"),
     "npm_token": re.compile(r"\bnpm_[A-Za-z0-9]{36}\b"),
+    "reasonwork_contributor_token": re.compile(r"\bnxc_[A-Za-z0-9_-]{20,}\b"),
     "db_connection_password": re.compile(
         r"\b(?:postgres(?:ql)?|mysql|mongodb(?:\+srv)?|redis|amqp)://[^\s\"'/:@]+:[^\s\"'/@]+@[^\s\"']+",
         re.IGNORECASE,
@@ -172,7 +216,7 @@ _SECRET_PATTERNS = {
     "iban": re.compile(r"\b[A-Z]{2}\d{2}[A-Z0-9]{11,30}\b"),
     "uk_national_insurance_number": re.compile(r"\b[A-CEGHJ-PR-TW-Z]{1}[A-CEGHJ-NPR-TW-Z]{1}\d{6}[A-D]\b"),
     "india_pan": re.compile(r"\b[A-Z]{5}\d{4}[A-Z]\b"),
-    "india_aadhaar": re.compile(r"\b\d{4}\s\d{4}\s\d{4}\b"),
+    "india_aadhaar": re.compile(r"\b[2-9]\d{3}[\s-]?\d{4}[\s-]?\d{4}\b"),
     "us_itin": re.compile(r"\b9\d{2}-\d{2}-\d{4}\b"),
     "passport_mrz_line": re.compile(r"\bP<[A-Z<]{43}\b"),
     "drivers_license_assignment": re.compile(
@@ -294,6 +338,14 @@ _SECRET_PATTERNS = {
     "diners_club_card": re.compile(r"\b3(?:0[0-5]|[68][0-9])[0-9]{11}\b"),
     "jcb_card": re.compile(r"\b(?:2131|1800|35\d{2})\d{12}\b"),
 }
+# Checksum validators applied to a pattern's raw matches before they count as
+# findings (and before redaction). Keeps loose numeric patterns usable.
+_SECRET_VALIDATORS = {
+    "credit_card": _luhn_valid,
+    "diners_club_card": _luhn_valid,
+    "jcb_card": _luhn_valid,
+    "india_aadhaar": _aadhaar_valid,
+}
 _EMAIL_PATTERN = re.compile(r"\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b", re.IGNORECASE)
 _PHONE_PATTERN = re.compile(
     r"\b(?:\+?1[-.\s])?\(?\d{3}\)?[-.\s]\d{3}[-.\s]\d{4}\b"
@@ -410,6 +462,10 @@ def _codex_agent_id(record: dict[str, Any]) -> str | None:
 
 
 _EDIT_TOOL_NAMES = {"Edit", "Write", "NotebookEdit", "MultiEdit", "apply_patch"}
+# Current Codex routes nearly every action through one custom tool, `exec`,
+# whose `input` is a script calling `tools.<name>(...)`; the nested names are
+# the real tool types.
+_CODEX_NESTED_TOOL = re.compile(r"\btools\.([A-Za-z_][A-Za-z0-9_]*)\s*\(")
 
 
 @dataclass
@@ -500,6 +556,12 @@ def analyze(path: Path, discovered_source: str | None = None) -> Analysis:
     error_results = 0
     recovered_errors = 0
     pending_error = False
+    # Current Codex records what actually happened as item_completed events:
+    # FileChange for edits, CommandExecution (status/exit_code) for commands.
+    codex_file_changes = 0
+    codex_failed_commands = 0
+    codex_recovered_commands = 0
+    codex_pending_failure = False
     text_chars = 0
     tool_signatures: Counter[str] = Counter()
     text_messages: Counter[str] = Counter()
@@ -513,8 +575,9 @@ def analyze(path: Path, discovered_source: str | None = None) -> Analysis:
             text = raw.decode("utf-8", errors="replace")
             for name, pattern in _SECRET_PATTERNS.items():
                 matches = pattern.findall(text)
-                if name == "credit_card":
-                    matches = [m for m in matches if _luhn_valid(m)]
+                validator = _SECRET_VALIDATORS.get(name)
+                if validator is not None:
+                    matches = [m for m in matches if validator(m)]
                 secrets[name] += len(matches)
             email_count += len(_EMAIL_PATTERN.findall(text))
             phone_count += len(_PHONE_PATTERN.findall(text))
@@ -567,10 +630,17 @@ def analyze(path: Path, discovered_source: str | None = None) -> Analysis:
                         name = name if isinstance(name, str) else payload_type
                         tool_names.add(name)
                         edit_calls += int(name in _EDIT_TOOL_NAMES)
+                        # function_call carries `arguments`; custom_tool_call
+                        # (e.g. `exec`) carries `input` instead.
+                        call_args = payload.get("arguments")
+                        if call_args is None:
+                            call_args = payload.get("input")
+                        if isinstance(call_args, str):
+                            tool_names.update(_CODEX_NESTED_TOOL.findall(call_args))
                         try:
-                            args_repr = json.dumps(payload.get("arguments"), sort_keys=True, default=str)[:500]
+                            args_repr = json.dumps(call_args, sort_keys=True, default=str)[:500]
                         except (TypeError, ValueError):
-                            args_repr = str(payload.get("arguments"))[:500]
+                            args_repr = str(call_args)[:500]
                         tool_signatures[f"{name}:{args_repr}"] += 1
                         if pending_error:
                             recovered_errors += 1
@@ -585,6 +655,22 @@ def analyze(path: Path, discovered_source: str | None = None) -> Analysis:
                         is_error = isinstance(output, dict) and bool(output.get("error"))
                         error_results += int(is_error)
                         pending_error = pending_error or is_error
+                    if event_type == "event_msg" and payload_type == "item_completed":
+                        item = payload.get("item")
+                        item_type = item.get("type") if isinstance(item, dict) else None
+                        if item_type == "FileChange":
+                            codex_file_changes += 1
+                        elif item_type == "CommandExecution":
+                            exit_code = item.get("exit_code")
+                            failed = item.get("status") == "failed" or (
+                                isinstance(exit_code, int) and exit_code != 0
+                            )
+                            if failed:
+                                codex_failed_commands += 1
+                                codex_pending_failure = True
+                            elif codex_pending_failure:
+                                codex_recovered_commands += 1
+                                codex_pending_failure = False
             elif source == "claude_code":
                 messages += int(event_type in {"user", "assistant"})
                 events = _claude_events(record)
@@ -604,6 +690,14 @@ def analyze(path: Path, discovered_source: str | None = None) -> Analysis:
                     error_results += events.error_results
                     pending_error = True
 
+    if source == "codex":
+        # Older rollouts only have tool names/outputs; current ones also have
+        # the authoritative events. Take whichever saw more, never both.
+        edit_calls = max(edit_calls, codex_file_changes)
+        if codex_failed_commands > error_results:
+            error_results = codex_failed_commands
+            recovered_errors = codex_recovered_commands
+
     secret_total = sum(secrets.values())
     if secret_total:
         privacy_risk = "blocked"
@@ -750,15 +844,20 @@ def redact_trajectory(path: Path) -> RedactionResult:
             line_count += 1
             text = raw.decode("utf-8", errors="replace")
             for name, pattern in _SECRET_PATTERNS.items():
-                if name == "credit_card":
-
-                    def _sub_card(match: re.Match[str]) -> str:
-                        if _luhn_valid(match.group(0)):
-                            categories.add("credit_card")
-                            return "[REDACTED_CREDIT_CARD]"
+                validator = _SECRET_VALIDATORS.get(name)
+                if validator is not None:
+
+                    def _sub_validated(
+                        match: re.Match[str],
+                        _name: str = name,
+                        _valid: Callable[[str], bool] = validator,
+                    ) -> str:
+                        if _valid(match.group(0)):
+                            categories.add(_name)
+                            return f"[REDACTED_{_name.upper()}]"
                         return match.group(0)
 
-                    text = pattern.sub(_sub_card, text)
+                    text = pattern.sub(_sub_validated, text)
                     continue
                 if pattern.search(text):
                     categories.add(name)
@@ -776,8 +875,9 @@ def redact_trajectory(path: Path) -> RedactionResult:
 
             for name, pattern in _SECRET_PATTERNS.items():
                 matches = pattern.findall(text)
-                if name == "credit_card":
-                    matches = [m for m in matches if _luhn_valid(m)]
+                validator = _SECRET_VALIDATORS.get(name)
+                if validator is not None:
+                    matches = [m for m in matches if validator(m)]
                 residual_secrets[name] += len(matches)
             residual_email += len(_EMAIL_PATTERN.findall(text))
             residual_phone += len(_PHONE_PATTERN.findall(text))
@@ -906,3 +1006,71 @@ def content_simhash(path: Path) -> int:
 def hamming_distance(a: int, b: int) -> int:
     """Number of differing bits between two fingerprints."""
     return bin(a ^ b).count("1")
+
+
+# Per-capture identifiers and opaque blobs that carry no conversational content
+# and would only dilute overlap between two copies of the same session.
+_SKETCH_SKIP_KEYS = frozenset(
+    {"id", "tool_use_id", "call_id", "signature", "encrypted_content", "uuid", "parentUuid", "timestamp"}
+)
+_SKETCH_WORD_RE = re.compile(r"\w+")
+_SKETCH_SHINGLE_WORDS = 5
+# Keep a shingle when its hash is 0 mod this value. Content-defined sampling
+# (unlike SimHash or bottom-k) keeps the same shingles from any excerpt of a
+# session, so a chunk, a truncated copy, or a lightly-edited copy still shares
+# most of its sampled shingles with the original.
+_SKETCH_SAMPLE_MODULUS = 8
+_SKETCH_MAX_HASHES = 20000
+
+
+def _sketch_strings(value: object, out: list[str]) -> None:
+    if isinstance(value, str):
+        out.append(value)
+    elif isinstance(value, list):
+        for item in value:
+            _sketch_strings(item, out)
+    elif isinstance(value, dict):
+        for key, item in value.items():
+            if key not in _SKETCH_SKIP_KEYS:
+                _sketch_strings(item, out)
+
+
+def content_sketch(path: Path) -> list[int]:
+    """Sampled word-shingle hashes over message text AND tool calls/results.
+
+    Worker-only, companion to content_simhash: SimHash only matches
+    near-identical whole sessions, so a moderately-edited copy, a chunk split
+    out of a session, or a truncated re-upload slips past it. Overlap between
+    two sketches estimates how much of one session's content appears in the
+    other regardless of size or order. Hashes only -- not reversible to text.
+    Returned sorted, deduplicated, as signed 64-bit ints (Postgres bigint).
+    """
+    sampled: set[int] = set()
+    with path.open(encoding="utf-8", errors="replace") as handle:
+        for line in handle:
+            try:
+                record = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            if not isinstance(record, dict):
+                continue
+            strings: list[str] = []
+            if record.get("type") == "response_item" and isinstance(record.get("payload"), dict):
+                _sketch_strings(record["payload"], strings)
+            elif record.get("type") in {"user", "assistant"} and isinstance(record.get("message"), dict):
+                _sketch_strings(record["message"].get("content"), strings)
+            if not strings:
+                continue
+            normalized = _TIMESTAMP_RE.sub(" ", "\n".join(strings).lower())
+            normalized = _UUID_RE.sub(" ", normalized)
+            words = _SKETCH_WORD_RE.findall(normalized)
+            for index in range(len(words) - _SKETCH_SHINGLE_WORDS + 1):
+                shingle = " ".join(words[index : index + _SKETCH_SHINGLE_WORDS])
+                value = int.from_bytes(
+                    hashlib.blake2b(shingle.encode("utf-8"), digest_size=8).digest(), "big", signed=True
+                )
+                if value % _SKETCH_SAMPLE_MODULUS == 0:
+                    sampled.add(value)
+    # Cap by smallest values so every capped sketch is a consistent prefix of
+    # its full sketch; the server compares only below the lower of two maxima.
+    return sorted(sampled)[:_SKETCH_MAX_HASHES]

{reasonwork-0.6.0 → reasonwork-0.6.2}/src/reasonwork_exchange/cli/__init__.py

@@ -16,12 +16,25 @@ from reasonwork_exchange.cli import sync as _sync
 from reasonwork_exchange.cli import update as _update
 from reasonwork_exchange.cli import upload as _upload
 
+_QUICK_START = (
+    "[bold]Quick start[/bold]\n\n"
+    "1. [bold]reasonwork login[/bold]  paste the token from reasonwork.ai/settings (input is hidden)\n\n"
+    "2. [bold]reasonwork scan[/bold]  list local sessions and their privacy checks; nothing is uploaded\n\n"
+    "3. [bold]reasonwork upload --path FILE --confirm-rights[/bold]  submit one session, or\n\n"
+    "   [bold]reasonwork sync[/bold]  submit new sessions, following your sharing mode\n\n"
+    "4. [bold]reasonwork config show[/bold]  check what's shared; "
+    "[bold]reasonwork config set --sharing-mode ask[/bold] to be asked first\n\n"
+    "Run [bold]reasonwork COMMAND -h[/bold] for a command's options and an example."
+)
+
 app = typer.Typer(
     name="reasonwork",
-    help="Discover, inspect, and submit Codex or Claude Code trajectories.",
+    help="Discover, inspect, and submit Claude Code, Codex, and Cursor sessions to Reasonwork.",
+    epilog=_QUICK_START,
     add_completion=False,
     rich_markup_mode="rich",
     no_args_is_help=True,
+    context_settings={"help_option_names": ["-h", "--help"]},
 )
 
 app.command(name="login", epilog=_login._EPILOG)(_login.login)

{reasonwork-0.6.0 → reasonwork-0.6.2}/src/reasonwork_exchange/cli/config.py

@@ -11,7 +11,20 @@ from reasonwork_exchange.config import VALID_SHARING_MODES, ConsentConfigStore
 from reasonwork_exchange.errors import ValidationError
 from reasonwork_exchange.output import JsonOpt, emit_success, handle_errors
 
-_EPILOG = "example: reasonwork config set --sharing-mode ask"
+_EPILOG = (
+    "sharing modes:\n\n"
+    "  all   automatically upload every new session from all agents (Claude Code, Codex, Cursor) "
+    "in all projects on this machine, without asking\n\n"
+    "  ask   list what would be uploaded and ask before each sync (default)\n\n"
+    "  none  never upload\n\n"
+    "example: reasonwork config set --sharing-mode ask"
+)
+
+_MODE_SUMMARY = {
+    "all": "every new session from all agents and all projects on this machine is uploaded automatically, without asking",
+    "ask": "you'll be shown what would be uploaded and asked before each sync",
+    "none": "nothing is uploaded",
+}
 
 config_app = typer.Typer(name="config", help="Inspect and adjust local sharing consent.", no_args_is_help=True)
 
@@ -23,7 +36,7 @@ def show(json_: JsonOpt = False) -> int:
     return emit_success(
         json_,
         [
-            f"sharing_mode: {config.sharing_mode}",
+            f"sharing_mode: {config.sharing_mode} ({_MODE_SUMMARY.get(config.sharing_mode, '')})",
             f"excluded_sources: {', '.join(config.excluded_sources) or '(none)'}",
             f"excluded_paths: {', '.join(config.excluded_paths) or '(none)'}",
         ],
@@ -37,17 +50,33 @@ def show(json_: JsonOpt = False) -> int:
 
 @handle_errors
 def set_mode(
-    sharing_mode: Annotated[str, typer.Option("--sharing-mode", help="all, ask, or none.")],
+    sharing_mode: Annotated[
+        str,
+        typer.Option(
+            "--sharing-mode",
+            help=(
+                "all: upload every new session from all agents (Claude Code, Codex, Cursor) and all "
+                "projects on this machine automatically, without asking. ask: ask before each sync "
+                "(default). none: never upload."
+            ),
+        ),
+    ],
     json_: JsonOpt = False,
 ) -> int:
-    """Set the sharing mode: all, ask, or none."""
+    """Set the sharing mode: all (automatic, every agent and project), ask, or none."""
     if sharing_mode not in VALID_SHARING_MODES:
         raise ValidationError(
             f"sharing mode must be one of {', '.join(sorted(VALID_SHARING_MODES))}", code="invalid_sharing_mode"
         )
     store = ConsentConfigStore()
     store.write(replace(store.read(), sharing_mode=sharing_mode))
-    return emit_success(json_, [f"sharing_mode set to {sharing_mode}."], {"sharing_mode": sharing_mode})
+    lines = [f"sharing_mode set to {sharing_mode}: {_MODE_SUMMARY[sharing_mode]}."]
+    if sharing_mode == "all":
+        lines.append(
+            "Exclude anything you don't want shared with `reasonwork config exclude --path DIR` "
+            "or `--source NAME`."
+        )
+    return emit_success(json_, lines, {"sharing_mode": sharing_mode})
 
 
 @handle_errors

reasonwork-0.6.2/src/reasonwork_exchange/cli/login.py

@@ -0,0 +1,75 @@
+"""`reasonwork login` — verify and store a contributor token."""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import Annotated
+
+import typer
+
+from reasonwork_exchange.errors import ValidationError
+from reasonwork_exchange.output import JsonOpt, emit_success, handle_errors
+
+_EPILOG = (
+    "example: reasonwork login   (paste your token when asked; it isn't shown or saved in shell history)\n\n"
+    "scripts: REASONWORK_TOKEN=nxc_xxx reasonwork login"
+)
+TOKEN_ENV = "REASONWORK_TOKEN"
+
+
+def _interactive() -> bool:
+    return sys.stdin.isatty()
+
+
+def _resolve_token(flag: str | None) -> str:
+    """--token, else $REASONWORK_TOKEN, else a hidden prompt on a terminal."""
+    token = (flag or os.environ.get(TOKEN_ENV) or "").strip()
+    if token:
+        return token
+    if not _interactive():
+        raise ValidationError(
+            "no token provided",
+            code="token_required",
+            hint=f"run `reasonwork login` in a terminal, or set {TOKEN_ENV}",
+        )
+    return typer.prompt("Paste your token (from reasonwork.ai/settings)", hide_input=True).strip()
+
+
+@handle_errors
+def login(
+    token: Annotated[
+        str | None,
+        typer.Option(
+            "--token",
+            help=(
+                "The nxc_ token from reasonwork.ai/settings. Prefer leaving this out: "
+                "you'll be asked for it with the input hidden, so it doesn't end up in "
+                f"shell history. Scripts can set {TOKEN_ENV} instead."
+            ),
+        ),
+    ] = None,
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Verify the token but do not write the contributor auth file.")
+    ] = False,
+    json_: JsonOpt = False,
+) -> int:
+    """Sign in: verify your contributor token and store it, or preview under --dry-run."""
+    from reasonwork_exchange.auth import ContributorAuthStore
+    from reasonwork_exchange.client import ContributeClient
+
+    token = _resolve_token(token)
+    identity = ContributeClient(token).whoami()
+    store = ContributorAuthStore()
+    if not dry_run:
+        store.write(token)
+    email = str(identity.get("email", ""))
+    return emit_success(
+        json_,
+        (
+            [f"[dry-run] verified contributor {email}; token file was not written."]
+            if dry_run
+            else [f"Logged in as contributor {email}.", f"Token stored securely for your user at {store.path}."]
+        ),
+        {"logged_in": not dry_run, "verified": True, "dry_run": dry_run, "email": email, "path": str(store.path)},
+    )

{reasonwork-0.6.0 → reasonwork-0.6.2}/src/reasonwork_exchange/cli/scan.py

@@ -17,7 +17,7 @@ def scan(
     limit: Annotated[int, typer.Option("--limit", min=1, max=500, help="Newest candidates to inspect, per source.")] = 20,
     json_: JsonOpt = False,
 ) -> int:
-    """Discover local Codex and Claude Code sessions and show metadata-only checks."""
+    """Discover local Claude Code, Codex, and Cursor sessions and show metadata-only checks."""
     from reasonwork_exchange.analyzer import analyze
     from reasonwork_exchange.discovery import discover
     from reasonwork_exchange.state import SubmissionLedger

reasonwork-0.6.0/src/reasonwork_exchange/cli/login.py

@@ -1,39 +0,0 @@
-"""`reasonwork login` — verify and store a contributor token."""
-
-from __future__ import annotations
-
-from typing import Annotated
-
-import typer
-
-from reasonwork_exchange.output import JsonOpt, emit_success, handle_errors
-
-_EPILOG = "example: reasonwork login --token nxc_xxx --dry-run"
-
-
-@handle_errors
-def login(
-    token: Annotated[str, typer.Option("--token", help="The nxc_ token created in the exchange's /settings page.")],
-    dry_run: Annotated[
-        bool, typer.Option("--dry-run", help="Verify the token but do not write the contributor auth file.")
-    ] = False,
-    json_: JsonOpt = False,
-) -> int:
-    """Verify the token and store it, or preview under --dry-run."""
-    from reasonwork_exchange.auth import ContributorAuthStore
-    from reasonwork_exchange.client import ContributeClient
-
-    identity = ContributeClient(token).whoami()
-    store = ContributorAuthStore()
-    if not dry_run:
-        store.write(token)
-    email = str(identity.get("email", ""))
-    return emit_success(
-        json_,
-        (
-            [f"[dry-run] verified contributor {email}; token file was not written."]
-            if dry_run
-            else [f"Logged in as contributor {email}.", f"Token stored securely for your user at {store.path}."]
-        ),
-        {"logged_in": not dry_run, "verified": True, "dry_run": dry_run, "email": email, "path": str(store.path)},
-    )