didericis-claude
9e3b7e441e
First slice of chunk 4: implement the two provisioning methods
that don't depend on agent-image tooling beyond `cp` and
`mkdir`. provision_ca / provision_git / provision_supervise
land once the agent-image gap is solved (chunk 4b+) — they need
update-ca-certificates, git, and the claude binary respectively,
none of which the chunk-2d alpine placeholder provides.
What this PR ships:
- `claude_bottle/backend/smolmachines/provision/` subpackage
with `prompt.py` + `skills.py`. Each routes through
`smolvm.machine_cp` / `machine_exec`. provision_prompt mirrors
the docker contract (file always copied; return value drives
--append-system-prompt-file iff the agent has a non-empty
prompt). provision_skills mkdir + cp per skill, matching
the docker backend's loop.
- prepare.py now writes the prompt file under
agent_state_dir(slug) with the agent's `prompt` body, mode
0o600. The in-guest path is `/root/.claude-bottle-prompt.txt`
(alpine has no `node` user; will become `/home/node/...` once
the real claude-bottle image lands).
- launch.py calls `provision(plan, machine_name)` after
machine_start. The returned prompt path threads to
SmolmachinesBottle so exec_claude can add
--append-system-prompt-file when the agent has a prompt.
- backend.py: provision_prompt / provision_skills now real;
provision_git is a deliberate stub (waiting on the git-gate
inner Plan + git in the agent image). provision_supervise
stays the chunk-2d stub.
Tests:
- 7 new unit cases (test_smolmachines_provision.py): argv
shape (mocked smolvm.machine_cp / .machine_exec),
prompt return-value contract, no-op-with-no-skills,
CLAUDE_BOTTLE_GUEST_SKILLS_DIR override, fail-on-missing-skill.
- 1 new integration case in test_smolmachines_launch.py:
end-to-end verification that the prompt file lands in the
alpine guest at /root/.claude-bottle-prompt.txt with the
expected content (via `bottle.exec("cat ...")`). The smoke +
the two TSI probes stay green.
552 unit + 4 integration (Darwin+smolvm+docker gated) passing.
What's left in chunk 4:
- 4b: thread the inner Plans (PipelockProxyPlan / EgressPlan /
GitGatePlan / SupervisePlan) through prepare + launch so the
bundle daemons actually run (currently daemons_csv="").
- 4c: the agent-image-conversion gap — get claude-code + git +
curl + ca-certificates into the guest image (build a
.smolmachine via `pack create --from-vm` after manual setup,
or push the docker image to a registry smolvm can pull).
- 4d: provision_ca + provision_git + provision_supervise once
4b + 4c land.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
74 lines
2.9 KiB
Python
74 lines
2.9 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."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import subprocess
|
|
import sys
|
|
|
|
from .. import Bottle, ExecResult
|
|
from . import smolvm as _smolvm
|
|
|
|
|
|
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. 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."""
|
|
flags = ["smolvm", "machine", "exec", "--name", self.name]
|
|
if tty:
|
|
flags += ["-i", "-t"]
|
|
claude_argv = ["claude"]
|
|
if self._prompt_path:
|
|
claude_argv += ["--append-system-prompt-file", self._prompt_path]
|
|
flags += ["--", *claude_argv, *argv]
|
|
result = subprocess.run(flags, check=False)
|
|
return result.returncode
|
|
|
|
def exec(self, script: str) -> ExecResult:
|
|
"""Run a POSIX shell script and capture the result. The
|
|
script runs under `/bin/sh -c`, matching what the docker
|
|
backend's `exec` does — callers can write shell-y test
|
|
helpers without worrying about argv splitting."""
|
|
r = _smolvm.machine_exec(
|
|
self.name,
|
|
["/bin/sh", "-c", script],
|
|
)
|
|
return ExecResult(
|
|
returncode=r.returncode,
|
|
stdout=r.stdout,
|
|
stderr=r.stderr,
|
|
)
|
|
|
|
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
|