claude-code-tools 1.16.2__tar.gz → 1.18.0__tar.gz

{claude_code_tools-1.16.2 → claude_code_tools-1.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-tools
-Version: 1.16.2
+Version: 1.18.0
 Summary: Collection of tools for working with Claude Code
 License-File: LICENSE
 Requires-Python: >=3.11
@@ -66,81 +66,14 @@ separate Rust binary:
   [Releases](https://github.com/pchalasani/claude-code-tools/releases)
   (look for `rust-v*`)
 
-Install the Claude Code workflow plugin:
+Install the Claude Code
+[plugins](https://pchalasani.github.io/claude-code-tools/getting-started/plugins/)
+for hooks, skills, and agents:
 
 ```bash
 claude plugin marketplace add pchalasani/claude-code-tools
-claude plugin install workflow@cctools-plugins
 ```
 
-Install the equivalent dynamic workflow plugin for Codex:
-
-```bash
-codex plugin marketplace add pchalasani/claude-code-tools
-codex plugin add dynamic-workflow@cctools-codex-plugins
-```
-
-The Codex plugin installs independently: it does not require the Python
-`claude-code-tools` package or an npm install. Node.js 20 or newer and Codex
-CLI 0.136.0 or newer are required for callbacks. Version 0.136.0 is the first
-compatible CLI release for this callback protocol. Codex still marks the app
-server and remote TUI interfaces as experimental, so those surfaces may evolve.
-The plugin can notify the originating Codex thread through Codex's shared app
-server after a detached workflow finishes. Callback preflight also rejects a
-stale connected server.
-
-The optional Python package makes that callback setup a single command:
-
-```bash
-codex-dynamic
-# Or continue the latest conversation:
-codex-dynamic resume --last
-```
-
-`codex-dynamic` starts or reuses the local app server and then hands the
-terminal directly to Codex. After a plugin or Codex upgrade, the next launch
-automatically starts a fresh server generation; existing sessions and workflow
-callbacks stay connected to their old generation. No manual restart is needed.
-Use `codex-server status` or `logs` for nondisruptive inspection. A forced stop
-or restart cleans up every retained generation and disconnects its attached
-TUIs, so use those commands only after exiting the sessions normally.
-
-The Python package also installs `codex-workflows`, an observational dashboard
-for durable workflow runs:
-
-```bash
-codex-workflows
-codex-workflows watch --limit 20
-codex-workflows show RUN_ID
-codex-workflows --all
-```
-
-The default list contains only active workflows and identifies the project
-folder from which each workflow was launched. Use `show RUN_ID` for its full
-working directory, or `--all` to include completed and diagnostic history. The
-command reads durable workflow state and process metadata. It never changes a
-run, sends a signal, repairs state, or launches an agent. See the
-[codex-workflows reference][codex-workflows-reference] for filters, JSON output,
-and the complete versioned schema.
-
-[codex-workflows-reference]:
-  //pchalasani.github.io/claude-code-tools/tools/codex-dynamic/#observe-workflow-runs
-
-Server management and passive supervision add no model calls. Completion
-reporting starts a new turn only while the thread is idle; otherwise it steers
-and extends the active turn. Either reporting path consumes model tokens.
-
-Each workflow `run` or `resume` uses narrow host execution for that exact
-reviewed supervisor command. The workflow JavaScript remains restricted, and
-every headless Codex worker keeps its declared sandbox.
-
-See the
-[Claude → Codex migration guide][claude-to-codex-guide]
-for usage and workflow-porting instructions.
-
-[claude-to-codex-guide]:
-  https://pchalasani.github.io/claude-code-tools/guides/claude-to-codex/
-
 ---
 
 Click a card to jump to that feature, or

{claude_code_tools-1.16.2 → claude_code_tools-1.18.0}/README.md

@@ -40,81 +40,14 @@ separate Rust binary:
   [Releases](https://github.com/pchalasani/claude-code-tools/releases)
   (look for `rust-v*`)
 
-Install the Claude Code workflow plugin:
+Install the Claude Code
+[plugins](https://pchalasani.github.io/claude-code-tools/getting-started/plugins/)
+for hooks, skills, and agents:
 
 ```bash
 claude plugin marketplace add pchalasani/claude-code-tools
-claude plugin install workflow@cctools-plugins
 ```
 
-Install the equivalent dynamic workflow plugin for Codex:
-
-```bash
-codex plugin marketplace add pchalasani/claude-code-tools
-codex plugin add dynamic-workflow@cctools-codex-plugins
-```
-
-The Codex plugin installs independently: it does not require the Python
-`claude-code-tools` package or an npm install. Node.js 20 or newer and Codex
-CLI 0.136.0 or newer are required for callbacks. Version 0.136.0 is the first
-compatible CLI release for this callback protocol. Codex still marks the app
-server and remote TUI interfaces as experimental, so those surfaces may evolve.
-The plugin can notify the originating Codex thread through Codex's shared app
-server after a detached workflow finishes. Callback preflight also rejects a
-stale connected server.
-
-The optional Python package makes that callback setup a single command:
-
-```bash
-codex-dynamic
-# Or continue the latest conversation:
-codex-dynamic resume --last
-```
-
-`codex-dynamic` starts or reuses the local app server and then hands the
-terminal directly to Codex. After a plugin or Codex upgrade, the next launch
-automatically starts a fresh server generation; existing sessions and workflow
-callbacks stay connected to their old generation. No manual restart is needed.
-Use `codex-server status` or `logs` for nondisruptive inspection. A forced stop
-or restart cleans up every retained generation and disconnects its attached
-TUIs, so use those commands only after exiting the sessions normally.
-
-The Python package also installs `codex-workflows`, an observational dashboard
-for durable workflow runs:
-
-```bash
-codex-workflows
-codex-workflows watch --limit 20
-codex-workflows show RUN_ID
-codex-workflows --all
-```
-
-The default list contains only active workflows and identifies the project
-folder from which each workflow was launched. Use `show RUN_ID` for its full
-working directory, or `--all` to include completed and diagnostic history. The
-command reads durable workflow state and process metadata. It never changes a
-run, sends a signal, repairs state, or launches an agent. See the
-[codex-workflows reference][codex-workflows-reference] for filters, JSON output,
-and the complete versioned schema.
-
-[codex-workflows-reference]:
-  //pchalasani.github.io/claude-code-tools/tools/codex-dynamic/#observe-workflow-runs
-
-Server management and passive supervision add no model calls. Completion
-reporting starts a new turn only while the thread is idle; otherwise it steers
-and extends the active turn. Either reporting path consumes model tokens.
-
-Each workflow `run` or `resume` uses narrow host execution for that exact
-reviewed supervisor command. The workflow JavaScript remains restricted, and
-every headless Codex worker keeps its declared sandbox.
-
-See the
-[Claude → Codex migration guide][claude-to-codex-guide]
-for usage and workflow-porting instructions.
-
-[claude-to-codex-guide]:
-  https://pchalasani.github.io/claude-code-tools/guides/claude-to-codex/
-
 ---
 
 Click a card to jump to that feature, or

{claude_code_tools-1.16.2 → claude_code_tools-1.18.0}/claude_code_tools/__init__.py

@@ -1,3 +1,3 @@
 """Claude Code Tools - Collection of utilities for Claude Code."""
 
-__version__ = "1.16.2"
+__version__ = "1.18.0"

{claude_code_tools-1.16.2 → claude_code_tools-1.18.0}/claude_code_tools/aichat.py

@@ -30,6 +30,26 @@ class SessionIDGroup(click.Group):
         return super().parse_args(ctx, args)
 
 
+class ResolveCommand(click.Command):
+    """Click command that renders resolver usage errors without usage text."""
+
+    def parse_args(self, ctx: click.Context, args: list[str]) -> list[str]:
+        """Parse arguments, converting Click usage failures to resolver errors."""
+        import sys
+
+        from claude_code_tools.resolve_session_render import _render_error
+
+        raw_args = tuple(args)
+        try:
+            return super().parse_args(ctx, args)
+        except click.UsageError as error:
+            pretty = "--pretty" in raw_args or (
+                "--json" not in raw_args and sys.stdout.isatty()
+            )
+            _render_error("invalid_input", error.format_message(), pretty)
+            ctx.exit(1)
+
+
 @click.group(cls=SessionIDGroup, invoke_without_command=True)
 @click.version_option()
 @click.option(
@@ -95,8 +115,15 @@ def main(ctx, claude_home, codex_home):
     # Auto-index sessions on every aichat command (incremental, fast if up-to-date)
     # Skip for build-index/clear-index to avoid double-indexing or state conflicts
     # In JSON mode (-j/--json), suppress all output for clean parsing
+    # 'port' is also skipped: its contract requires the detected
+    # direction line to be the FIRST output, so the indexer's progress
+    # bar must never print before it.
     skip_auto_index_cmds = ['build-index', 'clear-index', 'index-stats']
-    should_skip = any(cmd in sys.argv for cmd in skip_auto_index_cmds)
+    should_skip = (
+        ctx.invoked_subcommand in ('port', 'resolve')
+        or ctx.invoked_subcommand in skip_auto_index_cmds
+        or any(cmd in sys.argv for cmd in skip_auto_index_cmds)
+    )
     json_mode = any(arg in sys.argv for arg in ['-j', '--json'])
     if not should_skip:
         try:
@@ -128,6 +155,60 @@ def main(ctx, claude_home, codex_home):
         )
 
 
+@main.command("resolve", cls=ResolveCommand)
+@click.argument("query")
+@click.option(
+    "--agent",
+    type=str,
+    metavar="claude|codex",
+    default="claude",
+    show_default=True,
+)
+@click.option(
+    "--home",
+    type=click.Path(readable=False),
+    help="Claude or Codex home directory to search.",
+)
+@click.option("--json", "json_output", is_flag=True, help="Force JSON output.")
+@click.option(
+    "--pretty",
+    "pretty_output",
+    is_flag=True,
+    help="Force human-readable output.",
+)
+@click.pass_context
+def resolve_session_cmd(
+    ctx: click.Context,
+    query: str,
+    agent: str,
+    home: str | None,
+    json_output: bool,
+    pretty_output: bool,
+) -> None:
+    """Resolve a session name, full ID, ID fragment, or filename fragment.
+
+    Ordered tiers (first non-empty wins): exact ID, exact name, ID
+    prefix, ID substring, name substring, session-file name
+    substring (e.g. a codex rollout timestamp like
+    2026-03-25T14-50).
+    """
+    import sys
+
+    from claude_code_tools.resolve_session_render import run
+
+    if json_output and pretty_output:
+        click.echo(
+            '{"error":"invalid_format",'
+            '"detail":"Choose only one of --json or --pretty."}'
+        )
+        sys.exit(1)
+    if home is None:
+        home_key = "codex_home" if agent.casefold() == "codex" else "claude_home"
+        home = ctx.ensure_object(dict).get(home_key)
+    fmt = "json" if json_output else "pretty" if pretty_output else "auto"
+    sys.exit(run(query, agent.lower(), home, fmt))
+
+
 # Shared help text for find commands
 _FIND_OPTIONS_COMMON = """
 Options:
@@ -1370,6 +1451,104 @@ def move_session(session, new_project, agent):
         console.print(f"  [cyan]{resume_cmd}[/cyan]")
 
 
+@main.command("port")
+@click.argument("session", required=True)
+@click.option("--claude-home", help="Path to Claude home directory")
+@click.option("--codex-home", help="Path to Codex home directory")
+@click.pass_context
+def port_session(
+    ctx: click.Context,
+    session: str,
+    claude_home: "str | None",
+    codex_home: "str | None",
+) -> None:
+    """Port a session to the OTHER agent (codex <-> claude).
+
+    Auto-detects which agent the session belongs to. Codex sessions
+    are converted into a flattened, resumable Claude Code session;
+    Claude sessions are converted into a flattened, resumable Codex
+    rollout.
+
+    SESSION may be a full session id, a partial id (prefix, middle,
+    or suffix fragment), a session name (set with /rename), a
+    rollout filename fragment (e.g. 2026-03-25T14-50), or a session
+    file path. Lookup is global across all projects in both homes.
+
+    \b
+    Examples:
+        aichat port 019f6d85-df3c-7c83-84f6-b97e73305fcf
+        aichat port abc123 --claude-home ~/.claude-alt
+        aichat port my-session-name
+        aichat port 2026-03-25T14-50
+    """
+    import sys
+
+    from claude_code_tools.port_service import (
+        PortSessionError,
+        port_claude_session,
+        port_codex_session,
+        resolve_port_session,
+    )
+
+    # Group-level --claude-home/--codex-home (given BEFORE the
+    # subcommand) are stored on the root context; command-level
+    # options take precedence.
+    root_obj = ctx.find_root().obj or {}
+    claude_home = claude_home or root_obj.get("claude_home")
+    codex_home = codex_home or root_obj.get("codex_home")
+
+    try:
+        resolved = resolve_port_session(
+            session, claude_home=claude_home, codex_home=codex_home
+        )
+    except PortSessionError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    if resolved.agent == "claude":
+        print("Detected source agent: claude — porting to Codex")
+        try:
+            result = port_claude_session(
+                resolved.session_file, codex_home=codex_home
+            )
+        except PortSessionError as e:
+            print(f"Error: {e}", file=sys.stderr)
+            sys.exit(1)
+
+        print()
+        print(f"New Codex session id:  {result.new_session_id}")
+        print(f"Output file:           {result.output_file}")
+        print(f"Session cwd:           {result.cwd}")
+        print()
+        print("To resume:")
+        print(f"  {result.resume_hint}")
+        print()
+        print(
+            "Tip: codex's /import can also import Claude sessions "
+            "natively (interactive alternative)."
+        )
+        return
+
+    print("Detected source agent: codex — porting to Claude Code")
+    try:
+        result = port_codex_session(
+            resolved.session_file, claude_home=claude_home
+        )
+    except PortSessionError as e:
+        # Expected failure modes (missing/empty session, filesystem
+        # or encoding errors) become a clean error, not a traceback.
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    print()
+    print(f"New Claude session id: {result.new_session_id}")
+    print(f"Output file:           {result.output_file}")
+    print(f"Session cwd:           {result.cwd}")
+    print()
+    print("To resume:")
+    print(f"  {result.resume_hint}")
+
+
 @main.command("query")
 @click.argument("session", required=False)
 @click.argument("question", required=False)

{claude_code_tools-1.16.2 → claude_code_tools-1.18.0}/claude_code_tools/codex_server.py

@@ -14,11 +14,13 @@ import struct
 import subprocess
 import sys
 import time
-from contextlib import contextmanager
+from contextlib import ExitStack, contextmanager
 from dataclasses import replace
 from pathlib import Path
 from typing import Iterator, Mapping, Sequence
 
+from claude_code_tools import codex_server_retry
+from claude_code_tools.codex_server_legacy import reauthenticate_legacy_state
 from claude_code_tools.codex_server_fingerprint import (
     PluginSnapshot as _PluginSnapshot,
     hash_plugin_tree as _hash_plugin_tree,  # noqa: F401
@@ -78,6 +80,7 @@ from claude_code_tools.codex_server_reuse import (
     disconnect_refusal as _disconnect_refusal,
     helper_restart_reason as _reuse_restart_reason,
     require_external_compatible as _external_compatible,
+    same_server_launch as _same_server_launch,
 )
 
 
@@ -150,6 +153,22 @@ def _lifecycle_lock(paths: ServerPaths) -> Iterator[None]:
         os.close(fd)
 
 
+@contextmanager
+def _reserved_generation_lifecycle(
+    base: ServerPaths,
+    paths: ServerPaths,
+    generation: str,
+) -> Iterator[None]:
+    """Reserve capacity before releasing the base lifecycle lock."""
+    generation_lock = ExitStack()
+    with _lifecycle_lock(base):
+        require_generation_capacity(base, generation)
+        prepare_runtime(paths)
+        generation_lock.enter_context(_lifecycle_lock(paths))
+    with generation_lock:
+        yield
+
+
 def _resolve_codex(env: Mapping[str, str]) -> str:
     """Resolve a canonical executable used by both server and TUI."""
     configured = env.get("CCTOOLS_CODEX_BIN")
@@ -519,6 +538,7 @@ def get_status(env: Mapping[str, str] | None = None) -> ServerStatus:
     except StateFileError as exc:
         state = None
         state_error = str(exc)
+    state = reauthenticate_legacy_state(paths, state, _socket_peer_pid)
     probe = _probe_server(codex_path, child_env, paths)
     return _status_from(paths, state, probe, state_error)
 
@@ -557,33 +577,12 @@ def _require_unchanged_plugin_snapshot(
 ) -> None:
     """Reject a lifecycle decision made across a plugin input change."""
     if _plugin_configuration_snapshot(paths, codex_options) != expected:
-        raise CodexServerError(
+        raise codex_server_retry.PluginSnapshotChangedError(
             "the Codex plugin or marketplace snapshot changed during "
             f"{operation}; retry after plugin updates finish"
         )
 
 
-def _same_server_launch(expected: OwnedServer, current: OwnedServer) -> bool:
-    """Return whether two states name the same exact supervised launch."""
-    return (
-        current.pid,
-        current.pgid,
-        current.process_started_at,
-        current.launch_token,
-        current.worker_pid,
-        current.worker_pgid,
-        current.worker_started_at,
-    ) == (
-        expected.pid,
-        expected.pgid,
-        expected.process_started_at,
-        expected.launch_token,
-        expected.worker_pid,
-        expected.worker_pgid,
-        expected.worker_started_at,
-    )
-
-
 def _certify_helper_boundary(
     expected: OwnedServer,
     active_env: Mapping[str, str],
@@ -724,6 +723,7 @@ def _wait_for_process_group_exit(
     )
 
 
+@codex_server_retry.retry_plugin_snapshot_changes
 def ensure_server(
     env: Mapping[str, str] | None = None,
     *,
@@ -745,16 +745,15 @@ def ensure_server(
         codex_options,
     )
     paths = paths_for_generation(base_paths, generation)
-    require_generation_capacity(base_paths, generation)
-    child_env = _command_env(active_env, paths)
-    child_env[CODEX_SERVER_OPTIONS_ENV] = json.dumps(
-        list(codex_options),
-        separators=(",", ":"),
-    )
-    with _lifecycle_lock(paths):
+    with _reserved_generation_lifecycle(base_paths, paths, generation):
+        child_env = _command_env(active_env, paths)
+        child_env[CODEX_SERVER_OPTIONS_ENV] = json.dumps(
+            list(codex_options),
+            separators=(",", ":"),
+        )
         locked_snapshot = _plugin_configuration_snapshot(paths, codex_options)
         if locked_snapshot.fingerprint != plugin_snapshot.fingerprint:
-            raise CodexServerError(
+            raise codex_server_retry.PluginSnapshotChangedError(
                 "the Codex plugin or marketplace snapshot changed during "
                 "app-server generation selection; retry after updates finish"
             )
@@ -766,6 +765,7 @@ def ensure_server(
         except StateFileError as exc:
             state = None
             state_error = str(exc)
+        state = reauthenticate_legacy_state(paths, state, _socket_peer_pid)
 
         probe = _probe_server(codex_path, child_env, paths)
         status = _status_from(paths, state, probe, state_error)
@@ -938,6 +938,7 @@ def _stop_server_at(
                 ) from exc
             _quarantine_invalid_state(paths)
             state = None
+        state = reauthenticate_legacy_state(paths, state, _socket_peer_pid)
 
         if state is not None and _state_is_owned(state):
             if not allow_disconnect: