Skip to content

chore(release): 0.4.1 - #1

Merged
fransallen merged 51 commits into
mainfrom
dev
Nov 16, 2026
Merged

fransallen merged 51 commits into
mainfrom
dev

Conversation

@fransallen

@fransallen fransallen commented Nov 16, 2026 •

Copy link
Copy Markdown
Contributor

Release 0.4.1: runs CI on dev before the version bump. main is fast-forwarded to the release commit, as for 0.4.0.

Tailscale answers 400 "description had invalid characters" to the
colon in "Pyo: join web-1", so adding a cluster or sandbox server
failed on every install since 0.3.0.
Each integration is a card with its category, a real stat and status
when connected, and what it enables plus a setup guide when not. A
segmented filter by category and a search sit on top. Settings move
into dialogs from each card's menu, and /integrations#<id> scrolls to
a card and opens them.
Tailscale, Hetzner, Docker for container registries and Vault for
secret stores, from simple-icons. BrandMark can now force a brand or
text color so each mark reads in light and dark themes.
Clusters has its own page with adding a cluster and each cluster's
settings, so the card only repeated it.
The installation admin now finds backups of Pyo's own data on Backups,
in a Pyo tab (/backups?tab=pyo), next to the team's backups.
/settings/backups redirects there and Settings opens on Email.
Servers without usable KVM, like Hetzner Cloud, now run sandboxes
under runsc as root on systrap. Each sandbox is an OCI bundle whose
root is a host overlay: the template's disk mounted read-only once,
under a writable layer on the sandbox's own ext4 image. envd runs as
PID 1 in dial mode and connects to the daemon's per-sandbox host.sock.

Networking uses a namespace and veth pair per sandbox behind the same
nftables table as Firecracker's taps. Pause and resume use runsc
checkpoint and restore after the daemon cuts every envd connection.
gVisor servers make templates as plain disks and start every sandbox
cold. Detection reports the runsc release.
The release now has pyo-sandbox-gvisor-linux-<arch>.tar.gz with runsc
and its gvisor-bin from the gVisor release pinned in gvisor.env and
checked against its sha512. release.json lists its sha256 under
sandboxGvisor, so it's signed with the rest.

sandbox.sh fetches it only when the detection finds no Firecracker,
installs runsc next to the daemon and checks again. A gVisor server
updates runsc with each release, and uninstall removes its sandboxes,
mounts and network namespaces.
A root job on GitHub's x64 runners fetches the pinned runsc and runs
sandboxes under it: exec, files, a port, the disk cap, memory from the
cgroup, internet with the host and metadata blocked, pause and resume,
a daemon restart, the lifetime and a clean delete.
GitHub's Connect and Set up now open the GitHub card's modal, which
also holds creating and removing the GitHub App. The GitHub tab leaves
Settings. /settings/github redirects to /integrations#github, and
GitHub's return after creating the app lands there with the modal open.
The registries menu no longer links away to the Pyo registry.
gVisor servers now take the team's templates like Firecracker servers,
and their reports count in a template's state. The daemon config names
runsc, and sandbox servers in the API carry a top-level runtime.
createCloudSandboxServer makes a server in the team's Hetzner project
with the existing cloud server code and sets it up as a sandbox server.
Its bootstrap code opens sandbox.sh's details, with a sandbox join code
made when the server asks, so its 15 minutes start then. Pyo follows it
from creating to ready, labels it pyo-sandbox-server, and deletes it at
Hetzner when the sandbox server is removed with confirm.

Sandbox servers in the API carry their cloud server, and cloud servers
their sandbox server.
pyo sandbox servers create asks for the price, makes the server and
follows it to ready. servers ls shows the runtime and how far a new
server is, and rm confirms the cost that stops for one Pyo made.
The installation's settings pages move to the root (/backups, /email,
/github, /observability, /updates), next to /profile. A team slug can't
take those names, and the dashboard's slug guess skips them too.
The installation's settings pages leave /settings/<page> for the root,
like /profile: /backups, /email, /observability and /updates. A pathless
layout keeps them inside Settings with the same tabs, and /settings opens
the first one. Old /settings/<page> links redirect with their query.

Backups of Pyo's own data are back in Settings at /backups. The team's
Backups page shows only the team's backups again, and its old ?tab=pyo
link goes to /backups.
The GitHub App is one per installation, so its setup returns to
Settings at /github, for the installation admin. There they create it,
see it and remove it. GitHub's return after creating the app lands
there, and /settings/github still redirects with its query.

The team's GitHub card on Integrations only connects the team's own
accounts. Without an app it links admins to Settings and asks others to
ask an admin. When GitHub sends someone back and Pyo can't tell the
team, / opens the current team's GitHub card.
/sandboxes with no sandbox server and no sandboxes is now the same
empty state as the databases'. Its button, New sandbox without a
server, and the New menu's Add server open Add sandbox server, which
starts with two square tiles: Cloud provider and Command line.

Cloud provider picks the provider (Hetzner for now), connects it inline
when it isn't, then takes a name, location and server type with
Hetzner's live prices and follows the server to ready. Command line is
the one-line sandbox.sh as before. Servers still being set up show
above the sandboxes, and removing one Pyo made deletes it at Hetzner
after showing the cost that stops.
New sandbox redirected to Add sandbox server when the team had no
server. It now shows a blocker in place of the form: add a sandbox
server first, or wait for the one that's being set up, with a link to
it on the servers page.
runsc moves the guest address and default route out of the network
namespace when it starts a sandbox. runsc restore then finds eth0
without an address, skips it, and the resumed sandbox has only lo.
Put the address and route back in the namespace before each restore.
runsc list has no -q flag, so uninstall never deleted the gVisor
sandboxes before unmounting their disks.
Commands that give a machine a Tailscale key (sandbox server, Add
server, Add cluster over the tailnet) fetched their script from Pyo's
tailnet address. The machine joins the tailnet only once that script
runs, so on a fresh server the curl couldn't reach the *.ts.net name.

These commands now fetch from PYO_SCRIPTS_URL when set, else from
pyo.dev. Pyo's public IP isn't used either, since it may sit behind
NAT. Commands for machines already on the tailnet keep their source.
An image like ghcr.io/o/r:1@sha256:... failed to parse, as its tag
stayed in the repository name. The digest now wins and the tag is
dropped, as in Docker. Pyo's release pins its images that way.
Debian 13 slim with git, curl, jq, build tools, Python 3.13 with pip
and uv, and Node.js 26 LTS with npm and pnpm through corepack. Every
version is pinned. It works as root with the default PATH, since
templates don't use an image's User, Env or WorkingDir yet.
The release builds ghcr.io/upsetdev/pyo/sandbox-base for amd64 and
arm64, signs it, and pins its digest as images.sandboxBase. Pyo's
worker gets it as PYO_SANDBOX_BASE_IMAGE. Each image job now checks
that the image can be pulled without logging in. pyo-up.sh leaves the
variable empty, since it doesn't build that image.
Pyo seeds an installation template named base from its release's
image on start and in each sandbox round. It's idempotent and only
moves forward, so an older Pyo during an update never moves it back.
Dev builds use the latest release found, or wait with one log line.

A new image is a new revision, kept on servers as <id>.<revision>.
Servers make it beside the old one, new sandboxes move to it once it's
ready there, and the old one is deleted once no sandbox uses it.
New servers make base when they join, like any template.

A create without a template uses base. Nobody can delete base, and no
other template may take its name.
pyo sandbox create and the create_sandbox tool no longer need a
template. The CLI shows base's image as Debian 13 and its repository.
The sandbox e2e builds sandbox-base from this branch, pushes it to a
registry on the runner, makes the template and runs git, python3, uv,
node and pnpm in a sandbox. A new job builds the image for both
architectures when its Dockerfile changes.
base reads as Debian 13 and its repository on Sandbox templates, has
no delete action, and New sandbox picks it once it's ready. The SDK
snippet leaves the template out when it's base.
@fransallen
fransallen merged commit 1e1ae77 into main Nov 16, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant