hostctl 0.1.2__tar.gz → 0.2.1__tar.gz

{hostctl-0.1.2 → hostctl-0.2.1}/CHANGELOG.md

@@ -7,6 +7,112 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.2.1] - 2026-07-29
+
+### Added
+
+- `ConnectionString` parses a connection target from whatever a user typed.
+  `ConnectionString("nas", scheme="wss")` and `ConnectionString("nas:8443",
+  ...)` parse, because a bare host is not an invalid URI — it is a URI with
+  the scheme left off, which is what people type on a command line.
+
+  Every field can be supplied directly, and three layers decide each one: an
+  explicit argument wins, then whatever the string carried, then `defaults`.
+  `scheme=`/`port=`/`host=`/… are therefore *overrides* — `scheme="ssh"`
+  beats a `wss://` in the string — while `defaults` (a mapping, or another
+  `ConnectionString` used as a profile) fills only what nothing else
+  supplied.
+
+  A port carries its own resolution strategy wherever one is accepted: an
+  `int`, a callable `scheme -> port | None`, or anything indexable by scheme
+  (a plain mapping), so a caller passes its whole table without pre-selecting
+  an entry. When no layer supplies one, `netimps.get_default_port` resolves
+  the scheme — it knows schemes no system services database does (`ws`/`wss`,
+  `socks5`), and an application can register more with
+  `netimps.register_port`.
+
+  `False` stops the search outright: no port, and no lookup.
+
+  Credentials are parsed but never rendered. `str()` and `repr()` both emit
+  the redacted form, with the password **removed rather than masked**, so the
+  output stays a valid, reusable connection string that cannot round-trip a
+  wrong credential — and a value reaching a log line or a traceback frame
+  cannot leak one. A password may carry `key:value` extras after a newline,
+  as `parse_credentials` describes, written raw.
+
+  The host keeps the spelling it was given. `is_local` resolves nothing — it
+  is called while a configuration is built, which is network-free, and
+  resolving would both block and raise on a name that does not resolve. An
+  address literal is answered by `netimps.is_local_address`, so an address
+  actually assigned to this machine counts as local and not just loopback,
+  while a name is compared against the loopback spellings. `qsl` and
+  `query_val()` read the query; `replace()` returns a changed copy.
+
+### Changed
+
+- **`netimps` is now a required dependency**, supplying scheme/port and
+  address semantics rather than hostctl reimplementing them. Note this
+  arrives in a patch release: an existing install pinned within `0.2.x` gains
+  a new requirement, so a locked or offline environment needs `netimps`
+  available before upgrading.
+
+### Fixed
+
+- A path in a command is rendered through `__fspath__` rather than `str()`.
+  Every transport now shares one `command_text` helper — the SSH, WinRM,
+  container, QGA, and PSRP executors each stringified with `str()`, so only
+  the local executor asked for the filesystem representation. `__fspath__` is
+  tried by attribute rather than by `isinstance(value, os.PathLike)`, so a
+  duck-typed path that never registered with the ABC is honoured too, and an
+  object whose `__fspath__` raises or returns a non-string falls back to
+  `str()` rather than failing the command. The shell layer follows the same
+  rule. No shipped path type changes behaviour — `str()` and `__fspath__`
+  agree for all of them — but the contract now matches what a path promises.
+
+## [0.2.0] - 2026-07-28
+
+### Added
+
+- `Exec(program, *args)` marks one command for direct execution: the program
+  runs with that argv and no shell layer renders. The program and every
+  argument may be a `str`, `bytes`, or a path object — all reach the transport
+  as text, so the spelling records how the caller held the value rather than
+  changing what runs. A **bare program name is now possible**
+  (`Exec("ls", "-l")`), resolved through the target's `PATH`; it previously had
+  no spelling at all, because a plain string command is always shell text.
+- The full `run()` command syntax is documented in the "Running commands"
+  guide: the varargs rule, the three command forms, operators, validation, and
+  the PowerShell rendering.
+
+### Changed
+
+- **Breaking.** Direct execution is marked by `Exec`, not by position. A path
+  in the first argument used to mean "this is the executable, the rest is
+  argv"; a path is now an ordinary value that stringifies wherever it appears.
+
+  ```python
+  host.run(Path("/bin/ls"), "-l")   # before: direct execution
+  host.run(Exec("/bin/ls", "-l"))   # now
+  ```
+
+  This is a **silent** change for the old spelling: `run(Path(...), *args)`
+  still succeeds, but the values become several `;`-joined shell commands
+  instead of one program and its argv, so arguments are subject to shell
+  quoting and word-splitting. Anything passing a leading path must be updated;
+  there is no deprecation shim.
+
+  What it buys, both unspellable before: several path commands in one call
+  (`run(p1, p2)` is two commands), and direct execution of a `PATH`-resolved
+  name.
+
+  An `Exec` cannot be combined with other commands in one call — there is no
+  shell to join them with, and running only one would silently drop the rest.
+  It raises `TypeError` rather than choosing.
+- `hostctl run` passes its operand as a single `Exec`, so the program is used
+  verbatim. It no longer converts the operand through the target shell's path
+  flavour, which means a bare name now resolves through the target's `PATH`
+  instead of being treated as a relative path.
+
 ## [0.1.2] - 2026-07-28
 
 Supersedes 0.1.1, which was tagged but never published: a release-gate test
@@ -186,6 +292,8 @@ test suite on Python 3.9 through 3.14.
   assigned to it; a config-less host now builds its own family configuration
   instead.
 
-[Unreleased]: https://github.com/jose-pr/hostctl/compare/v0.1.2...HEAD
+[Unreleased]: https://github.com/jose-pr/hostctl/compare/v0.2.1...HEAD
+[0.2.1]: https://github.com/jose-pr/hostctl/compare/v0.2.0...v0.2.1
+[0.2.0]: https://github.com/jose-pr/hostctl/compare/v0.1.2...v0.2.0
 [0.1.2]: https://github.com/jose-pr/hostctl/compare/v0.1.0...v0.1.2
 [0.1.0]: https://github.com/jose-pr/hostctl/releases/tag/v0.1.0

{hostctl-0.1.2 → hostctl-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hostctl
-Version: 0.1.2
+Version: 0.2.1
 Summary: Run commands and access files on a host, local or remote, protocol-agnostic
 Project-URL: Homepage, https://github.com/jose-pr/hostctl/
 Project-URL: Documentation, https://jose-pr.github.io/hostctl/
@@ -24,6 +24,7 @@ Classifier: Topic :: System :: Filesystems
 Classifier: Topic :: System :: Systems Administration
 Classifier: Typing :: Typed
 Requires-Python: >=3.9
+Requires-Dist: netimps<0.2,>=0.1
 Requires-Dist: pathlib-next<0.9,>=0.8.6
 Provides-Extra: container
 Requires-Dist: docker<8,>=7.1; extra == 'container'
@@ -172,6 +173,22 @@ with Host("ssh://admin:secret@nas.example.com") as same_host:
     same_host.run("uptime")
 ```
 
+`run()` takes one positional argument per command, so a `list` is a single
+command whose elements are each quoted, not a list of commands:
+
+```python
+host.run(["chmod", "755", target])                          # one command
+host.run(["chmod", "755", target], ["chown", "u", target])  # two commands
+host.run("chmod", "755", target)                            # WRONG: three commands
+```
+
+A raw string is verbatim shell text, and `Exec(program, *args)` is direct
+execution — one program plus argv, with no shell layer, where the program may
+be an absolute path or a bare name resolved through the target's `PATH`. A
+`ShellOperator` between two commands joins them conditionally. See the
+[running commands guide](https://jose-pr.github.io/hostctl/guide/run/) for the
+full rules.
+
 A URI may carry `user:password@host` on the way *in* — it is a valid URI, so
 hostctl accepts it, extracts the password into the credentials, and keeps it
 out of every rendered form. Passing the same password both in the URI and as an

{hostctl-0.1.2 → hostctl-0.2.1}/README.md

@@ -118,6 +118,22 @@ with Host("ssh://admin:secret@nas.example.com") as same_host:
     same_host.run("uptime")
 ```
 
+`run()` takes one positional argument per command, so a `list` is a single
+command whose elements are each quoted, not a list of commands:
+
+```python
+host.run(["chmod", "755", target])                          # one command
+host.run(["chmod", "755", target], ["chown", "u", target])  # two commands
+host.run("chmod", "755", target)                            # WRONG: three commands
+```
+
+A raw string is verbatim shell text, and `Exec(program, *args)` is direct
+execution — one program plus argv, with no shell layer, where the program may
+be an absolute path or a bare name resolved through the target's `PATH`. A
+`ShellOperator` between two commands joins them conditionally. See the
+[running commands guide](https://jose-pr.github.io/hostctl/guide/run/) for the
+full rules.
+
 A URI may carry `user:password@host` on the way *in* — it is a valid URI, so
 hostctl accepts it, extracts the password into the credentials, and keeps it
 out of every rendered form. Passing the same password both in the URI and as an

{hostctl-0.1.2 → hostctl-0.2.1}/docs/api/reference.md

@@ -39,6 +39,7 @@ without a deprecation cycle.
 
 ## Executors and processes
 
+::: hostctl.Exec
 ::: hostctl.Executor
 ::: hostctl.ExecutionOptions
 ::: hostctl.LocalExecutor
@@ -79,6 +80,7 @@ without a deprecation cycle.
 
 ## Connection strings
 
+::: hostctl.ConnectionString
 ::: hostctl.redact_uri
 ::: hostctl.parse_credentials
 ::: hostctl.strict_uri_credentials

{hostctl-0.1.2 → hostctl-0.2.1}/docs/guide/run.md

@@ -12,10 +12,113 @@ result = host.run("echo hello")
 print(result.stdout)
 ```
 
+## Command syntax
+
+`run(*cmds, **options)` takes **one positional argument per command** — it is
+varargs, not a list of commands. This is the distinction to get right:
+
+```python
+host.run(["chmod", "755", target])                      # ONE command
+host.run(["chmod", "755", target], ["chown", "u", target])  # TWO commands
+```
+
+A list is *one* command whose elements are quoted individually. Wrapping
+commands in an outer list does not produce several commands — the inner lists
+are stringified into a single nonsensical argument:
+
+```python
+host.run([["chmod", "755", target]])   # WRONG: one command, mangled
+```
+
+The mirror mistake is passing an argv as separate positionals, which makes each
+element its own command:
+
+```python
+host.run("chmod", "755", target)       # WRONG: runs chmod;755;/path
+```
+
+### The three forms a command may take
+
+| Form | Example | Result |
+| --- | --- | --- |
+| Structured `list`/`tuple` | `["chmod", "755", p]` | `chmod 755 '/tmp/a b'` — every element quoted as data |
+| Raw `str` | `"echo $HOME"` | verbatim shell text; globs, pipes, and `$VAR` are interpreted |
+| `Exec(...)` | `Exec("/bin/ls", "-l", p)` | direct execution: one program plus argv, no shell |
+
+Prefer the structured form. It quotes each element, so a value containing a
+space, quote, `$`, or `;` is passed as data instead of changing the command.
+Use a raw string only when you want the shell to interpret the text.
+
+Elements may be `str`, `bytes`, `int`, or path objects; all are normalized and
+quoted. `["echo", 42, b"by", PurePosixPath("/p q")]` renders as
+`echo 42 by '/p q'`.
+
+### Joining and operators
+
+Commands are joined with the flavour's separator (`;` on POSIX). Pass a
+`ShellOperator` *between* two commands to join them conditionally instead:
+
+```python
+from hostctl import ShellOperator
+
+host.run(["test", "-f", target], ShellOperator.AND, ["rm", target])
+```
+
+`ShellOperator` provides `AND`, `OR`, `PIPE`, `REDIRECT`, `APPEND`, and
+`SEQUENCE`. An operator that is leading, trailing, or adjacent to another
+raises `ValueError`, and a flavour may reject one it cannot represent
+portably — PowerShell 5 rejects `AND`/`OR`, while PowerShell 7 accepts them.
+
+### `Exec` is direct execution
+
+`Exec(program, *args)` runs one program with an argv, with no shell layer
+rendered — nothing quotes, splits, or interprets the values:
+
+```python
+from hostctl import Exec
+
+host.run(Exec("/bin/ls", "-l", target))   # absolute path
+host.run(Exec("ls", "-l"))                # resolved through the target's PATH
+```
+
+The program and each argument may be a `str`, `bytes`, or a path object. All
+of them reach the transport as text, so the spelling records how you happened
+to hold the value rather than changing what runs. A bare name is only possible
+here: a plain string command is always shell text.
+
+Arguments are argv values, never nested commands — a list or tuple raises
+`TypeError` rather than blurring the two.
+
+Direct execution replaces the whole call, so an `Exec` cannot be combined with
+other commands: there is no shell to join them with, and running just one
+would silently drop the rest. Give each its own call, or use structured
+commands if you want them joined.
+
+Everything else is an ordinary value. A path is just a value that
+stringifies, wherever it appears:
+
+```python
+host.run(["chmod", "755", Path("/srv/app")])   # a quoted argument
+host.run(Path("/bin/a"), Path("/bin/b"))       # two shell commands
+```
+
+### Validation
+
+An empty structured command and any control character (including a newline
+inside a value, which could otherwise smuggle in a second command) raise
+`ValueError`. An empty raw string is skipped when joining.
+
+### PowerShell targets
+
+PowerShell flavours render a structured command through the `&` call operator
+and append `; exit $LASTEXITCODE` so the remote status propagates:
+
+```
+& 'Get-Item' 'C:/a b'; exit $LASTEXITCODE
+```
+
 `run()` returns a `subprocess.CompletedProcess`. Highlights:
 
-- Multiple positional commands are joined with `;`. A command given as a
-  `list`/`tuple` is shell-quoted piece by piece.
 - `capture_output` may be `True` (both streams), `"stdout"`, `"stderr"`, or
   `False`.
 - SSH `input=`, `cwd=`, `env=`, `check=`, `timeout=`, and

{hostctl-0.1.2 → hostctl-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hostctl"
-version = "0.1.2"
+version = "0.2.1"
 authors = [{ name = "Jose A." }]
 description = "Run commands and access files on a host, local or remote, protocol-agnostic"
 readme = "README.md"
@@ -28,9 +28,12 @@ classifiers = [
     "Topic :: System :: Filesystems",
     "Typing :: Typed",
 ]
-# pathlib_next supplies the common local/remote path return type. Transport
-# implementations remain extras, so importing hostctl never requires them.
-dependencies = ["pathlib_next>=0.8.6,<0.9"]
+# pathlib_next supplies the common local/remote path return type. netimps
+# supplies scheme/port and address semantics -- including schemes no system
+# services database knows (ws/wss, socks5) -- so hostctl does not reimplement
+# them. Transport implementations remain extras, so importing hostctl never
+# requires them.
+dependencies = ["pathlib_next>=0.8.6,<0.9", "netimps>=0.1,<0.2"]
 
 [project.optional-dependencies]
 # SSH-backed run()/path(): asyncssh for shell exec, pathlib_next's SftpPath

{hostctl-0.1.2 → hostctl-0.2.1}/src/hostctl/AGENTS.md

@@ -57,9 +57,20 @@ shared protocol implementations can be added once; `Shell.__call__` delegates
 to `Shell.execute()`.
 `Host` itself supplies the multi-command `run()` provider contract; there is no
 duplicate host-executor protocol or unused host-options wrapper.
-`Shell.execute(path_like)` preserves the path, while string input remains a
-string. Executors and hosts distinguish direct commands from shell scripts by
-that value type; no duplicate command-kind flag is carried.
+`Exec(program, *args)` is the direct-execution marker for `Host.run()`: one
+program plus argv, no shell layer. The program may be a `str`, `bytes`, or a
+path — all reach the transport as text, so a bare name resolves through the
+target's `PATH`. Direct execution replaces the whole call, so an `Exec`
+combined with any other command raises. Everything else is an ordinary value:
+a path is a value that stringifies wherever it appears, so `run(p1, p2)` is two
+shell commands. `Exec` is a deliberately non-iterable frozen dataclass --
+`ShellFlavour.command_text` dispatches structured commands on `Iterable`, and
+an iterable marker would be quoted into an argv instead of taking the direct
+branch; `command_text` raises if an `Exec` reaches it.
+`Shell.execute(command, *args)` keeps its own program-plus-argv signature and
+wraps into an `Exec` only when dispatching to a host `run(*cmds)` and only when
+argv values are present -- `Shell.run` renders every command into one script
+and dispatches it with no args, and that script is shell text, not a program.
 
 ## Configuration and lifecycle
 

{hostctl-0.1.2 → hostctl-0.2.1}/src/hostctl/__init__.py

@@ -33,7 +33,9 @@ from .executor import (
 )
 from .host import (
     ContainerConfig as ContainerConfig,
+    ConnectionString as ConnectionString,
     ContainerHost as ContainerHost,
+    Exec as Exec,
     Host as Host,
     HostConfig as HostConfig,
     HostInfo as HostInfo,
@@ -125,6 +127,7 @@ __all__ = [
     "ssh_providers",
     "strict_uri_credentials",
     "strict_uri_query",
+    "ConnectionString",
     "uri_host",
     "uri_hostname",
     "winrm_providers",
@@ -146,6 +149,7 @@ __all__ = [
     "IosConfig",
     "IosHost",
     # Executors and processes
+    "Exec",
     "Executor",
     "ExecutionOptions",
     "ExecutorCapability",

{hostctl-0.1.2 → hostctl-0.2.1}/src/hostctl/_cli.py

@@ -8,7 +8,6 @@ import dataclasses
 import getpass
 import json
 import os
-from pathlib import PurePath
 import re
 import subprocess
 import sys
@@ -17,7 +16,7 @@ import typing
 
 from pathlib_next import Path as NextPath
 
-from .host import Host, HostPath
+from .host import Exec, Host, HostPath
 
 _URI_OPERAND = re.compile(r"^[A-Za-z][A-Za-z0-9+.-]*:")
 
@@ -81,13 +80,11 @@ def _command_run(args: argparse.Namespace, stdout, stderr) -> int:
     if not command:
         raise ValueError("run requires a command after --")
     with Host(args.uri, **_credentials(args)) as host:
-        try:
-            command_path = host.shell_flavour.command_path(command[0])
-        except NotImplementedError:
-            command_path = PurePath(command[0])
+        # `Exec` marks direct execution and takes the program verbatim, so the
+        # operand needs no path flavour: a bare name resolves through the
+        # target's PATH and an absolute path is used as given.
         result = host.run(
-            command_path,
-            *command[1:],
+            Exec(command[0], *command[1:]),
             check=False,
             capture_output=True,
         )

{hostctl-0.1.2 → hostctl-0.2.1}/src/hostctl/executor/_common.py

@@ -94,6 +94,39 @@ def normalize_input(
     return input
 
 
+def command_text(
+    value: object, *, encoding: str = "utf-8", errors: str = "strict"
+) -> str:
+    """Render one command or argv value as the text a transport sends.
+
+    Anything offering `__fspath__` is asked for it first: that is the
+    filesystem representation a path promises, and it is what a transport
+    needs. `str()` happens to match for the path types shipped here, but that
+    is a coincidence of their `__str__` rather than a contract -- a path type
+    whose `repr`-ish `__str__` differs would otherwise send the wrong text.
+
+    `__fspath__` is tried directly rather than through
+    `isinstance(value, os.PathLike)`, so a duck-typed path that never
+    registered with the ABC is still honoured. A object whose `__fspath__`
+    raises or returns a non-string falls back to `str()` rather than failing
+    the command.
+
+    Bytes -- returned by `__fspath__` or passed directly -- are decoded;
+    everything else is stringified.
+    """
+    fspath = getattr(value, "__fspath__", None)
+    if callable(fspath):
+        try:
+            resolved = fspath()
+        except Exception:
+            resolved = None
+        if isinstance(resolved, (str, bytes)):
+            value = resolved
+    if isinstance(value, bytes):
+        return value.decode(encoding, errors)
+    return str(value)
+
+
 def normalize_environment(
     env: typing.Optional[Environment],
 ) -> typing.Optional[typing.Dict[str, str]]:

{hostctl-0.1.2 → hostctl-0.2.1}/src/hostctl/executor/container.py

@@ -7,6 +7,7 @@ import typing
 
 from ._common import (
     CaptureOutput,
+    command_text,
     CommandArgument,
     Environment,
     Executor,
@@ -79,10 +80,8 @@ class ContainerExecutor(Executor[subprocess.CompletedProcess]):
             )
 
         stdout, stderr = capture_streams(capture_output, stdout, stderr)
-        argv = [str(command)]
-        argv.extend(
-            value.decode() if isinstance(value, bytes) else str(value) for value in args
-        )
+        argv = [command_text(command)]
+        argv.extend(command_text(value) for value in args)
         merge_stderr = stderr is subprocess.STDOUT
         exec_options: typing.Dict[str, object] = {
             "stdout": True,

{hostctl-0.1.2 → hostctl-0.2.1}/src/hostctl/executor/local.py

@@ -8,6 +8,7 @@ import typing
 
 from ._common import (
     CaptureOutput,
+    command_text,
     CommandArgument,
     Environment,
     Executor,
@@ -52,21 +53,7 @@ class LocalExecutor(Executor[subprocess.CompletedProcess]):
             raise TypeError(f"unsupported local executor option: {sorted(options)[0]}")
         reject_stdin_conflict(input, stdin)
         stdout, stderr = capture_streams(capture_output, stdout, stderr)
-        argv = [
-            os.fspath(command),
-            *[
-                (
-                    value.decode()
-                    if isinstance(value, bytes)
-                    else (
-                        os.fspath(value)
-                        if isinstance(value, os.PathLike)
-                        else str(value)
-                    )
-                )
-                for value in args
-            ],
-        ]
+        argv = [command_text(command), *(command_text(value) for value in args)]
         return subprocess.run(
             argv,
             bufsize=bufsize,

{hostctl-0.1.2 → hostctl-0.2.1}/src/hostctl/executor/psrp.py

@@ -9,6 +9,7 @@ import types
 
 from ._common import (
     CaptureOutput,
+    command_text,
     CommandArgument,
     Executor,
     ExecutorCapability,
@@ -92,7 +93,9 @@ class PsrpExecutor(Executor[subprocess.CompletedProcess]):
                 "PSRP pipeline timeout is unsupported; configure WinRM timeouts"
             )
         stdout, stderr = capture_streams(capture_output, stdout, stderr)
-        result = self._session().invoke(str(command), raw=False, capture_exit=True)
+        result = self._session().invoke(
+            command_text(command), raw=False, capture_exit=True
+        )
         codec = encoding or "utf-8"
         # Preserve PowerShell's object-pipeline line orientation when
         # projecting objects to subprocess-compatible text.
@@ -135,7 +138,7 @@ class PsrpExecutor(Executor[subprocess.CompletedProcess]):
             errors=errors,
         )
         completed = subprocess.CompletedProcess(
-            args=str(command),
+            args=command_text(command),
             returncode=returncode,
             stdout=out,
             stderr=err,

{hostctl-0.1.2 → hostctl-0.2.1}/src/hostctl/executor/qemu.py

@@ -11,6 +11,7 @@ import typing
 from ._qga import GuestAgentTransport, QgaProtocolError
 from ._common import (
     CaptureOutput,
+    command_text,
     CommandArgument,
     Environment,
     Executor,
@@ -113,7 +114,8 @@ class QemuExecutor(Executor[subprocess.CompletedProcess]):
                 "QGA guest-exec has no native working-directory support"
             )
         reject_stdin_conflict(input, stdin)
-        if not str(command):
+        program = command_text(command)
+        if not program:
             raise ValueError("QGA guest-exec path must not be empty")
         if timeout is not None and timeout < 0:
             raise ValueError("timeout must not be negative")
@@ -122,15 +124,11 @@ class QemuExecutor(Executor[subprocess.CompletedProcess]):
 
         stdout, stderr = capture_streams(capture_output, stdout, stderr)
         argv = [
-            (
-                value.decode(encoding or "utf-8", errors or "strict")
-                if isinstance(value, bytes)
-                else str(value)
-            )
+            command_text(value, encoding=encoding or "utf-8", errors=errors or "strict")
             for value in args
         ]
         arguments: typing.Dict[str, object] = {
-            "path": str(command),
+            "path": program,
             "arg": argv,
             "capture-output": True,
         }
@@ -156,7 +154,7 @@ class QemuExecutor(Executor[subprocess.CompletedProcess]):
             arguments["input-data"] = base64.b64encode(payload).decode("ascii")
 
         deadline = None if timeout is None else self._clock() + timeout
-        command_display = [str(command), *argv]
+        command_display = [program, *argv]
         started = self._execute(
             {"execute": "guest-exec", "arguments": arguments},
             deadline,

{hostctl-0.1.2 → hostctl-0.2.1}/src/hostctl/executor/ssh.py

@@ -10,6 +10,7 @@ import typing
 
 from ._common import (
     CaptureOutput,
+    command_text,
     CommandArgument,
     Environment,
     Executor,
@@ -135,7 +136,7 @@ class SshExecutor(Executor[subprocess.CompletedProcess]):
             raise NotImplementedError("SshExecutor does not support native arguments")
         if bufsize == 0:
             raise ValueError("bufsize=0 is unsupported by the buffered SSH executor")
-        command = str(command)
+        command = command_text(command)
         reject_stdin_conflict(input, stdin)
         if text and encoding is None:
             encoding = "utf-8"

{hostctl-0.1.2 → hostctl-0.2.1}/src/hostctl/executor/winrm.py

@@ -9,6 +9,7 @@ import typing
 
 from ._common import (
     CaptureOutput,
+    command_text,
     CommandArgument,
     Executor,
     ExecutorCommand,
@@ -165,7 +166,7 @@ class WinRMExecutor(Executor[subprocess.CompletedProcess]):
             raise TypeError(f"unsupported WinRM executor option: {sorted(options)[0]}")
         if args:
             raise NotImplementedError("WinRMExecutor does not support native arguments")
-        command = str(command)
+        command = command_text(command)
         if timeout is not None:
             raise NotImplementedError(
                 "WinRMExecutor timeout is unsupported; configure transport timeouts"

{hostctl-0.1.2 → hostctl-0.2.1}/src/hostctl/host/__init__.py

@@ -1,6 +1,7 @@
 """Host contracts and built-in host implementations."""
 
 from ._common import (
+    Exec as Exec,
     Host as Host,
     HostConfig as HostConfig,
     HostInfo as HostInfo,
@@ -12,6 +13,7 @@ from ._common import (
     uri_host as uri_host,
     uri_hostname as uri_hostname,
 )
+from ._connection import ConnectionString as ConnectionString
 from ._ssh import ssh_providers as ssh_providers
 from ._winrm import winrm_providers as winrm_providers
 from ._local import LocalConfig as LocalConfig, LocalHost as LocalHost