hostctl 0.1.0__tar.gz → 0.2.0__tar.gz

{hostctl-0.1.0 → hostctl-0.2.0}/CHANGELOG.md

@@ -7,6 +7,92 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [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
+timed out on the Windows/Python 3.14 runner, so nothing reached PyPI. There is
+no 0.1.1 release; its fix is included here.
+
+### Added
+
+- `uri_hostname(parsed)` returns the host as it was written in a URI, rather
+  than the case-folded spelling `urlsplit().hostname` produces. Use it in
+  `_from_parsed_uri` wherever a host is stored; presence checks can keep using
+  `.hostname`, since emptiness does not depend on case.
+
+### Changed
+
+- A config built from a URI now stores the hostname as typed, so
+  `HostConfig("ssh://nasA")` keeps `nasA` in `.host`, in `connection_uri`, and
+  in the `HostInfo.hostname` a system host reports without connecting. It
+  previously stored `urlsplit`'s lowercased form, which meant the library
+  echoed a spelling the operator never wrote and left downstream code to
+  recover the original from the URI itself.
+
+  Consequently `.host` is the spelling that was given, not a canonical form:
+  `HostConfig("ssh://nasA")` and `HostConfig("ssh://nasa")` no longer compare
+  equal, so code using a config or its host as a dict key or for
+  deduplication should casefold explicitly. Resolution is unaffected — DNS,
+  SSH, and WinRM all treat the two spellings as one name.
+
+### Fixed
+
+- `redact_uri()` no longer case-folds the hostname. Only the branch that
+  rebuilt the authority — the one taken when a password was present — adopted
+  `urlsplit`'s lowercased `hostname`, so `nasA` rendered as `nasa` with a
+  credential and as `nasA` without one. The same host now renders one way
+  whichever branch runs, and log records stay greppable by the name the
+  operator typed. Redaction removes a credential; normalizing a host is a
+  separate concern and is left to the transport that resolves it.
+- The spawn conformance test no longer fails on a slow runner. It waited 10s
+  for a real `powershell.exe -NoProfile` to start, exit, and be reaped, which
+  a cold Windows CI runner can exceed. The wait is a hang guard rather than a
+  performance assertion, so it is now 60s. Test-only; no library change.
+
 ## [0.1.0] - 2026-07-27
 
 First release. Alpha: the public surface is deliberately small (66 exported
@@ -144,5 +230,7 @@ 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.0...HEAD
+[Unreleased]: https://github.com/jose-pr/hostctl/compare/v0.2.0...HEAD
+[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.0 → hostctl-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hostctl
-Version: 0.1.0
+Version: 0.2.0
 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/
@@ -172,6 +172,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.0 → hostctl-0.2.0}/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.0 → hostctl-0.2.0}/docs/api/reference.md

@@ -39,6 +39,7 @@ without a deprecation cycle.
 
 ## Executors and processes
 
+::: hostctl.Exec
 ::: hostctl.Executor
 ::: hostctl.ExecutionOptions
 ::: hostctl.LocalExecutor
@@ -84,6 +85,7 @@ without a deprecation cycle.
 ::: hostctl.strict_uri_credentials
 ::: hostctl.strict_uri_query
 ::: hostctl.uri_host
+::: hostctl.uri_hostname
 
 ## Composing transports
 

{hostctl-0.1.0 → hostctl-0.2.0}/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.0 → hostctl-0.2.0}/docs/guide/transfer.md

@@ -116,11 +116,8 @@ with ProgressReader(source_path.open("rb"), report, total=size) as reader:
   though their read sides stream.
 
 Three gaps are tracked as `pathlib_next` requests rather than hostctl features,
-because each one lives inside machinery hostctl deliberately does not fork.
-Drafts are kept in the repository under `.agents/upstream/`:
+because each one lives inside machinery hostctl deliberately does not fork:
 
-| Request | Draft |
-| --- | --- |
-| Byte-progress hook in `BinaryOpen.copy` / `Path.copy()` | `pathlib_next-copy-progress-hook.md` |
-| Symlink handling in `PathSyncer` (plus its unreachable `ignore_error`) | `pathlib_next-symlink-sync.md` |
-| Optional backend-native checksum protocol | `pathlib_next-backend-checksum-protocol.md` |
+- Byte-progress hook in `BinaryOpen.copy` / `Path.copy()`
+- Symlink handling in `PathSyncer` (plus its unreachable `ignore_error`)
+- Optional backend-native checksum protocol

{hostctl-0.1.0 → hostctl-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hostctl"
-version = "0.1.0"
+version = "0.2.0"
 authors = [{ name = "Jose A." }]
 description = "Run commands and access files on a host, local or remote, protocol-agnostic"
 readme = "README.md"

{hostctl-0.1.0 → hostctl-0.2.0}/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.0 → hostctl-0.2.0}/src/hostctl/__init__.py

@@ -34,6 +34,7 @@ from .executor import (
 from .host import (
     ContainerConfig as ContainerConfig,
     ContainerHost as ContainerHost,
+    Exec as Exec,
     Host as Host,
     HostConfig as HostConfig,
     HostInfo as HostInfo,
@@ -46,6 +47,7 @@ from .host import (
     strict_uri_credentials as strict_uri_credentials,
     strict_uri_query as strict_uri_query,
     uri_host as uri_host,
+    uri_hostname as uri_hostname,
     winrm_providers as winrm_providers,
     QemuConfig as QemuConfig,
     QemuHost as QemuHost,
@@ -125,6 +127,7 @@ __all__ = [
     "strict_uri_credentials",
     "strict_uri_query",
     "uri_host",
+    "uri_hostname",
     "winrm_providers",
     "SshConfig",
     "WinRMConfig",
@@ -144,6 +147,7 @@ __all__ = [
     "IosConfig",
     "IosHost",
     # Executors and processes
+    "Exec",
     "Executor",
     "ExecutionOptions",
     "ExecutorCapability",

{hostctl-0.1.0 → hostctl-0.2.0}/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.0 → hostctl-0.2.0}/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,
@@ -10,6 +11,7 @@ from ._common import (
     strict_uri_credentials as strict_uri_credentials,
     strict_uri_query as strict_uri_query,
     uri_host as uri_host,
+    uri_hostname as uri_hostname,
 )
 from ._ssh import ssh_providers as ssh_providers
 from ._winrm import winrm_providers as winrm_providers

{hostctl-0.1.0 → hostctl-0.2.0}/src/hostctl/host/_common.py

@@ -35,30 +35,81 @@ if _ty.TYPE_CHECKING:
     from ..process import Process, TerminalRequest
     from ..shell import Shell, ShellFlavour
 
-Command = _ty.Union[str, PathLike, _ty.Sequence[object]]
+#: One argv value. Everything reaching a transport is text, so a program or
+#: argument may be spelled as a string, bytes, or a path object
+#: interchangeably -- the spelling records how the caller held the value, not
+#: what crosses the wire.
+ExecValue = _ty.Union[str, bytes, _PurePath, _Pathname]
+
+
+@_dc.dataclass(frozen=True)
+class Exec:
+    """One command executed directly, with no shell layer.
+
+    ``Exec(program, *args)`` names a program and its argv. The program may be
+    an absolute path or a bare name the target resolves through ``PATH``; a
+    bare name has no other spelling, since a plain string is always shell text.
+
+    This is the explicit marker for direct execution. A path used anywhere
+    else is an ordinary value that stringifies, so several commands can be
+    written without one of them silently becoming an executable::
+
+        host.run(Exec("/bin/ls", "-l"))       # one direct command
+        host.run(Exec("ls", "-l"))            # PATH-resolved, no shell
+        host.run(Exec("/bin/a"), Exec("/bin/b"))   # two direct commands
+        host.run(PurePosixPath("/bin/a"), PurePosixPath("/bin/b"))
+                                              # two ordinary shell commands
+
+    Arguments are argv values, never nested commands: a list or tuple raises
+    ``TypeError`` rather than blurring argv and shell semantics.
+
+    A deliberately non-iterable container. `ShellFlavour.command_text`
+    dispatches structured commands on ``Iterable``, so an iterable marker
+    would be quoted into an argv string instead of taking the direct branch.
+    """
+
+    program: ExecValue
+    args: _ty.Tuple[ExecValue, ...]
+
+    def __init__(self, program: ExecValue, *args: ExecValue) -> None:
+        if not isinstance(program, (str, bytes, _PurePath, _Pathname)):
+            raise TypeError("Exec program must be a str, bytes, or path value")
+        for value in args:
+            if isinstance(value, (tuple, list)):
+                raise TypeError("direct command arguments must be scalar values")
+            if not isinstance(value, (str, bytes, _PurePath, _Pathname)):
+                raise TypeError(
+                    "direct command arguments must be str, bytes, or path values"
+                )
+        object.__setattr__(self, "program", program)
+        object.__setattr__(self, "args", tuple(args))
+
+
+Command = _ty.Union[str, PathLike, Exec, _ty.Sequence[object]]
 
 
 def starts_direct_command(
     cmds: _ty.Sequence[Command],
-) -> _ty.Optional[_ty.Tuple[_ty.Union[_PurePath, _Pathname], _ty.Tuple[object, ...]]]:
-    """Split a path-led call into one executable and its argv arguments.
+) -> _ty.Optional[_ty.Tuple[ExecValue, _ty.Tuple[object, ...]]]:
+    """Split an :class:`Exec` call into one executable and its argv arguments.
 
-    A leading path object is the explicit direct-execution marker.  Every
-    trailing value is an argv scalar; nested command sequences are rejected so
-    callers cannot accidentally mix shell-command and argv semantics.
+    Returns ``None`` unless the call is exactly one `Exec`. Direct execution
+    replaces the whole command list rather than joining with anything, so an
+    `Exec` alongside other commands is rejected: there is no shell to join
+    them with, and silently running only one would lose the rest.
     """
-    if not cmds or not isinstance(cmds[0], (_PurePath, _Pathname)):
+    if not cmds:
         return None
-    command = cmds[0]
-    argv = tuple(cmds[1:])
-    for value in argv:
-        if isinstance(value, (tuple, list)):
-            raise TypeError("direct command arguments must be scalar values")
-        if not isinstance(value, (str, bytes, _PurePath, _Pathname)):
-            raise TypeError(
-                "direct command arguments must be str, bytes, or path values"
-            )
-    return command, argv
+    marked = [value for value in cmds if isinstance(value, Exec)]
+    if not marked:
+        return None
+    if len(cmds) > 1:
+        raise TypeError(
+            "a direct Exec command cannot be combined with other commands; "
+            "run it in its own call"
+        )
+    command = marked[0]
+    return command.program, command.args
 
 
 @_dc.dataclass(frozen=True)
@@ -160,9 +211,37 @@ def _reject_authority_control_characters(parsed: _SplitResult) -> None:
         )
 
 
+def uri_hostname(parsed: _SplitResult) -> str:
+    """The host as it was written, not as `urlsplit` case-folded it.
+
+    `urlsplit().hostname` is lowercased by design -- DNS is case-insensitive,
+    so folding is right for *resolution*. It is wrong for text a caller will
+    see again. A config built from a URI stores this value and renders it back
+    through `connection_uri`, so reading `.hostname` there would make the
+    library echo a spelling the operator never typed, and `nasA` would reach
+    logs and `HostInfo` as `nasa`.
+
+    Use this in `_from_parsed_uri` wherever a host is stored. Presence checks
+    (`if not parsed.hostname`) can keep using `.hostname` -- emptiness does not
+    depend on case. Resolution is unaffected either way: DNS, SSH, and WinRM
+    all treat the two spellings as one name.
+
+    Returns `""` for a URI with no host, matching `hostname or ""`.
+
+    `hostname` is a case-folded substring of the authority (after any
+    userinfo), so locating it recovers the original text.
+    """
+    hostname = parsed.hostname or ""
+    authority = parsed.netloc.rpartition("@")[2]
+    index = authority.casefold().find(hostname)
+    if index < 0:
+        return hostname
+    return authority[index : index + len(hostname)]
+
+
 def _rebuild_authority(parsed: _SplitResult, password: _ty.Optional[str]) -> str:
     """Rebuild a URI authority with `password` in place of the original."""
-    host = uri_host(parsed.hostname or "")
+    host = uri_host(uri_hostname(parsed))
     if parsed.port is not None:
         host = f"{host}:{parsed.port}"
     if not parsed.username:

{hostctl-0.1.0 → hostctl-0.2.0}/src/hostctl/host/_ssh.py

@@ -40,6 +40,7 @@ from ._common import (
     strict_uri_credentials,
     strict_uri_query,
     uri_host,
+    uri_hostname,
     reject_stdin_conflict,
 )
 from ..shell import (
@@ -147,7 +148,7 @@ class SshConfig(HostConfig, schemes=("ssh",)):
         if not parsed.hostname or parsed.path not in ("", "/"):
             raise ValueError("SSH URI requires a host and no path")
         return cls(
-            host=parsed.hostname,
+            host=uri_hostname(parsed),
             port=parsed.port or 22,
             username=unquote(parsed.username or "") or "root",
             password=typing.cast(typing.Optional[str], credentials.get("password")),

{hostctl-0.1.0 → hostctl-0.2.0}/src/hostctl/host/_winrm.py

@@ -50,6 +50,7 @@ from ._common import (
     strict_uri_credentials,
     strict_uri_query,
     uri_host,
+    uri_hostname,
 )
 from ..shell import POWERSHELL, ShellFlavour
 
@@ -155,7 +156,7 @@ class WinRMConfig(HostConfig, schemes=("winrm", "winrms")):
         if not parsed.username:
             raise ValueError("WinRM URI requires a username")
         return cls(
-            host=parsed.hostname,
+            host=uri_hostname(parsed),
             username=unquote(parsed.username),
             password=typing.cast(typing.Optional[str], credentials.get("password")),
             port=parsed.port,

{hostctl-0.1.0 → hostctl-0.2.0}/src/hostctl/host/qemu.py

@@ -48,6 +48,7 @@ from ._common import (
     strict_uri_credentials,
     strict_uri_query,
     uri_host,
+    uri_hostname,
 )
 from ._ssh import SshConfig, _SshTransport
 
@@ -222,7 +223,7 @@ class QemuConfig(HostConfig, schemes=("qemu+libvirt", "qga+unix", "qga+ssh")):
         if not parsed.hostname or not parsed.username or not parsed.path.strip("/"):
             raise ValueError("SSH QGA URI requires user, host, and domain")
         ssh = SshConfig(
-            parsed.hostname,
+            uri_hostname(parsed),
             port=parsed.port or 22,
             username=unquote(parsed.username),
             password=typing.cast(typing.Optional[str], credentials.get("password")),