devlaunch 0.0.11__tar.gz → 0.0.12__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devlaunch
-Version: 0.0.11
+Version: 0.0.12
 Summary: DevLaunch - A streamlined CLI for devpod workspaces
 Project-URL: Source, https://github.com/blooop/devlaunch
 Project-URL: Home, https://github.com/blooop/devlaunch

devlaunch-0.0.12/devlaunch/devpod_ssh.py

@@ -0,0 +1,143 @@
+"""How a `devpod ssh` session ended, recovered from what devpod reports.
+
+devpod means to pass a remote process's exit status through. Its top-level error
+handler does:
+
+    if sshExitErr, ok := err.(*ssh.ExitError); ok {
+        os.Exit(sshExitErr.ExitStatus())
+    }
+
+But by the time the error reaches there it has been wrapped three times —
+`ssh session: %w` in cmd/machine/ssh.go, then "run in container", then "tunnel to
+container" — and a bare type assertion does not see through `%w`. So every
+nonzero remote exit misses that branch and lands on devpod's generic failure
+path instead, which prints
+
+    error Try using the --debug flag to see a more verbose output    root.go:106
+    fatal tunnel to container: run in container: ssh session: Process exited with status 130
+
+and exits 1.
+
+Nothing has gone wrong in that example. A login shell exits with the status of
+its last command, so a single Ctrl-C before typing `exit` is enough to make a
+perfectly ordinary session end 130. The session ran and it ended; devpod just has
+no way left to say so.
+
+Both of those lines are Error/Fatal level, which loft-sh/log sends to stderr
+(Info-level progress goes to stdout, so reading stderr does not hold back the
+"waiting for workspace" chatter). That makes the status recoverable: read
+devpod's stderr, take the status out of the message it buried it in, and hold
+back the two lines that only exist because devpod could not report it properly.
+
+The distinction the rest of devlaunch needs is which process the resulting number
+came from, so it is a type rather than a bare int — see SshOutcome.
+"""
+
+import re
+from dataclasses import dataclass
+from typing import Iterable, NoReturn, Optional, TextIO
+
+# devpod prints this immediately before the fatal it belongs to, so it has to be
+# held for one line to see which fatal that is.
+DEBUG_HINT = "Try using the --debug flag to see a more verbose output"
+
+# The status golang.org/x/crypto/ssh formatted into an *ssh.ExitError:
+# "Process exited with status 130", optionally " from signal SIGINT" and
+# ". Reason was: ...". Anchored on devpod's "fatal" tag as well so a remote
+# program printing the same sentence on its own stderr (which reaches us only
+# when there is no pty) cannot be mistaken for devpod's report.
+#
+# No \b before "fatal": devpod colours the tag, and the escape it emits ends in
+# "m", so there is no word boundary in front of it.
+REMOTE_EXIT_RE = re.compile(r"fatal\b.*\bssh session: Process exited with status (\d+)")
+
+
+@dataclass(frozen=True)
+class RemoteExit:
+    """devpod ran the remote program, and it exited with `status`.
+
+    Not a devlaunch failure, whatever `status` is: the shell or command the user
+    asked for ran to completion. `status` belongs to that program.
+    """
+
+    status: int
+
+
+@dataclass(frozen=True)
+class DevpodFailed:
+    """devpod never ran the remote program, or lost it partway.
+
+    `exit_code` is devpod's own. devpod has already written its diagnostics to
+    stderr by the time this is constructed, so it carries no message of its own —
+    there is nothing devlaunch knows that the user has not already been told.
+    """
+
+    exit_code: int
+
+
+SshOutcome = RemoteExit | DevpodFailed
+
+
+def assert_never(value: NoReturn) -> NoReturn:
+    """Fail loudly on an SshOutcome arm nobody handled.
+
+    A runtime backstop, not a compile-time one: `ty`, the checker this project
+    runs in CI, does not currently reject a `match` that drops an arm. It is
+    still worth having, because a `match` with no fallthrough returns None, and
+    `main` returning None makes `dl` exit 0 — a new outcome would otherwise go
+    out as success.
+
+    Stands in for typing.assert_never, which needs 3.11; this project is 3.10+.
+    """
+    raise AssertionError(f"unhandled outcome: {value!r}")
+
+
+def filter_devpod_stderr(lines: Iterable[str], out: TextIO) -> Optional[int]:
+    """Forward devpod's stderr, holding back its report of a remote exit status.
+
+    Returns that status if devpod reported one. Everything else is passed through
+    verbatim and unbuffered, so a genuine devpod failure still reads exactly as
+    it does today — including the --debug hint, which is released ahead of the
+    fatal it precedes rather than after it.
+    """
+    remote_status: Optional[int] = None
+    held_hint: Optional[str] = None
+
+    for line in lines:
+        match = REMOTE_EXIT_RE.search(line)
+        if match:
+            remote_status = int(match.group(1))
+            # The hint introduced this fatal, so it goes with it.
+            held_hint = None
+            continue
+        if DEBUG_HINT in line:
+            held_hint = line
+            continue
+        if held_hint is not None:
+            out.write(held_hint)
+            held_hint = None
+        out.write(line)
+        out.flush()
+
+    if held_hint is not None:
+        out.write(held_hint)
+        out.flush()
+
+    return remote_status
+
+
+def interpret(devpod_exit_code: int, remote_status: Optional[int]) -> SshOutcome:
+    """Decide what a finished `devpod ssh` actually reported.
+
+    A recovered remote status wins over devpod's own exit code, because devpod
+    reports 1 alongside it regardless of what the remote program returned.
+    """
+    if remote_status is not None:
+        return RemoteExit(remote_status)
+    if devpod_exit_code == 0:
+        return RemoteExit(0)
+    # No status to recover. Either devpod really did fail, or a future devpod
+    # unwraps the error properly and exits with the remote status itself — in
+    # which case this is still the right number to pass on, and devpod stayed
+    # quiet, so nothing spurious is printed either way.
+    return DevpodFailed(devpod_exit_code)

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

@@ -33,7 +33,7 @@ from dataclasses import dataclass
 from urllib.parse import urlparse
 from urllib.request import url2pathname
 
-from . import gh_auth
+from . import devpod_ssh, gh_auth
 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
@@ -832,6 +832,38 @@ def run_devpod(
         raise DevpodNotInstalled(DEVPOD_MISSING_MESSAGE) from e
 
 
+def run_devpod_session(
+    args: List[str], env: Optional[Dict[str, str]] = None
+) -> devpod_ssh.SshOutcome:
+    """Run a devpod command that hands its stdin/stdout to a terminal session.
+
+    stdin and stdout are inherited untouched — devpod puts the real terminal into
+    raw mode through them, and requests a pty on that basis. Only stderr is read,
+    which under a pty carries devpod's own warnings and errors and nothing else,
+    so that devpod's report of how the session ended can be interpreted rather
+    than dumped on the user. See devpod_ssh for why that is necessary.
+    """
+    cmd = ["devpod"] + args
+    logging.debug("Running: %s", " ".join(cmd))
+    # nosec B603 - using list form, not shell=True; no command injection risk
+    with subprocess.Popen(
+        cmd,
+        stderr=subprocess.PIPE,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        env=env,
+    ) as proc:
+        # proc.stderr is a pipe because PIPE was asked for, but Popen's type
+        # cannot express that, so the narrowing happens here rather than by
+        # widening filter_devpod_stderr to a None it would have no answer for.
+        pipe = proc.stderr
+        remote_status = (
+            devpod_ssh.filter_devpod_stderr(pipe, sys.stderr) if pipe is not None else None
+        )
+    return devpod_ssh.interpret(proc.returncode, remote_status)
+
+
 # The memoized `devpod list` snapshot. A dict rather than a module-level
 # Optional so the accessors below need no `global`, and so "nothing read yet"
 # (no key at all) stays distinguishable from "devpod has no workspaces" (an
@@ -1049,8 +1081,20 @@ def workspace_ssh(
     args.extend(token_args)
 
     logging.info(f"SSH command: devpod {' '.join(args)}")
-    result = run_devpod(args, env=env)
-    return result.returncode
+    outcome = run_devpod_session(args, env=env)
+
+    # The two arms carry the same kind of number from different processes, which
+    # is exactly the confusion this used to make: `dl` reported devpod's exit
+    # code (always 1) for a session that had ended perfectly normally with, say,
+    # 130. Whichever arm this is, the status returned is the session's.
+    match outcome:
+        case devpod_ssh.RemoteExit(status=status):
+            return status
+        case devpod_ssh.DevpodFailed(exit_code=exit_code):
+            logging.debug("devpod ssh failed with exit code %s", exit_code)
+            return exit_code
+        case _ as unhandled:
+            devpod_ssh.assert_never(unhandled)
 
 
 def attach_workspace(workspace_id: str, shell_command: Optional[str] = None) -> int:

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

@@ -1,6 +1,6 @@
 [project]
 name = "devlaunch"
-version = "0.0.11"
+version = "0.0.12"
 authors = [{ name = "Austin Gregg-Smith", email = "blooop@gmail.com" }]
 description = "DevLaunch - A streamlined CLI for devpod workspaces"
 readme = "README.md"