xsync-cli 0.1.4__tar.gz → 0.2.0__tar.gz

{xsync_cli-0.1.4 → xsync_cli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: xsync-cli
-Version: 0.1.4
+Version: 0.2.0
 Summary: Sync the model list of an OpenAI-compatible endpoint into the Codex model catalog.
 License-Expression: MIT
 License-File: LICENSE
@@ -50,19 +50,25 @@ The last question asks for the wire API:
 A wrong value breaks every request. Ask the operator of the endpoint when
 you do not know.
 
-### 2. Connect Codex to the endpoint
+### 2. Open a harness
 
-    xsync codex --init
+    xsync codex
+    xsync claude
 
-The command adds `[model_providers.<profile>]` to `~/.codex/config.toml` and
-points `model_catalog_json` at the catalog of the profile. Run this one time
-for each endpoint.
+The command builds a home for the profile, then starts the harness in that
+home. The real Codex and the real Claude Code of the user stay as they are.
 
-### 3. Sync
+Arguments after `--` go to the harness:
 
-    xsync codex
+    xsync claude -- --model cmc/deepseek/deepseek-v4-pro
+
+### 3. Or write the real harness
 
-Run this command again when the endpoint changes.
+    xsync codex apply
+    xsync claude apply
+
+The `apply` verb changes the real home of the user. Read **Safety** before
+you use it.
 
 ## Commands
 
@@ -72,18 +78,38 @@ Run this command again when the endpoint changes.
 | `xsync list` | Show the profiles. The active profile has a star. |
 | `xsync use <name>` | Set the active profile. |
 | `xsync remove <name>` | Delete a profile. |
-| `xsync codex` | Sync the active profile into the Codex catalog. |
-| `xsync codex --dry-run` | Show the difference. Write nothing. |
-| `xsync codex --profile <name>` | Use another profile for one run. |
-| `xsync codex --init` | Connect Codex to the endpoint of the profile. |
-| `xsync codex --reset` | Remove everything that xSync wrote. |
-| `xsync codex --reset --force` | Reset when no state file exists. It asks first. |
-| `xsync codex --reset --force --yes` | Reset with no question. Use this in a script. |
-| `xsync claude` | Sync the active profile into the Claude Code model picker. |
-| `xsync claude --init` | Point Claude Code at the endpoint of the profile. |
-| `xsync claude --dry-run` | Show the difference. Write nothing. |
-| `xsync claude --reset` | Remove everything that xSync wrote. |
 | `xsync help` | Show the help. `xsync help codex` explains one command. |
+| `xsync codex` | Open a Codex on the active profile, in its own home. |
+| `xsync claude` | Open a Claude Code the same way. |
+| `xsync codex -- <args>` | The arguments after `--` go to the harness. |
+| `xsync codex apply` | Write the real Codex of the user. |
+| `xsync claude apply` | Write the real Claude Code of the user. |
+| `xsync <harness> apply --dry-run` | Show the difference. Write nothing. |
+| `xsync <harness> apply --reset` | Remove everything that xSync wrote. |
+| `xsync <harness> apply --reset --force --yes` | Reset with no question. |
+| `xsync <harness> --profile <name>` | Use another profile for one run. |
+
+## The isolated home
+
+`xsync codex` and `xsync claude` do not change the settings of the user. Each
+one builds a home under `~/.config/xsync/homes/<profile>/`, and then starts
+the harness with `CODEX_HOME` or with `CLAUDE_CONFIG_DIR` set to that home.
+
+The home starts as a copy of the real settings file, so the hooks of the
+user and the trusted projects of the user stay. xSync then points the copy at
+the endpoint of the profile.
+
+The home shares the work of the user through a symbolic link:
+
+| Harness | Shared |
+|---|---|
+| Codex | `skills`, `plugins`, `marketplaces`, `memories`, `AGENTS.md` |
+| Claude Code | `agents`, `skills`, `plugins`, `hooks`, `commands`, `CLAUDE.md` |
+
+A session, a cache, and a log stay inside the isolated home. They never mix
+with the real home.
+
+Delete a home at any time. The next command builds it again.
 
 Exit codes: `0` for success, `1` for an error, `2` when the endpoint does not
 answer.

{xsync_cli-0.1.4 → xsync_cli-0.2.0}/README.md

@@ -38,19 +38,25 @@ The last question asks for the wire API:
 A wrong value breaks every request. Ask the operator of the endpoint when
 you do not know.
 
-### 2. Connect Codex to the endpoint
+### 2. Open a harness
 
-    xsync codex --init
+    xsync codex
+    xsync claude
 
-The command adds `[model_providers.<profile>]` to `~/.codex/config.toml` and
-points `model_catalog_json` at the catalog of the profile. Run this one time
-for each endpoint.
+The command builds a home for the profile, then starts the harness in that
+home. The real Codex and the real Claude Code of the user stay as they are.
 
-### 3. Sync
+Arguments after `--` go to the harness:
 
-    xsync codex
+    xsync claude -- --model cmc/deepseek/deepseek-v4-pro
+
+### 3. Or write the real harness
 
-Run this command again when the endpoint changes.
+    xsync codex apply
+    xsync claude apply
+
+The `apply` verb changes the real home of the user. Read **Safety** before
+you use it.
 
 ## Commands
 
@@ -60,18 +66,38 @@ Run this command again when the endpoint changes.
 | `xsync list` | Show the profiles. The active profile has a star. |
 | `xsync use <name>` | Set the active profile. |
 | `xsync remove <name>` | Delete a profile. |
-| `xsync codex` | Sync the active profile into the Codex catalog. |
-| `xsync codex --dry-run` | Show the difference. Write nothing. |
-| `xsync codex --profile <name>` | Use another profile for one run. |
-| `xsync codex --init` | Connect Codex to the endpoint of the profile. |
-| `xsync codex --reset` | Remove everything that xSync wrote. |
-| `xsync codex --reset --force` | Reset when no state file exists. It asks first. |
-| `xsync codex --reset --force --yes` | Reset with no question. Use this in a script. |
-| `xsync claude` | Sync the active profile into the Claude Code model picker. |
-| `xsync claude --init` | Point Claude Code at the endpoint of the profile. |
-| `xsync claude --dry-run` | Show the difference. Write nothing. |
-| `xsync claude --reset` | Remove everything that xSync wrote. |
 | `xsync help` | Show the help. `xsync help codex` explains one command. |
+| `xsync codex` | Open a Codex on the active profile, in its own home. |
+| `xsync claude` | Open a Claude Code the same way. |
+| `xsync codex -- <args>` | The arguments after `--` go to the harness. |
+| `xsync codex apply` | Write the real Codex of the user. |
+| `xsync claude apply` | Write the real Claude Code of the user. |
+| `xsync <harness> apply --dry-run` | Show the difference. Write nothing. |
+| `xsync <harness> apply --reset` | Remove everything that xSync wrote. |
+| `xsync <harness> apply --reset --force --yes` | Reset with no question. |
+| `xsync <harness> --profile <name>` | Use another profile for one run. |
+
+## The isolated home
+
+`xsync codex` and `xsync claude` do not change the settings of the user. Each
+one builds a home under `~/.config/xsync/homes/<profile>/`, and then starts
+the harness with `CODEX_HOME` or with `CLAUDE_CONFIG_DIR` set to that home.
+
+The home starts as a copy of the real settings file, so the hooks of the
+user and the trusted projects of the user stay. xSync then points the copy at
+the endpoint of the profile.
+
+The home shares the work of the user through a symbolic link:
+
+| Harness | Shared |
+|---|---|
+| Codex | `skills`, `plugins`, `marketplaces`, `memories`, `AGENTS.md` |
+| Claude Code | `agents`, `skills`, `plugins`, `hooks`, `commands`, `CLAUDE.md` |
+
+A session, a cache, and a log stay inside the isolated home. They never mix
+with the real home.
+
+Delete a home at any time. The next command builds it again.
 
 Exit codes: `0` for success, `1` for an error, `2` when the endpoint does not
 answer.

{xsync_cli-0.1.4 → xsync_cli-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "xsync-cli"
-version = "0.1.4"
+version = "0.2.0"
 description = "Sync the model list of an OpenAI-compatible endpoint into the Codex model catalog."
 readme = "README.md"
 requires-python = ">=3.11"

xsync_cli-0.2.0/src/xsync_cli/adapters/isolated.py

@@ -0,0 +1,118 @@
+"""The builder of an isolated harness home.
+
+The functions here write into a home that xSync owns. They read the
+real home of the user, but they never write into it.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from collections.abc import Sequence
+from pathlib import Path
+
+import tomlkit
+
+from xsync_cli.adapters.claude import load_rules as load_claude_rules
+from xsync_cli.adapters.claude import render_rows
+from xsync_cli.adapters.codex import load_rules as load_codex_rules
+from xsync_cli.adapters.codex import render_catalog
+from xsync_cli.core.atomic import write_json_atomic
+from xsync_cli.core.homes import SHARED_CLAUDE, SHARED_CODEX, link_shared
+from xsync_cli.core.model import Model
+from xsync_cli.core.profiles import Profile
+
+
+def prepare_codex_home(
+    home: Path,
+    real_home: Path,
+    profile: Profile,
+    api_key: str | None,
+    models: Sequence[Model],
+) -> Path:
+    """Build a Codex home that talks to the endpoint of the profile.
+
+    The function copies the real `config.toml` as a base, so the trusted
+    projects of the user stay. It then points the copy at the endpoint.
+    """
+    home.mkdir(parents=True, exist_ok=True)
+
+    catalog_path = home / f"{profile.name}-models.json"
+    write_json_atomic(
+        catalog_path, render_catalog(models, load_codex_rules()), keep_backup=False
+    )
+
+    real_config = real_home / "config.toml"
+    document = (
+        tomlkit.parse(real_config.read_text(encoding="utf-8"))
+        if real_config.exists()
+        else tomlkit.document()
+    )
+
+    document["model_catalog_json"] = str(catalog_path)
+    document["model_provider"] = profile.name
+
+    providers = document.get("model_providers")
+    if providers is None:
+        providers = tomlkit.table(is_super_table=True)
+        document["model_providers"] = providers
+
+    entry = tomlkit.table()
+    entry["name"] = profile.name
+    entry["base_url"] = profile.base_url
+    entry["wire_api"] = profile.wire_api
+    if api_key:
+        headers = tomlkit.table()
+        headers["Authorization"] = f"Bearer {api_key}"
+        entry["http_headers"] = headers
+    providers[profile.name] = entry
+
+    temporary = home / "config.toml.tmp"
+    temporary.write_text(tomlkit.dumps(document), encoding="utf-8")
+    os.replace(temporary, home / "config.toml")
+
+    link_shared(real_home, home, SHARED_CODEX)
+    return home
+
+
+def prepare_claude_home(
+    home: Path,
+    real_home: Path,
+    profile: Profile,
+    api_key: str | None,
+    models: Sequence[Model],
+) -> Path:
+    """Build a Claude Code home that talks to the endpoint.
+
+    The function copies the real `settings.json` as a base, so the hooks
+    of the user stay. It then adds the endpoint and the picker rows.
+    """
+    home.mkdir(parents=True, exist_ok=True)
+
+    real_settings = real_home / "settings.json"
+    settings: dict = {}
+    if real_settings.exists():
+        try:
+            loaded = json.loads(real_settings.read_text(encoding="utf-8"))
+            if isinstance(loaded, dict):
+                settings = loaded
+        except json.JSONDecodeError:
+            settings = {}
+
+    environment = dict(settings.get("env") or {})
+    environment["ANTHROPIC_BASE_URL"] = profile.base_url
+    if api_key:
+        environment["ANTHROPIC_AUTH_TOKEN"] = api_key
+    settings["env"] = environment
+
+    rows = render_rows(models, load_claude_rules())
+    settings["modelPicker"] = {"options": rows, "replaceBuiltInOptions": False}
+
+    temporary = home / "settings.json.tmp"
+    temporary.write_text(
+        json.dumps(settings, indent=2, ensure_ascii=False) + "\n", encoding="utf-8"
+    )
+    os.replace(temporary, home / "settings.json")
+
+    link_shared(real_home, home, SHARED_CLAUDE)
+    return home

{xsync_cli-0.1.4 → xsync_cli-0.2.0}/src/xsync_cli/cli.py

@@ -10,7 +10,9 @@ from getpass import getpass
 from pathlib import Path
 
 from xsync_cli.adapters.codex import load_rules, render_catalog
+from xsync_cli.adapters.isolated import prepare_claude_home, prepare_codex_home
 from xsync_cli.core import term
+from xsync_cli.core.homes import HomeError, home_for, launch
 from xsync_cli.adapters.claude import load_rules as load_claude_rules
 from xsync_cli.adapters.claude import render_rows
 from xsync_cli.adapters import claude_config
@@ -382,8 +384,8 @@ def _do_reset(
     return EXIT_OK
 
 
-def cmd_codex(args: argparse.Namespace) -> int:
-    """Sync a profile into the Codex catalog."""
+def _codex_apply(args: argparse.Namespace) -> int:
+    """Write the real Codex home."""
     store = open_store()
     codex_home = default_codex_home()
     config_path = codex_home / "config.toml"
@@ -491,15 +493,20 @@ examples:
   xsync setup                      make a profile, and read the model list
   xsync list                       show the profiles. The active one has a star
   xsync use openrouter             set the active profile
-  xsync codex --init               connect Codex to the endpoint of the profile
-  xsync codex --dry-run            show the difference. Write nothing
-  xsync codex                      sync the models into the Codex catalog
-  xsync codex --reset              remove everything that xsync wrote
+
+  xsync codex                      open a Codex on the profile, in its own home
+  xsync claude                     open a Claude Code the same way
+  xsync claude -- --model a/b      arguments after -- go to the harness
+
+  xsync codex apply                write the real Codex of the user
+  xsync claude apply               write the real Claude Code of the user
+  xsync codex apply --dry-run      show the difference. Write nothing
+  xsync codex apply --reset        remove everything that xsync wrote
 
 files:
   ~/.config/xsync/profiles.toml    the profiles. `xsync setup` writes this file
-  ~/.codex/<profile>-models.json   the Codex catalog that `xsync codex` writes
-  ~/.codex/config.toml             only `--init` and `--reset` write this file
+  ~/.config/xsync/homes/           one home for each profile and each harness
+  ~/.codex, ~/.claude              only `apply` writes these
 
 exit codes:
   0 success    1 error    2 the endpoint does not answer
@@ -569,8 +576,8 @@ def _claude_reset(claude_home: Path, profile_name: str, force: bool, yes: bool)
     return EXIT_OK
 
 
-def cmd_claude(args: argparse.Namespace) -> int:
-    """Sync a profile into the Claude Code model picker."""
+def _claude_apply(args: argparse.Namespace) -> int:
+    """Write the real Claude Code home."""
     store = open_store()
     claude_home = default_claude_home()
     settings_file = settings_path_for(claude_home)
@@ -706,6 +713,130 @@ def _print_claude_report(rows, old_rows, profile: Profile) -> None:
         print(term.dim(f"   {native} models keep their native Claude handling"))
 
 
+def _resolve_profile(args: argparse.Namespace):
+    """The profile of this run, or None after an error."""
+    store = open_store()
+    try:
+        return store.get(args.profile) if args.profile else store.active_profile()
+    except ProfileError as error:
+        _fail(str(error))
+        return None
+
+
+def _models_for(profile) -> tuple[list | None, int]:
+    """The models of the endpoint, after the filters."""
+    try:
+        api_key = profile.resolve_key(os.environ)
+        models = fetch_models(profile.base_url, api_key)
+    except EndpointUnreachable as error:
+        _fail(str(error))
+        return None, EXIT_UNREACHABLE
+    except (SourceError, ProfileError) as error:
+        _fail(str(error))
+        return None, EXIT_ERROR
+    return apply_filters(models, profile.include, profile.exclude), EXIT_OK
+
+
+def _extra_args(args: argparse.Namespace) -> list[str]:
+    """The arguments that go to the harness."""
+    extra = list(getattr(args, "extra", None) or [])
+    return extra[1:] if extra and extra[0] == "--" else extra
+
+
+def _open_harness(args: argparse.Namespace, harness: str) -> int:
+    """Build the isolated home, then start the harness in it."""
+    profile = _resolve_profile(args)
+    if profile is None:
+        return EXIT_ERROR
+
+    models, code = _models_for(profile)
+    if models is None:
+        return code
+
+    try:
+        home = home_for(profile.name, harness)
+    except HomeError as error:
+        _fail(str(error))
+        return EXIT_ERROR
+
+    try:
+        api_key = profile.resolve_key(os.environ)
+    except ProfileError as error:
+        _fail(str(error))
+        return EXIT_ERROR
+
+    if harness == "codex":
+        prepare_codex_home(home, default_codex_home(), profile, api_key, models)
+        command, variable = "codex", "CODEX_HOME"
+    else:
+        prepare_claude_home(home, default_claude_home(), profile, api_key, models)
+        command, variable = "claude", "CLAUDE_CONFIG_DIR"
+
+    print(term.heading(f"{command} · {profile.name}"))
+    print(term.dim(f"   {profile.base_url}"))
+    print(term.dim(f"   home: {home}"))
+    _ok(f"{term.bold(str(len(models)))} models ready. Your real {command} is untouched.")
+    print()
+
+    try:
+        launch(command, variable, str(home), _extra_args(args))
+    except HomeError as error:
+        _fail(str(error))
+        return EXIT_ERROR
+    return EXIT_OK
+
+
+def cmd_codex(args: argparse.Namespace) -> int:
+    """Open an isolated Codex, or write the real one."""
+    if args.action == "apply":
+        # `apply` writes the real home. It therefore wires the endpoint.
+        # A dry run writes nothing, so it never wires anything.
+        if not args.reset and not args.dry_run:
+            args.init = True
+        return _codex_apply(args)
+    return _open_harness(args, "codex")
+
+
+def cmd_claude(args: argparse.Namespace) -> int:
+    """Open an isolated Claude Code, or write the real one."""
+    if args.action == "apply":
+        # `apply` writes the real home. It therefore wires the endpoint.
+        # A dry run writes nothing, so it never wires anything.
+        if not args.reset and not args.dry_run:
+            args.init = True
+        return _claude_apply(args)
+    return _open_harness(args, "claude")
+
+
+def _add_harness_arguments(parser: argparse.ArgumentParser) -> None:
+    """The arguments that both harness commands share."""
+    parser.add_argument(
+        "action",
+        nargs="?",
+        choices=["apply"],
+        help="apply writes the real home of the harness",
+    )
+    parser.add_argument("--profile", help="use this profile for one run")
+    parser.add_argument(
+        "--dry-run", action="store_true", help="apply: show the difference only"
+    )
+    parser.add_argument(
+        "--init",
+        action="store_true",
+        help="apply: point the harness at the endpoint (implied by apply)",
+    )
+    parser.add_argument(
+        "--reset", action="store_true", help="apply: remove everything xsync wrote"
+    )
+    parser.add_argument(
+        "--force", action="store_true", help="apply: reset without a state file"
+    )
+    parser.add_argument(
+        "--yes", action="store_true", help="apply: answer yes to the reset question"
+    )
+    parser.set_defaults(extra=[])
+
+
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         prog="xsync",
@@ -726,34 +857,28 @@ def build_parser() -> argparse.ArgumentParser:
     remove.add_argument("name")
     remove.set_defaults(func=cmd_remove)
 
-    codex = sub.add_parser("codex", help="sync a profile into the Codex catalog")
-    codex.add_argument("--profile", help="use this profile for one run")
-    codex.add_argument("--dry-run", action="store_true", help="show the difference only")
-    codex.add_argument("--init", action="store_true", help="wire Codex to the endpoint")
-    codex.add_argument(
-        "--reset", action="store_true", help="remove everything xSync wrote"
-    )
-    codex.add_argument("--force", action="store_true", help="reset without a state file")
-    codex.add_argument(
-        "--yes", action="store_true", help="answer yes to the reset question"
+    codex = sub.add_parser(
+        "codex",
+        help="open an isolated Codex on the active profile",
+        description=(
+            "Open a Codex that talks to the endpoint of the profile. The real "
+            "Codex of the user stays as it is. Add `apply` to write the real "
+            "Codex instead."
+        ),
     )
+    _add_harness_arguments(codex)
     codex.set_defaults(func=cmd_codex)
 
     claude = sub.add_parser(
-        "claude", help="sync a profile into the Claude Code model picker"
-    )
-    claude.add_argument("--profile", help="use this profile for one run")
-    claude.add_argument("--dry-run", action="store_true", help="show the difference only")
-    claude.add_argument(
-        "--init", action="store_true", help="point Claude Code at the endpoint"
-    )
-    claude.add_argument(
-        "--reset", action="store_true", help="remove everything xsync wrote"
-    )
-    claude.add_argument("--force", action="store_true", help="reset without a state file")
-    claude.add_argument(
-        "--yes", action="store_true", help="answer yes to the reset question"
+        "claude",
+        help="open an isolated Claude Code on the active profile",
+        description=(
+            "Open a Claude Code that talks to the endpoint of the profile. The "
+            "real Claude Code of the user stays as it is. Add `apply` to write "
+            "the real Claude Code instead."
+        ),
     )
+    _add_harness_arguments(claude)
     claude.set_defaults(func=cmd_claude)
 
     help_command = sub.add_parser("help", help="show this help, or the help of a command")
@@ -763,9 +888,23 @@ def build_parser() -> argparse.ArgumentParser:
     return parser
 
 
+def _split_extra(argv: list[str]) -> tuple[list[str], list[str]]:
+    """Cut the argument list at the first `--`.
+
+    argparse reads the first part. The harness gets the second part.
+    """
+    if "--" not in argv:
+        return argv, []
+    cut = argv.index("--")
+    return argv[:cut], argv[cut + 1 :]
+
+
 def main(argv: list[str] | None = None) -> int:
+    raw = list(sys.argv[1:] if argv is None else argv)
+    mine, theirs = _split_extra(raw)
     parser = build_parser()
-    args = parser.parse_args(argv)
+    args = parser.parse_args(mine)
+    args.extra = theirs
     if not getattr(args, "command", None):
         parser.print_help()
         return EXIT_OK

xsync_cli-0.2.0/src/xsync_cli/core/homes.py

@@ -0,0 +1,108 @@
+"""The isolated home of one harness.
+
+A harness keeps its settings in a home directory. xSync makes one home
+for each profile and each harness. The harness then runs against the
+endpoint of the profile, and the real home of the user stays as it is.
+
+The home holds its own settings and its own sessions. It links the
+folders that hold the work of the user, such as the skills and the
+plugins, so those stay in one place.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Callable
+
+# The folders and the files that both homes share. A session folder, a
+# cache, and a log never appear here. Those hold state of one run.
+SHARED_CODEX = ("skills", "plugins", "marketplaces", "memories", "AGENTS.md")
+SHARED_CLAUDE = ("agents", "skills", "plugins", "hooks", "commands", "CLAUDE.md")
+
+
+class HomeError(Exception):
+    """The home cannot be made, or the harness cannot start."""
+
+
+def homes_root() -> Path:
+    """The folder that holds every isolated home."""
+    from xsync_cli.core.profiles import default_store_path
+
+    override = os.environ.get("XSYNC_PROFILES")
+    base = Path(override).parent if override else default_store_path().parent
+    return base / "homes"
+
+
+def home_for(profile_name: str, harness: str) -> Path:
+    """The home of one profile and one harness."""
+    if not profile_name or "/" in profile_name or profile_name in (".", ".."):
+        raise HomeError(
+            f"the profile name {profile_name!r} cannot become a folder name."
+        )
+    return homes_root() / profile_name / harness
+
+
+def link_shared(
+    source_home: Path, target_home: Path, names: Sequence[str]
+) -> list[str]:
+    """Share the work of the user with the isolated home.
+
+    A folder becomes a symbolic link. A file becomes a copy, because a
+    harness writes a file back. The function never replaces a real
+    folder in the target.
+    """
+    shared: list[str] = []
+    for name in names:
+        source = source_home / name
+        if not source.exists():
+            continue
+        target = target_home / name
+
+        if source.is_dir():
+            if target.is_symlink():
+                if target.resolve() == source.resolve():
+                    shared.append(name)
+                    continue
+                target.unlink()
+            elif target.exists():
+                continue
+            target.symlink_to(source, target_is_directory=True)
+            shared.append(name)
+        else:
+            if target.exists() and not target.is_symlink():
+                continue
+            if target.is_symlink():
+                target.unlink()
+            shutil.copy2(source, target)
+            shared.append(name)
+    return shared
+
+
+def _default_exec(command: str, argv: list[str], env: dict[str, str]) -> None:
+    os.execvpe(command, argv, env)  # noqa: S606
+
+
+def launch(
+    command: str,
+    home_variable: str,
+    home: str,
+    extra_args: Sequence[str],
+    exec_fn: Callable[[str, list[str], dict[str, str]], None] | None = None,
+) -> None:
+    """Start the harness against the isolated home.
+
+    The function replaces the xsync process. It does not return.
+    """
+    env = dict(os.environ)
+    env[home_variable] = str(home)
+    argv = [command, *extra_args]
+    runner = exec_fn or _default_exec
+    try:
+        runner(command, argv, env)
+    except FileNotFoundError:
+        raise HomeError(
+            f"the command {command!r} is not found. Install it, or add it to PATH."
+        ) from None