devlaunch 0.0.14__tar.gz → 0.0.16__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devlaunch
-Version: 0.0.14
+Version: 0.0.16
 Summary: DevLaunch - A streamlined CLI for devpod workspaces
 Project-URL: Source, https://github.com/blooop/devlaunch
 Project-URL: Home, https://github.com/blooop/devlaunch
@@ -105,13 +105,26 @@ aid blooop/devlaunch@fix/42 fix the flaky test
 is exactly
 
 ```bash
-dl blooop/devlaunch@fix/42 -- claude 'fix the flaky test'
+dl blooop/devlaunch@fix/42 -- IS_SANDBOX=1 claude --dangerously-skip-permissions 'fix the flaky test'
 ```
 
 That means an `aid` workspace *is* the `dl` workspace: same clone, same workspace
 id, same container — started if stopped, attached to if already running, and never
 rebuilt just because `aid` asked for it. Anything `dl` learns, `aid` gets.
 
+`claude` is started with `--dangerously-skip-permissions`. The agent is already
+inside a disposable container holding only this repo, so the per-tool prompts it
+would ask on the host protect nothing here and would stall an unattended run.
+`IS_SANDBOX=1` rides along because `claude` otherwise refuses that flag outright
+under `uid 0`, and devcontainers that run as root are ordinary. The variable is
+scoped to the agent process, not exported into your shell.
+
+The trade is worth stating plainly: an agent started this way edits, runs and
+deletes inside the container without asking. It cannot reach your host, but it can
+rewrite the checkout it is in, so review an `aid` workspace before pushing rather
+than treating it as a sandbox that will stop it for you. `--codex` and `--gemini`
+are unaffected, and `dl <ws> -- claude` still runs exactly what you typed.
+
 | Option | Description |
 |--------|-------------|
 | `--claude`, `--codex`, `--gemini` | Pick the agent (default: `claude`) |
@@ -254,6 +267,11 @@ something to be spent on whatever the image ships. Check a workspace with:
 dl <workspace> -- gh auth status
 ```
 
+If no token can be found, `dl` warns on stderr and opens the workspace anyway rather
+than failing — and the warning names the config directory `gh` consulted, because the
+usual cause is a shell that scoped `XDG_CONFIG_HOME` somewhere `gh` has no login,
+not a host that is actually logged out.
+
 ### Who gets the token
 
 Everything running in the container does — including a `postCreateCommand` from a

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

@@ -83,13 +83,26 @@ aid blooop/devlaunch@fix/42 fix the flaky test
 is exactly
 
 ```bash
-dl blooop/devlaunch@fix/42 -- claude 'fix the flaky test'
+dl blooop/devlaunch@fix/42 -- IS_SANDBOX=1 claude --dangerously-skip-permissions 'fix the flaky test'
 ```
 
 That means an `aid` workspace *is* the `dl` workspace: same clone, same workspace
 id, same container — started if stopped, attached to if already running, and never
 rebuilt just because `aid` asked for it. Anything `dl` learns, `aid` gets.
 
+`claude` is started with `--dangerously-skip-permissions`. The agent is already
+inside a disposable container holding only this repo, so the per-tool prompts it
+would ask on the host protect nothing here and would stall an unattended run.
+`IS_SANDBOX=1` rides along because `claude` otherwise refuses that flag outright
+under `uid 0`, and devcontainers that run as root are ordinary. The variable is
+scoped to the agent process, not exported into your shell.
+
+The trade is worth stating plainly: an agent started this way edits, runs and
+deletes inside the container without asking. It cannot reach your host, but it can
+rewrite the checkout it is in, so review an `aid` workspace before pushing rather
+than treating it as a sandbox that will stop it for you. `--codex` and `--gemini`
+are unaffected, and `dl <ws> -- claude` still runs exactly what you typed.
+
 | Option | Description |
 |--------|-------------|
 | `--claude`, `--codex`, `--gemini` | Pick the agent (default: `claude`) |
@@ -232,6 +245,11 @@ something to be spent on whatever the image ships. Check a workspace with:
 dl <workspace> -- gh auth status
 ```
 
+If no token can be found, `dl` warns on stderr and opens the workspace anyway rather
+than failing — and the warning names the config directory `gh` consulted, because the
+usual cause is a shell that scoped `XDG_CONFIG_HOME` somewhere `gh` has no login,
+not a host that is actually logged out.
+
 ### Who gets the token
 
 Everything running in the container does — including a `postCreateCommand` from a

{devlaunch-0.0.14 → devlaunch-0.0.16}/devlaunch/aid.py

@@ -7,7 +7,7 @@ a `dl` one and hands that to :func:`devlaunch.dl.main`, so:
 
 is exactly
 
-    dl owner/repo@branch -- claude 'fix the flaky test'
+    dl owner/repo@branch -- claude --dangerously-skip-permissions 'fix the flaky test'
 
 Everything that decides how a workspace is obtained — the bare repo cache, the
 worktree clone, the workspace id, the devpod container, the fast attach to one
@@ -27,13 +27,41 @@ from typing import Dict, List, Optional
 
 from . import dl
 
+
+@dataclass(frozen=True)
+class Agent:
+    """How one coding agent is started inside the workspace.
+
+    Split three ways because not every part of the line belongs everywhere:
+    `env` and `command` always run, while `prompt_flags` only joins them when
+    there is a prompt — gemini's way of taking an initial prompt is a flag that
+    is a syntax error without one.
+    """
+
+    command: List[str]
+    prompt_flags: List[str] = field(default_factory=list)
+    env: Dict[str, str] = field(default_factory=dict)
+
+
 # Base command per agent. The prompt, when there is one, is appended as a single
 # quoted argument; each of these CLIs takes an initial prompt that way and then
 # drops into its interactive session.
-AGENT_COMMANDS: Dict[str, List[str]] = {
-    "claude": ["claude"],
-    "codex": ["codex"],
-    "gemini": ["gemini", "--prompt-interactive"],
+#
+# claude is started with --dangerously-skip-permissions: the whole point of a dl
+# workspace is that the agent is already inside a disposable container with only
+# this repo in it, so the per-tool prompts it would otherwise ask on the host buy
+# nothing and stop an unattended `aid owner/repo fix the bug` dead.
+#
+# IS_SANDBOX=1 is what makes that flag usable at all here. claude refuses it
+# outright under uid 0 -- "cannot be used with root/sudo privileges", exit 1 --
+# and plenty of devcontainers run as root, so without this aid would not start
+# in them at all. The variable is claude's own way of being told the refusal is
+# answering for a machine that isn't there, which is exactly a dl workspace: a
+# disposable container holding one repo.
+AGENT_COMMANDS: Dict[str, Agent] = {
+    "claude": Agent(["claude", "--dangerously-skip-permissions"], env={"IS_SANDBOX": "1"}),
+    "codex": Agent(["codex"]),
+    "gemini": Agent(["gemini"], prompt_flags=["--prompt-interactive"]),
 }
 
 # Flags that pick the agent, e.g. `aid --gemini owner/repo ...`.
@@ -122,18 +150,21 @@ def build_agent_command(agent: str, prompt: str = "") -> str:
     takes. The prompt is quoted here rather than reassembled by the caller, so
     the words the user typed reach the agent as the single argument they meant.
     """
+    # Named for the agent, not `spec`, which is the workspace everywhere else here.
     try:
-        command = list(AGENT_COMMANDS[agent])
+        started = AGENT_COMMANDS[agent]
     except KeyError:
         raise UsageError(
             f"Unknown agent {agent!r}. Choose one of: {', '.join(sorted(AGENT_COMMANDS))}."
         ) from None
-    if not prompt:
-        # No prompt to be interactive about: start the agent's plain session.
-        # gemini's --prompt-interactive would be a syntax error without one.
-        return shlex.quote(command[0])
-    command.append(prompt)
-    return shlex.join(command)
+    # No prompt to be interactive about: start the agent's plain session, without
+    # the flags that only make sense alongside one.
+    words = [*started.command, *started.prompt_flags, prompt] if prompt else list(started.command)
+    # Assignments prefixing a command set the variables for that command only, so
+    # the agent is the one process that sees them and nothing in the login shell
+    # dl runs this under is changed.
+    assignments = [f"{name}={shlex.quote(value)}" for name, value in sorted(started.env.items())]
+    return " ".join([*assignments, shlex.join(words)])
 
 
 def build_dl_args(parsed: AidArgs) -> List[str]:

devlaunch-0.0.16/devlaunch/devpod_provider.py

@@ -0,0 +1,116 @@
+"""Answer "is this devpod provider already registered?" from devpod itself.
+
+The question used to be asked by grepping devpod's human-facing table:
+
+    devpod provider list | grep -qw docker || devpod provider add docker
+
+devpod v0.26.1 colourises that table unconditionally and emits the reset
+sequence ``ESC[m`` immediately before each cell, so the character preceding
+``docker`` is the letter ``m``, ``grep -w``'s left word boundary never matches,
+and the guard reported "absent" on every machine that had already registered the
+provider. ``NO_COLOR=1`` does not help.
+
+Dropping ``-w`` would have fixed today's rendering and left us reading a table
+devpod is free to re-render tomorrow. ``provider list --output json`` is the
+same information in a form that has no rendering to change: an object keyed by
+provider name.
+
+The other half of the old guard's failure is the part worth keeping out on
+purpose. Output it could not read came back as an empty set of providers, and an
+empty set of providers means "go add one" -- so an unreadable answer turned into
+an action. Here, unreadable is its own outcome: `UnreadableProviderList`. The
+caller finds out, rather than being told something false.
+"""
+
+import json
+import subprocess
+from typing import Callable, Optional, Sequence, Set
+
+
+class UnreadableProviderList(RuntimeError):
+    """devpod's provider listing could not be read.
+
+    Distinct from "no providers are registered", which is a listing that reads
+    fine and is empty.
+    """
+
+
+def parse_provider_names(listing: str) -> Set[str]:
+    """The names of every registered provider in a `--output json` listing."""
+    try:
+        parsed = json.loads(listing)
+    except json.JSONDecodeError as exc:
+        raise UnreadableProviderList(
+            f"devpod's provider listing is not JSON: {listing[:120]!r}"
+        ) from exc
+    if not isinstance(parsed, dict):
+        raise UnreadableProviderList(
+            f"expected devpod to list providers by name, got {type(parsed).__name__}"
+        )
+    return set(parsed)
+
+
+def list_provider_names(
+    run: Callable[..., subprocess.CompletedProcess] = subprocess.run,
+) -> Set[str]:
+    """Ask devpod which providers are registered."""
+    result = run(
+        ["devpod", "provider", "list", "--output", "json"],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if result.returncode != 0:
+        raise UnreadableProviderList(
+            f"`devpod provider list` exited {result.returncode}: {(result.stderr or '').strip()[:200]}"
+        )
+    return parse_provider_names(result.stdout or "")
+
+
+def ensure_provider(
+    name: str, run: Callable[..., subprocess.CompletedProcess] = subprocess.run
+) -> bool:
+    """Register `name` with devpod unless it is already registered.
+
+    Returns True if it had to be added, False if it was already there. Raises
+    `UnreadableProviderList` rather than guessing when devpod's answer cannot
+    be read.
+    """
+    if name in list_provider_names(run=run):
+        return False
+    result = run(["devpod", "provider", "add", name], check=False)
+    if result.returncode != 0:
+        raise RuntimeError(f"`devpod provider add {name}` exited {result.returncode}")
+    return True
+
+
+def main(
+    argv: Optional[Sequence[str]] = None,
+    run: Callable[..., subprocess.CompletedProcess] = subprocess.run,
+) -> int:
+    """CLI entry point: `python -m devlaunch.devpod_provider <name>`.
+
+    This is what the `dev-add-docker` pixi task runs, so a devpod that cannot be
+    read has to stop the task rather than let it carry on as if the provider
+    were missing.
+    """
+    import argparse  # pylint: disable=import-outside-toplevel
+
+    parser = argparse.ArgumentParser(
+        prog="python -m devlaunch.devpod_provider",
+        description="Register a devpod provider unless it is already registered.",
+    )
+    parser.add_argument("name", help="provider name, e.g. docker")
+    args = parser.parse_args(argv)
+
+    try:
+        added = ensure_provider(args.name, run=run)
+    except (UnreadableProviderList, RuntimeError) as exc:
+        print(f"error: {exc}")
+        return 1
+    print(f"devpod provider {args.name}: {'added' if added else 'already registered'}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -27,6 +27,8 @@ import subprocess
 import tempfile
 from typing import Dict, Iterator, List, Optional, Tuple
 
+from devlaunch.xdg import config_home
+
 # The variable set inside the container. gh consults it before its config file.
 TOKEN_VAR = "GH_TOKEN"
 
@@ -74,14 +76,31 @@ def _token_from_gh_cli() -> Optional[str]:
             timeout=_GH_TIMEOUT_SECONDS,
         )
     except (OSError, subprocess.SubprocessError) as e:
-        logging.debug("Could not read a GitHub token from gh: %s", e)
+        logging.warning(
+            "Could not read a GitHub token from gh (%s), so this workspace opens "
+            "without a GitHub login.",
+            e,
+        )
         return None
     if result.returncode != 0:
-        logging.debug("gh auth token exited %s; no GitHub auth to forward", result.returncode)
+        # Name the config dir: a run that scoped XDG_CONFIG_HOME to a scratch
+        # directory hides the host's gh login, so gh refuses even though the user
+        # is logged in, and `gh auth login` is exactly the wrong remedy for it.
+        logging.warning(
+            "gh auth token exited %s, so this workspace opens without a GitHub login. "
+            "gh read its config from %s -- if you are logged in on this host, that "
+            "directory is the thing to check before `gh auth login`.",
+            result.returncode,
+            config_home(),
+        )
         return None
-    # Never log the value itself, only whether it was usable.
+    # Never log the value itself, only whether it was usable: what gh printed may
+    # be a malformed credential, and a warning is not a place to put one.
     if not _is_token(result.stdout.strip()):
-        logging.debug("gh auth token printed something that is not a token; ignoring it")
+        logging.warning(
+            "gh auth token printed something that is not a token, so this workspace "
+            "opens without a GitHub login."
+        )
         return None
     return result.stdout.strip()
 
@@ -112,13 +131,21 @@ def _stage_token_file(token: str) -> Optional[str]:
     try:
         fd, path = tempfile.mkstemp(prefix="devlaunch-gh-", suffix=".env")
     except OSError as e:
-        logging.debug("Could not create a file to pass the GitHub token to devpod: %s", e)
+        logging.warning(
+            "Could not create a file to pass the GitHub token to devpod (%s), so this "
+            "workspace opens without a GitHub login.",
+            e,
+        )
         return None
     try:
         with os.fdopen(fd, "w") as handle:
             handle.write(f"{TOKEN_VAR}={token}\n")
     except OSError as e:
-        logging.debug("Could not write the GitHub token for devpod: %s", e)
+        logging.warning(
+            "Could not write the GitHub token for devpod (%s), so this workspace "
+            "opens without a GitHub login.",
+            e,
+        )
         with contextlib.suppress(OSError):
             os.unlink(path)
         return None

{devlaunch-0.0.14 → devlaunch-0.0.16}/devlaunch/worktree/config.py

@@ -7,6 +7,8 @@ from typing import Dict, Optional, Union
 
 import tomli
 
+from devlaunch.xdg import config_home
+
 
 def _get_cache_base() -> Path:
     """Get the base cache directory, honoring XDG_CACHE_HOME."""
@@ -86,8 +88,7 @@ class WorktreeConfig:
 
 def get_config_path() -> Path:
     """Get the path to the config file."""
-    config_dir = Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config"))
-    return config_dir / "devlaunch" / "config.toml"
+    return config_home() / "devlaunch" / "config.toml"
 
 
 def load_config() -> Dict:

devlaunch-0.0.16/devlaunch/xdg.py

@@ -0,0 +1,21 @@
+"""Where the XDG base directories point on this machine.
+
+Two unrelated places ask for the config home: the worktree loader, which reads
+`config.toml` under it, and the gh-token warning, which names it so a user whose
+shell scoped the variable can see why `gh auth token` refused. Those two have to
+agree -- a warning that names one directory while the loader reads another is
+worse than no warning -- so they share the answer rather than each spelling it.
+"""
+
+import os
+from pathlib import Path
+
+
+def config_home() -> Path:
+    """`$XDG_CONFIG_HOME`, or the `~/.config` the spec falls back to.
+
+    An empty value counts as unset, which is what the XDG basedir spec says and
+    what a shell exporting the variable with no value means. Reading it any other
+    way resolves the config path relative to the working directory instead.
+    """
+    return Path(os.environ.get("XDG_CONFIG_HOME") or Path.home() / ".config")

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

@@ -1,6 +1,6 @@
 [project]
 name = "devlaunch"
-version = "0.0.14"
+version = "0.0.16"
 authors = [{ name = "Austin Gregg-Smith", email = "blooop@gmail.com" }]
 description = "DevLaunch - A streamlined CLI for devpod workspaces"
 readme = "README.md"
@@ -74,7 +74,7 @@ py312 = ["py312", "test"]
 py313 = ["py313", "test"]
 
 [tool.pixi.tasks]
-dev-add-docker = "devpod provider list | grep -qw docker || devpod provider add docker"
+dev-add-docker = "python -m devlaunch.devpod_provider docker"
 dev = { cmd = "devpod up . --ide none && ssh pythontemplate.devpod", depends-on = ["dev-add-docker"] }
 dev-vs = { cmd = "devpod up . --ide vscode", depends-on = ["dev-add-docker"] }
 dev-restart = { cmd = "devpod up . --recreate --ide none && ssh pythontemplate.devpod", depends-on = ["dev-add-docker"] }