devlaunch 0.0.12__tar.gz → 0.0.14__tar.gz

{devlaunch-0.0.12 → devlaunch-0.0.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devlaunch
-Version: 0.0.12
+Version: 0.0.14
 Summary: DevLaunch - A streamlined CLI for devpod workspaces
 Project-URL: Source, https://github.com/blooop/devlaunch
 Project-URL: Home, https://github.com/blooop/devlaunch
@@ -75,6 +75,18 @@ dl <user/repo> <cmd>             # Run workspace command (stop, code, etc.)
 dl <user/repo> -- <command>      # Run shell command in workspace
 ```
 
+### Commands that need a terminal
+
+`dl <ws> -- <command>` gives the command a terminal whenever `dl` itself has one,
+so interactive programs — a coding agent, `htop`, `git rebase -i`, a REPL — start
+and stay up instead of exiting immediately. Redirect the output and the terminal
+goes away again, so `dl <ws> -- ls > files.txt` stays free of escape sequences.
+
+This needs the ssh host alias `devpod up` writes to `~/.ssh/config`. If a
+workspace has none, `dl` says so and falls back to the plain `devpod ssh`
+transport, which has no terminal; `dl <ws> restart` republishes the alias. Set
+`DEVLAUNCH_NO_TTY=1` to force the fallback everywhere.
+
 ## aid: start a coding agent in a workspace
 
 `aid` is `dl` with a coding agent started for you:
@@ -209,13 +221,14 @@ than the filesystem has actually done.
 | `dl <user/repo> restart` | Stop and start (no rebuild) |
 | `dl <user/repo> recreate` | Recreate container |
 | `dl <user/repo> reset` | Clean slate (remove all, recreate) |
-| `dl <user/repo> -- <command>` | Run shell command in workspace |
+| `dl <user/repo> -- <command>` | Run shell command in workspace (with a terminal, when `dl` has one) |
 
 ## Options
 
 | Option | Description |
 |--------|-------------|
 | `--devcontainer <variant\|path>` | Use a non-default `devcontainer.json`. A bare name means `.devcontainer/<name>/devcontainer.json`. Stored with the workspace, so pass it once. |
+| `DEVLAUNCH_NO_TTY=1` | Never give a workspace command a terminal; always use the plain `devpod ssh` transport. |
 
 Projects with demanding devcontainers — several variants, compose sidecars, or a
 host-side `initializeCommand` that has to tell branch workspaces apart — are
@@ -233,8 +246,9 @@ whichever answers first, and hands it to the container as `GH_TOKEN`. That reach
 any image and any container user, unlike a bind-mount of `~/.config/gh`, and it
 works whether the host keeps its token in `hosts.yml` or in a keyring. The token
 is passed to devpod through a private file and through devpod's own environment,
-never on a command line, so it does not appear in `ps`. The container still needs
-`gh` installed for the login to be of any use. Check a workspace with:
+never on a command line, so it does not appear in `ps`. `dl` installs `gh` itself
+(see [Tools in every workspace](#tools-in-every-workspace)), so the login has
+something to be spent on whatever the image ships. Check a workspace with:
 
 ```bash
 dl <workspace> -- gh auth status
@@ -265,6 +279,36 @@ that is *already running* skips that step, and the token it was given at startup
 stays in place — including one it was given before you set
 `DEVLAUNCH_NO_GH_TOKEN`. Run `dl <workspace> restart` to replace it.
 
+## Tools in every workspace
+
+`gh` and `claude` are available in every workspace `dl` opens, in every kind of
+session — an interactive `dl <workspace>`, a one-shot `dl <workspace> -- <command>`,
+and `aid`. The repo's `devcontainer.json` does not have to provide them, and most
+do not: `dl` launches arbitrary repos, so a guarantee that depended on the image
+would not be a guarantee.
+
+They are installed with `pixi global` on `devpod up`, and put on the PATH of a
+login shell through whichever of `~/.bash_profile`, `~/.bash_login` or `~/.profile`
+bash actually reads — it sources only the first of those that exists, so an image
+shipping a `~/.bash_profile` never reads `~/.profile`. A workspace that already has both is left alone —
+the check runs first, so the cost after the first launch is one round-trip and no
+network. If `pixi` is missing from the image, `dl` installs that too.
+
+An install that fails costs the workspace its tools, not its launch: `dl` logs a
+warning and hands you the session anyway.
+
+```bash
+DEVLAUNCH_NO_TOOLS=1 dl someone/repo
+```
+
+| Variable | Description |
+|----------|-------------|
+| `DEVLAUNCH_NO_TOOLS=1` | Do not install `gh` or `claude` into workspaces |
+
+Attaching to a workspace that is *already running* skips `devpod up`, and so skips
+this too. A workspace started by something other than `dl` — or created before this
+existed — picks the tools up on its next `dl <workspace> restart`.
+
 ## Global Commands
 
 | Command | Description |

{devlaunch-0.0.12 → devlaunch-0.0.14}/README.md

@@ -53,6 +53,18 @@ dl <user/repo> <cmd>             # Run workspace command (stop, code, etc.)
 dl <user/repo> -- <command>      # Run shell command in workspace
 ```
 
+### Commands that need a terminal
+
+`dl <ws> -- <command>` gives the command a terminal whenever `dl` itself has one,
+so interactive programs — a coding agent, `htop`, `git rebase -i`, a REPL — start
+and stay up instead of exiting immediately. Redirect the output and the terminal
+goes away again, so `dl <ws> -- ls > files.txt` stays free of escape sequences.
+
+This needs the ssh host alias `devpod up` writes to `~/.ssh/config`. If a
+workspace has none, `dl` says so and falls back to the plain `devpod ssh`
+transport, which has no terminal; `dl <ws> restart` republishes the alias. Set
+`DEVLAUNCH_NO_TTY=1` to force the fallback everywhere.
+
 ## aid: start a coding agent in a workspace
 
 `aid` is `dl` with a coding agent started for you:
@@ -187,13 +199,14 @@ than the filesystem has actually done.
 | `dl <user/repo> restart` | Stop and start (no rebuild) |
 | `dl <user/repo> recreate` | Recreate container |
 | `dl <user/repo> reset` | Clean slate (remove all, recreate) |
-| `dl <user/repo> -- <command>` | Run shell command in workspace |
+| `dl <user/repo> -- <command>` | Run shell command in workspace (with a terminal, when `dl` has one) |
 
 ## Options
 
 | Option | Description |
 |--------|-------------|
 | `--devcontainer <variant\|path>` | Use a non-default `devcontainer.json`. A bare name means `.devcontainer/<name>/devcontainer.json`. Stored with the workspace, so pass it once. |
+| `DEVLAUNCH_NO_TTY=1` | Never give a workspace command a terminal; always use the plain `devpod ssh` transport. |
 
 Projects with demanding devcontainers — several variants, compose sidecars, or a
 host-side `initializeCommand` that has to tell branch workspaces apart — are
@@ -211,8 +224,9 @@ whichever answers first, and hands it to the container as `GH_TOKEN`. That reach
 any image and any container user, unlike a bind-mount of `~/.config/gh`, and it
 works whether the host keeps its token in `hosts.yml` or in a keyring. The token
 is passed to devpod through a private file and through devpod's own environment,
-never on a command line, so it does not appear in `ps`. The container still needs
-`gh` installed for the login to be of any use. Check a workspace with:
+never on a command line, so it does not appear in `ps`. `dl` installs `gh` itself
+(see [Tools in every workspace](#tools-in-every-workspace)), so the login has
+something to be spent on whatever the image ships. Check a workspace with:
 
 ```bash
 dl <workspace> -- gh auth status
@@ -243,6 +257,36 @@ that is *already running* skips that step, and the token it was given at startup
 stays in place — including one it was given before you set
 `DEVLAUNCH_NO_GH_TOKEN`. Run `dl <workspace> restart` to replace it.
 
+## Tools in every workspace
+
+`gh` and `claude` are available in every workspace `dl` opens, in every kind of
+session — an interactive `dl <workspace>`, a one-shot `dl <workspace> -- <command>`,
+and `aid`. The repo's `devcontainer.json` does not have to provide them, and most
+do not: `dl` launches arbitrary repos, so a guarantee that depended on the image
+would not be a guarantee.
+
+They are installed with `pixi global` on `devpod up`, and put on the PATH of a
+login shell through whichever of `~/.bash_profile`, `~/.bash_login` or `~/.profile`
+bash actually reads — it sources only the first of those that exists, so an image
+shipping a `~/.bash_profile` never reads `~/.profile`. A workspace that already has both is left alone —
+the check runs first, so the cost after the first launch is one round-trip and no
+network. If `pixi` is missing from the image, `dl` installs that too.
+
+An install that fails costs the workspace its tools, not its launch: `dl` logs a
+warning and hands you the session anyway.
+
+```bash
+DEVLAUNCH_NO_TOOLS=1 dl someone/repo
+```
+
+| Variable | Description |
+|----------|-------------|
+| `DEVLAUNCH_NO_TOOLS=1` | Do not install `gh` or `claude` into workspaces |
+
+Attaching to a workspace that is *already running* skips `devpod up`, and so skips
+this too. A workspace started by something other than `dl` — or created before this
+existed — picks the tools up on its next `dl <workspace> restart`.
+
 ## Global Commands
 
 | Command | Description |

{devlaunch-0.0.12 → devlaunch-0.0.14}/devlaunch/dl.py

@@ -33,7 +33,7 @@ from dataclasses import dataclass
 from urllib.parse import urlparse
 from urllib.request import url2pathname
 
-from . import devpod_ssh, gh_auth
+from . import devpod_ssh, gh_auth, tools, tty_session
 from .completion import install_completions
 from .workspace_id import TARGET_LENGTH, WorkspaceId, slug, source_workspace_id, validate_ref_name
 from .worktree.config import get_worktree_config
@@ -41,15 +41,27 @@ from .worktree.migration import migrate_cache
 from .worktree.workspace_clone import WorkspaceCloneManager
 
 
-class DevpodNotInstalled(Exception):
-    """The devpod binary dl shells out to is not on PATH.
+class MissingBinary(Exception):
+    """A binary dl shells out to is not on PATH.
 
     Deliberately not an OSError (FileNotFoundError is one) and not a
     RuntimeError: dl catches both broadly in a dozen places so that a flaky
     command degrades to an empty list or a "failed to prepare workspace"
     message. A missing binary reported through one of those handlers is
-    reported wrongly, so it travels as a type nothing between run_devpod and
-    main() catches, and main() is the only place that handles it.
+    reported wrongly, so it travels as a type nothing between the spawn helpers
+    and main() catches, and main() is the only place that handles it.
+    """
+
+
+class DevpodNotInstalled(MissingBinary):
+    """The devpod binary is not on PATH."""
+
+
+class SshNotInstalled(MissingBinary):
+    """OpenSSH is not on PATH, so no command can be given a terminal.
+
+    Its own type rather than DevpodNotInstalled: telling someone to install
+    devpod when devpod is present and working would send them the wrong way.
     """
 
 
@@ -62,6 +74,14 @@ DEVPOD_MISSING_MESSAGE = (
     "(pixi/conda installs of devlaunch include it; pip installs do not)."
 )
 
+# Same shape, and names the way out that does not need ssh at all: the devpod
+# transport still runs commands, it just cannot give them a terminal.
+SSH_MISSING_MESSAGE = (
+    "ssh not found on PATH: dl needs OpenSSH to give a workspace command a "
+    "terminal. Install it, or set DEVLAUNCH_NO_TTY=1 to run commands through "
+    "devpod instead (interactive programs will not work)."
+)
+
 # The shell's own "command not found" code, which says more than a bare 1 and
 # cannot be confused with a devpod command that ran and failed.
 DEVPOD_MISSING_EXIT_CODE = 127
@@ -1042,9 +1062,37 @@ def workspace_up(
     # `up` creates and starts workspaces, so any snapshot of `devpod list`
     # taken before it is now out of date.
     invalidate_workspace_list_cache()
+    # The tools a session always needs, for whatever repo this is: `up` is the
+    # one path that runs for every workspace dl opens and is already slow
+    # enough to absorb a round-trip. Only after a successful `up` -- there is
+    # no container to install into otherwise.
+    if result.returncode == 0 and identity:
+        tools.ensure_tools(identity, run_devpod)
     return result
 
 
+def run_ssh(args: List[str], env: Optional[Dict[str, str]] = None) -> subprocess.CompletedProcess:
+    """Run OpenSSH, dl's other way into a workspace.
+
+    Separate from run_devpod because it is a different binary with a different
+    failure mode, and because the pty transport has to be swappable in tests
+    without stubbing out every devpod call as well.
+
+    Takes the whole argv, `ssh` included, because tty_session composes a
+    complete command rather than a tail of flags -- unlike run_devpod, whose
+    callers each build up their own subcommand.
+
+    Security note: list form, not shell=True, so nothing in the payload is
+    interpreted by a host shell.
+    """
+    logging.debug("Running: %s", " ".join(args))
+    try:
+        # nosec B603 B607 - list form, not shell=True; no command injection risk
+        return subprocess.run(list(args), check=False, env=env)
+    except FileNotFoundError as e:
+        raise SshNotInstalled(SSH_MISSING_MESSAGE) from e
+
+
 def workspace_ssh(
     workspace: str,
     command: Optional[str] = None,
@@ -1052,6 +1100,17 @@ def workspace_ssh(
 ) -> int:
     """SSH into a workspace, optionally running a command.
 
+    A command runs through whichever of the two transports can give it what it
+    needs. devpod's --command never requests a pty, which is fine for `make
+    test` and fatal for anything interactive -- `claude` reads the pipe as a
+    non-interactive invocation and exits instead of starting a session. So when
+    dl is itself on a terminal, the command goes to OpenSSH through the host
+    alias devpod published, with -t (see tty_session). Otherwise, and when no
+    alias exists, it goes to devpod as before.
+
+    A bare attach is left on devpod: it already gets a pty, being the one case
+    devpod requests one for.
+
     Args:
         workspace: The workspace ID to SSH into
         command: Optional command to run (if None, starts interactive shell)
@@ -1060,19 +1119,34 @@ def workspace_ssh(
             if given a path that doesn't exist in the container, so never guess
             one from the workspace id.
     """
-    args = ["ssh", workspace]
+    # devpod runs --command under a non-login, non-interactive `bash -c`, which
+    # sources neither ~/.profile nor ~/.bashrc -- so PATH entries the image adds
+    # there (notably $HOME/.pixi/bin) are missing and the payload dies with
+    # "command not found". An interactive attach gets a login shell, so wrap
+    # here to give both paths the same PATH. dl launches arbitrary repos, so the
+    # parity has to come from the invocation rather than from any particular
+    # devcontainer.json.
+    #
+    # Built once and shared by both transports: two copies of this expression
+    # would be two chances for the transports to drift, which is the whole
+    # failure this function exists to have fixed.
+    payload = f"bash -lc {shlex.quote(command)}" if command else None
+
+    if payload is not None and tty_session.have_terminal():
+        if tty_session.devpod_host_configured(workspace):
+            return _ssh_with_terminal(workspace, payload, workdir)
+        logging.warning(
+            "No devpod ssh host entry for %s, so this command gets no terminal; "
+            "interactive programs may exit immediately. `dl %s restart` republishes it.",
+            workspace,
+            workspace,
+        )
 
+    args = ["ssh", workspace]
     if workdir:
         args.extend(["--workdir", workdir])
-    if command:
-        # devpod runs --command under a non-login, non-interactive `bash -c`,
-        # which sources neither ~/.profile nor ~/.bashrc -- so PATH entries the
-        # image adds there (notably $HOME/.pixi/bin) are missing and the payload
-        # dies with "command not found". An interactive attach gets a login
-        # shell, so wrap here to give both paths the same PATH. dl launches
-        # arbitrary repos, so the parity has to come from the invocation rather
-        # than from any particular devcontainer.json.
-        args.extend(["--command", f"bash -lc {shlex.quote(command)}"])
+    if payload is not None:
+        args.extend(["--command", payload])
 
     # Attaching to a running workspace skips workspace_up, so the gh login has
     # to be offered here too. Only the variable name lands in args; the token
@@ -1097,6 +1171,20 @@ def workspace_ssh(
             devpod_ssh.assert_never(unhandled)
 
 
+def _ssh_with_terminal(workspace: str, payload: str, workdir: Optional[str]) -> int:
+    """Run an already-wrapped payload under a pty via OpenSSH.
+
+    No devpod_ssh.SshOutcome here, and nothing to recover: OpenSSH exits with
+    the remote program's own status, which is the thing devpod loses by wrapping
+    its *ssh.ExitError three times before type-asserting on it. This transport
+    never had that bug, so it needs none of the machinery that works around it.
+    """
+    env_names, env = gh_auth.openssh_env_names_and_env()
+    args = tty_session.ssh_command_args(workspace, payload, send_env=env_names, workdir=workdir)
+    logging.info("SSH command: %s", " ".join(args))
+    return run_ssh(args, env=env).returncode
+
+
 def attach_workspace(workspace_id: str, shell_command: Optional[str] = None) -> int:
     """Hand the workspace to the user: name its prompt, then ssh in.
 
@@ -1299,7 +1387,7 @@ def main(argv: Optional[List[str]] = None) -> int:
     invalidate_workspace_list_cache()
     try:
         return _run_cli(argv)
-    except DevpodNotInstalled as e:
+    except MissingBinary as e:
         print(e, file=sys.stderr)
         return DEVPOD_MISSING_EXIT_CODE
 

{devlaunch-0.0.12 → devlaunch-0.0.14}/devlaunch/gh_auth.py

@@ -169,3 +169,17 @@ def ssh_args_and_env() -> Tuple[List[str], Optional[Dict[str, str]]]:
     if not token:
         return [], None
     return ["--send-env", TOKEN_VAR], {**os.environ, TOKEN_VAR: token}
+
+
+def openssh_env_names_and_env() -> Tuple[List[str], Optional[Dict[str, str]]]:
+    """The same forwarding, for the OpenSSH transport that carries a terminal.
+
+    Interactive payloads reach the workspace through `ssh` rather than `devpod
+    ssh` (see tty_session), which spells the same idea `-o SendEnv=NAME`. Only
+    the names are returned here; tty_session turns them into flags, and the
+    values travel in the environment for the same reason as above.
+    """
+    token = resolve_token()
+    if not token:
+        return [], None
+    return [TOKEN_VAR], {**os.environ, TOKEN_VAR: token}

devlaunch-0.0.14/devlaunch/tools.py

@@ -0,0 +1,219 @@
+"""Put the tools a session always needs into every workspace devlaunch opens.
+
+`gh` and `claude` are not optional extras for the way these workspaces get used:
+`dl` already forwards the host's GitHub login into every container, which is
+worth nothing when the container has no `gh` to spend it, and `aid` exists to
+run `claude` in there. Both currently arrive only when the repo's own
+devcontainer.json arranges them -- this repo does, through
+`.devcontainer/claude-code/`, which is why `claude` is present in its workspaces
+and `gh` (a project pixi dependency, reachable only as `pixi run gh`) is not.
+
+A guarantee that depends on the repo is not a guarantee. `dl` launches arbitrary
+repos, so the tools have to come from the invocation, the same argument
+gh_auth makes for the token and workspace_ssh's login shell makes for PATH.
+
+Installing them costs a devpod round-trip on `up`, which already runs for
+seconds, and nothing at all on the attach paths -- the script exits before doing
+any work when both tools are already there, and `up` is the only caller.
+
+Two consequences worth knowing:
+
+- A workspace that is already running when `dl` reaches it skips `up` entirely
+  (the fast-attach path), so it is not topped up. That covers workspaces started
+  by something other than `dl`, and ones created before this existed; both get
+  the tools on their next `dl <ws> restart` or `up`.
+- Provisioning is a convenience, so a failed install costs the workspace its
+  tools and not its launch: an install that fails is logged and the session
+  starts anyway. The exception is a devpod that has gone missing between `up`
+  and here, which dl treats as fatal everywhere else and which this does not
+  make an exception of.
+"""
+
+import logging
+import os
+import shlex
+from dataclasses import dataclass
+from typing import List, Optional, Sequence
+
+# Set this to opt a machine out of installing tools into workspaces.
+DISABLE_VAR = "DEVLAUNCH_NO_TOOLS"
+
+_FALSEY = ("", "0", "false", "no")
+
+# The claude package lives in a personal channel rather than conda-forge.
+BLOOOP_CHANNEL = "https://prefix.dev/blooop"
+
+# Which file a bash login shell will actually read. bash tries ~/.bash_profile,
+# ~/.bash_login and ~/.profile in that order and sources only the first that
+# exists, so appending to ~/.profile in an image that ships a ~/.bash_profile
+# writes to a file nothing reads.
+_PROFILE_RESOLUTION = "\n".join(
+    [
+        'if [ -f "$HOME/.bash_profile" ]; then PROFILE="$HOME/.bash_profile"',
+        'elif [ -f "$HOME/.bash_login" ]; then PROFILE="$HOME/.bash_login"',
+        'else PROFILE="$HOME/.profile"',
+        "fi",
+    ]
+)
+
+
+@dataclass(frozen=True)
+class Tool:
+    """A binary a session must be able to run, and the pixi package providing it.
+
+    `command` is what a shell has to find on PATH, which is not always the
+    package name -- `claude` ships in `claude-shim` -- so both are recorded
+    rather than one being derived from the other.
+    """
+
+    command: str
+    package: str
+    channel: Optional[str] = None
+
+    @property
+    def install_args(self) -> List[str]:
+        """The `pixi global install` arguments that provide this tool."""
+        if self.channel:
+            return ["--channel", self.channel, self.package]
+        return [self.package]
+
+
+REQUIRED_TOOLS: Sequence[Tool] = (
+    Tool(command="gh", package="gh"),
+    Tool(command="claude", package="claude-shim", channel=BLOOOP_CHANNEL),
+)
+
+
+def provisioning_disabled() -> bool:
+    """Whether the user opted this machine out of installing tools."""
+    return os.environ.get(DISABLE_VAR, "").strip().lower() not in _FALSEY
+
+
+def _install_line(tool: Tool) -> str:
+    args = " ".join(shlex.quote(arg) for arg in tool.install_args)
+    return (
+        f"if ! command -v {shlex.quote(tool.command)} >/dev/null 2>&1; then\n"
+        f'  echo "devlaunch: installing {tool.command}"\n'
+        f"  pixi global install {args} || failed=1\n"
+        f"fi"
+    )
+
+
+def provision_script(tools: Sequence[Tool] = REQUIRED_TOOLS) -> str:
+    """The shell script that makes `tools` available in a workspace.
+
+    Idempotent and cheap on the common path: every tool already on PATH is
+    skipped, so a workspace that has been provisioned before does nothing but
+    answer. It runs under a login shell (see ensure_tools), which is what puts
+    an earlier run's ~/.pixi/bin on PATH -- checked from a non-login shell every
+    tool would look missing and be reinstalled on every launch.
+
+    Exits 0 unless an install actually failed, so "nothing to do" and "all
+    installs worked" are the same answer to the caller.
+    """
+    all_present = " && ".join(
+        f"command -v {shlex.quote(tool.command)} >/dev/null 2>&1" for tool in tools
+    )
+    installs = "\n".join(_install_line(tool) for tool in tools)
+    # The trampoline pixi writes into ~/.pixi/bin does not work for packages
+    # that ship a shell script, which is why the env's own bin directory is
+    # added too -- the same workaround .devcontainer/claude-code/install.sh
+    # carries, for the same package.
+    profile_lines = "\n".join(
+        [
+            # bash reads exactly one of these on login, in this order, and
+            # stops at the first that exists -- so an image shipping a
+            # ~/.bash_profile means ~/.profile is never sourced at all. Writing
+            # to the wrong one leaves the tools installed and unreachable, and
+            # (since the check above is `command -v`) reinstalled from scratch
+            # on every single launch.
+            _PROFILE_RESOLUTION,
+            'grep -q "\\.pixi/bin" "$PROFILE" 2>/dev/null || '
+            'echo \'export PATH="$HOME/.pixi/bin:$PATH"\' >> "$PROFILE" || failed=1',
+            'grep -q "pixi/envs/claude-shim" "$PROFILE" 2>/dev/null || '
+            'echo \'[ -d "$HOME/.pixi/envs/claude-shim/bin" ] && '
+            'export PATH="$HOME/.pixi/envs/claude-shim/bin:$PATH"\' >> "$PROFILE" || failed=1',
+        ]
+    )
+    return "\n".join(
+        [
+            "set -u",
+            # Everything this script prints is progress, and progress is not
+            # the answer to anything: `dl <ws> -- cmd > file` on a workspace
+            # that needs provisioning must put the command's output in the
+            # file and nothing else. pixi writes to stdout too, so redirect
+            # once here rather than per line.
+            "exec >&2",
+            "failed=0",
+            # Everything already there: leave without touching pixi, the
+            # profile, or the network. Every launch after the first takes this.
+            f"if {all_present}; then exit 0; fi",
+            _pixi_bootstrap(),
+            installs,
+            profile_lines,
+            'exit "$failed"',
+        ]
+    )
+
+
+def _pixi_bootstrap() -> str:
+    """Install pixi if the image has none, since every tool here comes from it.
+
+    An arbitrary repo's container is not required to carry pixi, and without it
+    the guarantee this module makes would hold only for images that happen to
+    have it. Failure is left to the install steps to report: they will fail for
+    a reason the log can name.
+    """
+    return "\n".join(
+        [
+            "if ! command -v pixi >/dev/null 2>&1; then",
+            '  echo "devlaunch: installing pixi"',
+            "  curl -fsSL https://pixi.sh/install.sh | bash >/dev/null 2>&1 || true",
+            '  export PATH="$HOME/.pixi/bin:$PATH"',
+            "fi",
+        ]
+    )
+
+
+def ensure_tools(workspace: str, runner, tools: Sequence[Tool] = REQUIRED_TOOLS) -> bool:
+    """Make `tools` available in `workspace`. Returns whether they now are.
+
+    `runner` is dl.run_devpod, passed in rather than imported to keep this
+    module off dl's import cycle and testable without a devpod.
+
+    The payload goes through `bash -lc` for the same reason workspace_ssh wraps
+    its own: devpod runs --command under a shell that sources no profile, so
+    PATH would be missing the pixi directory this module itself installs into.
+
+    Output is not captured. A cold install downloads pixi and two packages and
+    takes tens of seconds, which with nothing on the terminal reads as a hung
+    `dl`; the script's own progress lines are the answer to that, and they are
+    worth nothing in a buffer. A workspace that needs no work stays silent
+    because the script prints nothing on that path.
+
+    Not every failure is swallowed: DevpodNotInstalled is deliberately not an
+    OSError (see dl.DevpodNotInstalled) so that it is never mistaken for a
+    failure of the thing being attempted, and it keeps that meaning here.
+    """
+    if provisioning_disabled():
+        logging.debug("%s is set; not installing tools into %s", DISABLE_VAR, workspace)
+        return False
+
+    script = provision_script(tools)
+    command = f"bash -lc {shlex.quote(script)}"
+    try:
+        result = runner(["ssh", workspace, "--command", command])
+    except OSError as e:
+        logging.debug("Could not install tools into %s: %s", workspace, e)
+        return False
+
+    if result.returncode != 0:
+        # Named, not raised: the workspace is up and the user asked for a
+        # session, not for an install.
+        logging.warning(
+            "Could not install %s into %s; the session will start without them.",
+            " and ".join(tool.command for tool in tools),
+            workspace,
+        )
+        return False
+    return True

devlaunch-0.0.14/devlaunch/tty_session.py

@@ -0,0 +1,144 @@
+"""Carry a terminal into the workspace for commands that need one.
+
+`devpod ssh --command` never asks its ssh session for a pty. It requests one
+only for a bare interactive attach, so anything started through --command runs
+with stdin, stdout and stderr on pipes and TERM=dumb, and there is no devpod
+flag that forces the matter.
+
+One-shot commands don't care. Interactive ones do, and they don't fail in a way
+that looks like a missing terminal: `claude` reads the pipe as "invoked
+non-interactively", switches to --print mode, and exits -- so `aid <repo>`
+returned to the shell instead of leaving a session behind, and `dl <ws> --
+claude 'fix it'` printed one answer and stopped.
+
+devpod already publishes the way out. Every `devpod up` writes an ssh host alias
+`<workspace>.devpod` into ~/.ssh/config whose ProxyCommand tunnels through
+`devpod ssh --stdio`, so OpenSSH can open the same session devpod would and, with
+-t, ask it for a pty. That gives the payload a real terminal, and gives the user
+OpenSSH's terminal handling -- raw mode, window size, SIGWINCH -- which is what a
+TUI needs and what a hand-rolled pty proxy in dl would have to reimplement.
+
+This module only decides and composes; dl.workspace_ssh does the spawning. The
+decision is deliberately the one ssh itself makes: use a terminal when there is
+a terminal to use. A redirected `dl <ws> -- ls > out.txt` keeps the old
+transport and so keeps its output free of escape sequences.
+"""
+
+from __future__ import annotations
+
+import os
+import pathlib
+import shlex
+import sys
+from typing import Any, Iterable, List, Optional
+
+# Where devpod writes its host aliases. A module-level path rather than a call
+# to Path.home() per lookup so tests can point it at a fixture.
+SSH_CONFIG_PATH = pathlib.Path.home() / ".ssh" / "config"
+
+# devpod names each alias after the workspace, and brackets the block with
+# markers it recognises again on the next `up`.
+HOST_SUFFIX = ".devpod"
+MARKER_PREFIX = "# DevPod Start "
+
+# Set this to keep every command on the devpod transport, whatever the terminal
+# says. An escape hatch for a machine where the ssh alias is stale or the
+# tunnel misbehaves, matching DEVLAUNCH_NO_GH_TOKEN in spirit.
+DISABLE_VAR = "DEVLAUNCH_NO_TTY"
+
+_FALSEY = ("", "0", "false", "no")
+
+
+def disabled() -> bool:
+    """Whether the user opted this machine out of the pty transport."""
+    return os.environ.get(DISABLE_VAR, "").strip().lower() not in _FALSEY
+
+
+def host_alias(workspace_id: str) -> str:
+    """The ssh host name devpod publishes for a workspace."""
+    return f"{workspace_id}{HOST_SUFFIX}"
+
+
+def have_terminal(stdin: Any = None, stdout: Any = None) -> bool:
+    """Whether dl was run from a terminal it can hand to the workspace.
+
+    Both directions have to be a terminal: a pty on stdout with stdin redirected
+    would give a TUI a screen it cannot receive keystrokes on, and a pty on
+    stdin with stdout redirected would fill the redirect with escape sequences.
+
+    Anything that isn't a real stream -- pytest's capture object, a closed file
+    -- counts as no terminal, because that is what it behaves like.
+    """
+    if disabled():
+        return False
+    streams = (
+        sys.stdin if stdin is None else stdin,
+        sys.stdout if stdout is None else stdout,
+    )
+    for stream in streams:
+        try:
+            if not stream.isatty():
+                return False
+        except (AttributeError, ValueError, OSError):
+            return False
+    return True
+
+
+def devpod_host_configured(workspace_id: str, config_path: Optional[pathlib.Path] = None) -> bool:
+    """Whether devpod has published an ssh alias for this workspace.
+
+    Matched on devpod's own start marker as a whole line, not as a substring:
+    workspace ids share prefixes by construction (`devlaunch-main-abcdefgh` and
+    `devlaunch-main-ijklmnop`), so a substring test would route a command at a
+    host alias belonging to a different container.
+    """
+    path = SSH_CONFIG_PATH if config_path is None else config_path
+    try:
+        text = pathlib.Path(path).read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        # No config, no permission, no alias -- all mean "fall back", never
+        # "fail the launch".
+        return False
+    marker = f"{MARKER_PREFIX}{host_alias(workspace_id)}"
+    return any(line.strip() == marker for line in text.splitlines())
+
+
+def ssh_command_args(
+    workspace_id: str,
+    command: str,
+    send_env: Iterable[str] = (),
+    workdir: Optional[str] = None,
+) -> List[str]:
+    """Build the OpenSSH invocation that runs `command` under a pty.
+
+    -t is what the whole module exists for: without it ssh runs a command with
+    no terminal, which is the situation being escaped.
+
+    send_env names variables only. OpenSSH reads their values from its own
+    environment, so a forwarded token never appears in argv where `ps` would
+    show it to every other user on the host -- the same discipline gh_auth
+    applies to the devpod transport.
+
+    Raises:
+        ValueError: if the workspace id would reach ssh as an option.
+    """
+    # The alias goes in positionally, and ssh has no reliable `--`, so an id
+    # beginning with a dash would be read as a flag -- and `-o ProxyCommand=...`
+    # is arbitrary command execution on the host. devpod's own ids cannot look
+    # like that (workspace_id validates a leading word character) and neither
+    # can the ~/.ssh/config entry this is gated on, so reaching here means
+    # something upstream is already wrong: refuse rather than hand it to ssh.
+    if workspace_id.startswith("-"):
+        raise ValueError(
+            f"refusing to ssh to a workspace id that looks like an option: {workspace_id!r}"
+        )
+    args = ["ssh", "-t"]
+    for name in send_env:
+        args.extend(["-o", f"SendEnv={name}"])
+    args.append(host_alias(workspace_id))
+    # ssh has no --workdir, so a directory has to travel inside the command.
+    payload = command
+    if workdir:
+        payload = f"cd {shlex.quote(workdir)} && {command}"
+    args.append(payload)
+    return args

{devlaunch-0.0.12 → devlaunch-0.0.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "devlaunch"
-version = "0.0.12"
+version = "0.0.14"
 authors = [{ name = "Austin Gregg-Smith", email = "blooop@gmail.com" }]
 description = "DevLaunch - A streamlined CLI for devpod workspaces"
 readme = "README.md"
@@ -22,7 +22,12 @@ platforms = ["linux-64"]
 [tool.pixi.dependencies]
 python = ">=3.10"
 shellcheck = ">=0.10.0,<0.11"
-devpod = ">=0.8.0,<0.9"
+# Match the devpod `dl` is actually installed alongside (pixi global ships
+# 0.26.x). The pin used to be <0.9, which quietly meant the suite exercised a
+# devpod five years of releases behind the one users run -- and it hid this
+# module's bug outright: 0.8 requests a pty for `devpod ssh --command` whenever
+# stdout is a terminal, and 0.26 never does. See devlaunch/tty_session.py.
+devpod = ">=0.26.1,<0.27"
 gh = ">=2.83.0,<3.0"
 
 [tool.pixi.feature.py310.dependencies]