didericis-claude
35edf50f21
Interactive claude session hung silently after `attaching interactive claude session...` — `runuser -l` invokes a login shell that triggers PAM session setup / /etc/profile sourcing, and the minimal Debian agent VM doesn't have the PAM config files for that to complete cleanly. claude never got to draw its TUI. Switch UID via plain `runuser -u <user> --` (no `-l`) and inject HOME / USER through `smolvm machine exec -e` so the child process sees them. Avoids login-shell wiring entirely. Same pattern in `exec_claude` and `exec(script)`. `_HOME_FOR` maps the two users the codebase currently asks for (`node`, `root`); anything else falls back to `/home/<user>`. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
116 lines
4.8 KiB
Python
116 lines
4.8 KiB
Python
"""SmolmachinesBottle — running-instance handle (PRD 0023 chunk 2d).
|
|
|
|
Routes `exec_claude` / `exec` / `cp_in` through `smolvm machine
|
|
exec` / `smolvm machine cp`. The handle is yielded by `launch`
|
|
and torn down via the surrounding ExitStack on context exit;
|
|
`close` is a no-op idempotent alias so the BottleBackend ABC's
|
|
context-manager contract is satisfied.
|
|
|
|
User context: `smolvm machine exec` runs commands as root in the
|
|
VM, but the agent image's USER is `node` and claude-code refuses
|
|
to run as root with `--dangerously-skip-permissions`. Both
|
|
`exec_claude` and `exec` switch to the requested user (default
|
|
`node`) via `runuser -u <user> --` and set `HOME` / `USER`
|
|
through `smolvm -e` — avoiding `runuser -l`'s login-shell wiring
|
|
(PAM session setup, /etc/profile sourcing) which can hang on a
|
|
minimal Debian VM with no PAM session config."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import subprocess
|
|
|
|
from .. import Bottle, ExecResult
|
|
from . import smolvm as _smolvm
|
|
|
|
|
|
# Per-user env the agent image's USER (node) expects. claude
|
|
# reads ~/.claude.json + writes session state under ~/.claude/;
|
|
# bare `runuser -u` inherits root's HOME=/root, which claude
|
|
# can't write to. Set HOME / USER explicitly through smolvm -e
|
|
# so the child process sees them.
|
|
_HOME_FOR = {
|
|
"node": "/home/node",
|
|
"root": "/root",
|
|
}
|
|
|
|
|
|
def _env_flags_for(user: str) -> list[str]:
|
|
home = _HOME_FOR.get(user, f"/home/{user}")
|
|
return ["-e", f"HOME={home}", "-e", f"USER={user}"]
|
|
|
|
|
|
class SmolmachinesBottle(Bottle):
|
|
"""Handle returned by `SmolmachinesBottleBackend.launch`. The
|
|
underlying VM lifecycle (create / start / stop / delete) lives
|
|
on the launch ExitStack — this class only routes runtime
|
|
operations to the right `smolvm machine ...` subcommand."""
|
|
|
|
def __init__(self, machine_name: str, *, prompt_path: str | None = None) -> None:
|
|
self.name = machine_name
|
|
# In-VM path to the agent's prompt file. None when the
|
|
# agent declared no prompt (file still exists; we just
|
|
# don't pass --append-system-prompt-file).
|
|
self._prompt_path = prompt_path
|
|
|
|
def exec_claude(self, argv: list[str], *, tty: bool = True) -> int:
|
|
"""Run `claude` interactively inside the VM as the `node`
|
|
user. Inherits the operator's terminal (stdin / stdout /
|
|
stderr) so the session feels native. Blocks until claude
|
|
exits; returns the in-VM exit code.
|
|
|
|
We bypass the captured-output `machine_exec` helper here
|
|
because that one wraps stdout/stderr in pipes — fine for
|
|
scripted exec, wrong for an interactive shell. Drop down
|
|
to `subprocess.run` with the TTY inherited.
|
|
|
|
UID switches via `runuser -u node --` (not `-l`) so we
|
|
avoid login-shell wiring. HOME / USER come from `smolvm
|
|
-e` instead, which sets them on the process env."""
|
|
flags = ["smolvm", "machine", "exec", "--name", self.name]
|
|
if tty:
|
|
flags += ["-i", "-t"]
|
|
flags += _env_flags_for("node")
|
|
claude_argv = ["claude"]
|
|
if self._prompt_path:
|
|
claude_argv += ["--append-system-prompt-file", self._prompt_path]
|
|
claude_argv += argv
|
|
flags += ["--", "runuser", "-u", "node", "--", *claude_argv]
|
|
result = subprocess.run(flags, check=False)
|
|
return result.returncode
|
|
|
|
def exec(self, script: str, *, user: str = "node") -> ExecResult:
|
|
"""Run a POSIX shell script as `user` (default `node`) and
|
|
capture the result. Matches the docker backend's `exec`,
|
|
which defaults to the image's USER (also node) — so test
|
|
helpers / provision shell-outs run with the same identity
|
|
on both backends. Pass `user="root"` for tests that need
|
|
root.
|
|
|
|
`runuser -u <user> -- /bin/sh -c <script>` switches UID
|
|
without invoking a login shell; HOME / USER are set via
|
|
`smolvm -e` (see `_env_flags_for`)."""
|
|
argv = (
|
|
_env_flags_for(user)
|
|
+ ["--", "runuser", "-u", user, "--", "/bin/sh", "-c", script]
|
|
)
|
|
# _smolvm.machine_exec expects argv (the bit after `--`);
|
|
# the -e flags go before, so call smolvm directly.
|
|
r = subprocess.run(
|
|
["smolvm", "machine", "exec", "--name", self.name] + argv,
|
|
capture_output=True, text=True, check=False,
|
|
)
|
|
return ExecResult(
|
|
returncode=r.returncode,
|
|
stdout=r.stdout or "",
|
|
stderr=r.stderr or "",
|
|
)
|
|
|
|
def cp_in(self, host_path: str, container_path: str) -> None:
|
|
"""Copy a host path into the guest at `container_path`."""
|
|
_smolvm.machine_cp(host_path, f"{self.name}:{container_path}")
|
|
|
|
def close(self) -> None:
|
|
# Real teardown lives on the launch ExitStack; this is just
|
|
# the idempotent alias the BottleBackend ABC expects.
|
|
pass
|