Use once your change is on main, to put it live on the network by the smallest path it needs, or to see what is live. Whoever makes a change releases it.
2 stars
0 votes
0 copies
2 views
Added November 20, 2026
devopsrustgonodegitapidatabase
Works with
cli
api
mcp
Security analysis
B75/100
criticalSends environment variables or credentials to an external URL
Installs into .claude/skills of the current project.
Sponsors
SSkills DirectorySkills Directory
Know which skills are safe — weekly.
SSkills DirectorySkills Directory
Is that skill safe to install?
Are you the author of Release?
Add the live security badge to your README. It updates with every re-scan.
[](https://www.skillsdirectory.com/skills/drevantonder-release)
---
name: release
description: Use once your change is on main, to put it live on the network by the smallest path it needs, or to see what is live. Whoever makes a change releases it.
---
Release from `main` as it is now, never an older commit, and only what your change touched.
Check `one builds` first: if the build for your part is from a commit that has yours, you're live and run nothing.
`tooling/release` checks the same before it builds, and a release of a commit that a build the network has, or the
release holding the machine's lock, already contains ends on its own with exit status 0, saying which build to follow
with `one builds`. Only a release whose commit nothing covers waits, one release of a kind at a time.
A release is part of your change: it isn't done until it's live.
## Versions
The platform (One Core's server, the UI library, the edge, the clients and what they say to each other) has one
version, and each app one of its own, Semantic Versioning's. `tooling/version` says the platform's, and
`tooling/version apps/<name>` an app's, from the Conventional Commits that touch that part's paths, as
release-please's manifest mode does: a breaking change (`type!:` or a `BREAKING CHANGE:` footer) takes the next
minor, a `feat` or a `fix` the next patch, and a commit touching two parts moves each. Before 1.0 a minor is
breaking, as Cargo, npm and Hex read 0.x. A build is that version with its commit's count and hash as build
metadata, `0.18.2+2974.febd37350abc`. Nothing decides a bump but how commits are marked and what they touch: `!`
marks what breaks whoever uses the part the commit changes. A version names a release and refuses nothing: an app's
`!` moves only that app, and the platform's whether parts talk is their protocol's. One that wasn't marked is marked by a commit after it
that touches the same part, `fix!: <what broke>`, before it's released.
Exactly two rules hold at runtime:
- Parts talk where the protocols they speak overlap (`OneCore.Protocol`, `core/protocol.json`), whatever their
versions. A server refuses a request of a part that speaks none it does (`OneCore.Mcp`), saying why; a server asks
one like that nothing, as if it were off; the relay passes the edge's calls only to servers that speak one it does
(`core/edge/relay/relay.ts`), apart from whether they're ready. What updates a part that's behind, `tools/list`,
`builds`, `download`, `update` and its task's `tasks/get`, is answered whatever it speaks, so a client of any
version can always update. `one builds` says each part's `protocol`, the `edge_protocol`, each device's
`last_seen`, and `why` a server doesn't talk.
- An app runs on a server on its `requires`' `"core" => ">= 0.16.0"` or newer (`OneCore.Apps.Version.platform/1`,
worked out from the two versions, never kept): `runs`, or `waiting_for_server` on an older one (deploying it there
is refused, saying so). `one apps` and `one builds` say which, and a server that can't run one says why in
telemetry.
## Order
Publishing is all a release does. The network's update takes every server to the latest build published by itself
(`core/edge/updater/updater.ts`): each awake server prepares it, then each restarts on it, one at
a time, never the last ready one. A build published while another is under way takes its
place; a server asleep or gone is caught up once it's back; one that goes back holds it, saying which and why, until
a newer build or Update Now (the `update` tool). Run no `one update` for a release. `one builds` says how far it is
(`network`: its `network_update_status`, the servers `behind` it, and when each step was reached, in `timings`).
Nothing is watched after a release: each server verifies a build before it keeps it, and a bug found later is fixed
forward.
Any release mixes with what's live, a breaking one too, since a release that changes the wire speaks the protocol
before beside its own. Release the servers first, then the edge from the commit they run, then the clients; an app
that requires the new platform is deployed once every server is on it. `tooling/release` refuses a build that speaks
no protocol a server, the edge or a device that talks with them does, naming which: drop an old protocol only
once none of them speaks only it. Devices are otherwise not waited for, since their people update them.
| Changed | Release |
| --- | --- |
| An app (`apps/<name>/`, here or in a network's repo) | `ONE_SUBJECT=network one deploy --name <name> --files-from apps/<name>`, from that repo, into each network it's released to (about 12 s). Refused, someone else's newer change is live: rebase and deploy again, never `--force` |
| An app with a NIF (`server/nif/`) | `tooling/nifs`, then the same deploy. A Mac's NIF whose inputs haven't changed is the one last published (or cached here); one that changed is built on a Mac (a few minutes): GitHub's macOS runner, or the Mac `ssh mac` reaches when GitHub has no runner for it within 5 minutes (`tooling/on-mac`) |
| An app's native code (`server/nif/`, `server/bin/`) | Also `tooling/publish-nifs` once it's on `main`: it publishes the new builds to a GitHub Release and pushes their `server/checksums.json`, from which every network updating the app from git gets them. A Mac's are built on a Mac (`tooling/on-mac`) |
| The UI library (`core/ui/`) | The server, which ships it and builds every app again against it, then the edge, which serves it to browsers |
| The edge (`core/edge/`, an app's `edge/`, `clients/web/`, and the app's window page `clients/app/page/`, which every app on a build it runs on loads from its next start, phones too) | `bun install && flock ~/.cache/the-one-app/release-server.lock bun edge.js deploy https://<the network's host>` in `core/edge/`; it reads the Cloudflare token (`CLOUDFLARE_API_TOKEN` overrides) and the page signing key from 1Password itself, and refuses without them |
| The server (`core/server/`, or Rust it builds with) | `tooling/release server`, which reads the build signing key from 1Password itself, as every `tooling/release` does. Each server restarts on it in turn (a few seconds each), never the last ready one; a server whose `one` is new restarts on that `one` too, so no device's server runs an old `one` |
| The desktop app or CLI (`core/client/`, `clients/`, an app's `client/native/`) | `tooling/release client`. Every device takes it by itself: a server's `one` as the network's update takes it (restarting each server on it, one at a time), and a desktop app as it hears of it, starting again on it (`clients/app/src/updater.rs`). `client` includes the Mac's build, made on GitHub's macOS runner and the owner's Mac at once, whichever is first (`tooling/on-mac`; about 2 minutes, 8 with nothing cached: run `client` with your harness's longest timeout; a second release of the kind waits for the first only when its commit isn't in the first's), and only when what it's built from changed since the network's latest `one/macos-aarch64` (so is every client: one that didn't keeps its build, and `one --version` says which that is); Linux's alone is `tooling/release one/linux-x86_64 one-cli/linux-x86_64` (about 4 min) |
| A phone's app | An iPhone's goes to TestFlight with `tooling/release client`, where its native code changed (`tooling/testflight`, from the network's repo, `ONE_NETWORK_REPO`), and its testers' phones take it; its page and its apps reach it without one. An Android phone's its network's owner builds from the network's repo (`app/`) |
| Docs, `tooling/`, `.agents/` | Nothing |
Windows' builds, `server/windows-x86_64`, `one/windows-x86_64`, `one-cli/windows-x86_64` and the app's installer,
`one-setup/windows-x86_64` (NSIS's `makensis`, `apt install nsis`), are made on Linux like the others, and are
built only for a network with a Windows server or device. The owner's Surface is one, a server of the live network
since 18 Nov.
An app change that uses something new in `core/server/` says so in its `requires`, `"core" => ">= 0.16.0"`, and is
deployed once every server is on that version.
A server release deploys no apps. This repo's apps are published as any author's are: deployed, each that
changed, into each network the release serves, the owner's (its address is in Agent Memory), where they're the
network's own trusted apps, so every install of them takes the new version at once. A new network gets them from
whoever makes it (`tooling/network`).
On a device that is also a server, `one update` is the network's Update Now. What a server did is in the log of the
program keeping it running (`one serve run`), `journalctl --user -u one-server-<key's first 12>` on Linux.
Run an edge deploy only while no server release publishes on the machine, by taking its lock, which waits for one that
does: `flock ~/.cache/the-one-app/release-server.lock bun edge.js deploy https://<host>`. The network's address and
where its Cloudflare token is kept are in Agent Memory, not the repo.
## What is live
- `one builds` gives the network's update (`network`), each server's `build` as `<version>+<count>.<commit>`, and the
`edge`'s.
- `git diff --stat <commit> origin/main` is what isn't live on the server.
- `ONE_SUBJECT=network one code --name <app>` is an app's files as deployed.
## Mistakes already made
- A breaking release that apps' code can't run on (the plugin-to-app rename, 17 Nov) leaves sign-in not running on
each server it reaches, so nobody is signed in there and nothing can be deployed to it: keep sign-in's new version
first with the new build's own `OneCore.Apps.Store.keep/8` on a server's machine (as the bucket is reached without
the node) and restart that server.
- Releasing everything when one app changed. A server release is minutes and restarts every server; an app is
seconds.
- Releasing a server build onto storage whose stored names it had renamed. A rename of anything kept (a blob prefix,
a database, a table) needs a one-time rename of what's stored first; say so in the commit and do it before
`one update`.
- Releasing from a worktree behind `origin/main`: a build the network has from a newer commit covers it, so `tooling/release` publishes none of it.
- Releasing a server from a tree with changes not committed: the build is `.dirty`, and every server refuses it
("says it's ….dirty, not what was published").
- Changing what servers ask each other (`hooks/call`, `apps/call`, what a call passed on says in `_meta`) so the
version before reads it wrongly while the release reaches them (`This device isn't signed in here`, 240 times in
three minutes): keep it compatible for one release, the new beside the old. A server that can't take its update
(`permissions couldn't decide it`) is taken by hand, as its program would: download the build `one download --target <kind>` links, unpack it in its
`server/builds/<build>` past `bin/one_core eval "OneCore.Release.check()"` saying that build, set `next` to
`{"build": <it>, "program": <its one --version>}` and `server_update_status` to `verifying` in `server/state.json`,
and restart its unit (`systemctl --user restart one-server-<key's first 12>`, or on a Mac
`launchctl kickstart -k gui/$(id -u)/app.theone.server.<key's first 12>`); it goes back by itself if it doesn't
answer.
- Deploying the edge before the servers, from a commit they don't run: its relay took them all for gone and server
updates went back (17 Nov). It now sends nothing only to those that speak no protocol it does; the edge still
goes after the servers.
- A breaking release that removed two app categories (17 Nov), when parts talked only on one 0.minor and apps
pinned one with `~>`: the network split in two and six apps waited for updates. Now apps say a minimum.
- Refusing parts by how many 0.minors apart they were (until 19 Nov): three `!`s that changed nothing on the wire
took the platform from 0.24 to 0.26, and phones on 0.24 that spoke exactly what 0.26 does were refused. Now parts
talk by their protocol.
## Report
What you released, by which command, and the minutes from your commit reaching `main` to `one builds` (or
`one code`) showing it live: for a server, its `network.timings`.