A computer with no screen
Still under development, like the rest of Remote. Expect it to change. Each release since 0.23.0 carries a tarball of it for Linux, and since 0.30.0 two container images of it; see Installing and In a container.
yardsort-host runs Yardsort on a computer with no display, such as a server you reach over SSH, as a
host your phone reaches through a Yardsort server. You start agents there with ys, or from
the phone; you watch them and type into them from the phone. They keep running on that computer
whatever happens to the connection, to the phone, or to yardsort-host itself.
It is a separate program from the app and from ys, with no window and nothing to do with WebKit or
GTK. Nothing it runs listens on the network: it reaches out to the server, as the app does. The one
thing it serves is its dashboard, a web page for setting the computer up, on
127.0.0.1 alone, where no other computer can connect.
What it needs
- Linux. It builds on macOS too, but pairing a device needs Linux, where it can check who is asking (see Only a person can pair a device). There is none for Windows.
- A Yardsort server you can sign in to, and a browser on any other computer to sign in with. To run one of your own, see the self-host recipe.
git, and the agents you want to run, installed and signed in on that computer as the user who runsyardsort-host. Their sign-ins and their licences are yours to see to.yardsort-host install-agentinstalls one for you. The full container image comes with the agents whose licences allow it.
Installing
As the user that will run the host, one line installs the newest release, or brings it up to date:
curl -fsSL https://raw.githubusercontent.com/joaoh82/yardsort/main/crates/host/packaging/install.sh | sh
It takes the release's tarball for this computer, puts yardsort-host and ys in ~/.local/bin and
the systemd user service in ~/.config/systemd/user, and keeps your services running after you log
out where it may (loginctl enable-linger, with sudo if that asks for no password). It starts
nothing and signs in to nothing: it prints what is left, which is signing in,
the service, an agent and pairing,
and the dashboard, where an agent, Git and the rest can be done from a browser.
sh -s -- --version 0.34.1 after the pipe takes that release instead. Read
the script first if you would rather know what it does.
On a new cloud server, where the first login is root's, name the user it is for:
curl -fsSL https://raw.githubusercontent.com/joaoh82/yardsort/main/crates/host/packaging/install.sh | sh -s -- --user yardsort
As root it makes that user if there is none, installs git where apt can, and installs the same
things for that user; the host itself never runs as root. Nothing is made until the release is
downloaded, so a run that fails there can simply be run again.
A user it made is given SSH keys, so that you can log in as it: yours, when you ran the line with
sudo, and otherwise root's. Only keys with no options before them are given. Many cloud images
turn root's login off by putting a command before root's key that says to log in as another user;
that line is never handed on, and when there is no other key the script says the user has none yet
and where to put yours.
As a server's first boot, where your provider takes cloud-init's user data, make the user there with your key, and the script installs for it:
#cloud-config
users:
- default
- name: yardsort
shell: /bin/bash
ssh_authorized_keys:
- ssh-ed25519 AAAA… you@laptop
runcmd:
- curl -fsSL https://raw.githubusercontent.com/joaoh82/yardsort/main/crates/host/packaging/install.sh | sh -s -- --user yardsort
Then log in as that user over SSH for the rest. A shell from su or sudo -iu has no user session,
and systemctl --user does not work in one.
By hand
Each release carries yardsort-host-<version>-linux-x86_64.tar.gz and
yardsort-host-<version>-linux-aarch64.tar.gz, from the
releases page. Each holds yardsort-host, ys, a
systemd user service and a README. They are built on Ubuntu 22.04, and run where its glibc does,
2.35 or later: Ubuntu 22.04, Debian 12 or anything newer. Install them for the user that will run
them:
tar -xzf yardsort-host-<version>-linux-x86_64.tar.gz
cd yardsort-host-<version>-linux-x86_64
install -Dm755 bin/yardsort-host bin/ys -t ~/.local/bin/
install -Dm644 systemd/yardsort-host.service -t ~/.config/systemd/user/
~/.local/bin must be on that user's PATH in its login shell's profile, as it is by default on
Ubuntu and Debian once the folder exists: agents, and you, find ys by it.
Or build both from a checkout of the repository, with a current Rust:
cargo build --release -p yardsort-host -p yardsort-cli
install target/release/yardsort-host target/release/ys ~/.local/bin/
scripts/host-package.sh builds the same tarball a release carries.
Run them as an ordinary user, never as root. That user must own, or be able to write to, the repositories you add, and its home holds the agents' own sign-ins. To run the host in a container instead, see In a container.
To try it on a throwaway cloud server first, A test box for Remote makes one and builds it there for you.
Signing in
yardsort-host sign-in https://remote.example.com --name "Build box"
--name is what phones call this computer; it defaults to its host name. The command prints an
address. Open it in a browser on any computer and sign in. The browser is then sent to an address that
starts http://127.0.0.1:<port>/signed-in, which goes nowhere on that computer: copy the whole address
from its address bar, paste it into the waiting command, and press Enter. A wrong address is said, and
asked for again.
Or, before opening the address, forward the port it names from the computer with the browser, and the sign-in finishes by itself:
ssh -L <port>:127.0.0.1:<port> build-box
The address you paste holds a one-time code that is worth nothing without a secret sign-in keeps to
itself, so passing it through a clipboard gives nothing away.
Sign in while yardsort-host serve is stopped: one sign-in held by two programs gets it revoked at
the server, so sign-in refuses while anything runs on the profile. Signing in again later, as the
same name or another, keeps this computer as the same host, with its devices still paired.
Or sign in from the dashboard, while serve runs: its Remote
tab asks for the server and the name, and takes the pasted address the same way. The host links at
once, with no restart.
The sign-in is this computer's identity at the server. It is kept in a folder only its user can
read: credentials in the profile, or the folder YARDSORT_CREDENTIALS_DIR names. Anyone who can read
that folder can act as this host, so keep it out of backups others can read, and out of images.
Running the host
yardsort-host serve
It runs until stopped, and does what the open app does for this computer's terminals: keeps their
records true, takes in what agents report as they work, and keeps the link to the server's relay so
paired devices reach it. If the network goes, it keeps trying by itself. It also serves
the dashboard, and says where as it starts. Try it under tmux first; then run it
as a service, below.
Stopping it (Ctrl-C, or SIGTERM) stops none of the agents. It closes its link to the server
and its control socket, and exits. The agents run in Yardsort's terminal daemon, a process of its own,
and the next serve finds them still running. They stop when they finish, when you end them, or when
the computer shuts down.
Only one program runs on a profile at once: serve will not start while the app, or another serve,
has it, and the app will not start while serve has it.
As a service
The tarball's yardsort-host.service is a systemd user service: it runs as you, not as root.
Sign in first, then:
systemctl --user daemon-reload
systemctl --user enable --now yardsort-host
sudo loginctl enable-linger "$USER"
The last line keeps your services running with nobody logged in, and starts them when the computer
does; without it, the host stops when your last SSH login ends. journalctl --user -u yardsort-host
shows what it prints.
The service is set to KillMode=process, so stopping or restarting it stops serve alone and leaves
the daemon and the agents running: systemctl status then still lists them under the service, which
is expected. A service of your own needs the same line, or stopping it ends the agents with it. To
sign in again, or sign in as another name, stop the service first, and start it after.
yardsort-host status says whether the host is running, whether it is signed in, how its link to the
server stands, how many devices are let in, how many terminals are running, and where the dashboard
is.
The dashboard
While it runs, the host serves a web page for looking after this computer from a browser: how the
host and the computer stand, installing agents, Git and GitHub, cloning repositories, running the
commands that set a server up, a terminal, signing in to a Yardsort server, and letting devices in.
It is on unless you turn it off, and listens on 127.0.0.1, port 28680, alone.
yardsort-host dashboard # where it is, and a one-time link to sign a browser in
ssh -L 28680:127.0.0.1:28680 build-box # from your own computer, to open that link there
yardsort-host dashboard tunnel on --subdomain build-box # or give it an https address, with rustunnel
yardsort-host dashboard off # stop serving it, now and at every start
A sign-in link is given only to a person at a terminal of their own, as pair is. Whoever signs in
has a shell here as you, and can let a device in: the dashboard's sign-in is as much to keep as
pairing is. The host dashboard has all of it: what each tab does, the tunnel
and what its server can see, and how to turn it off.
In a container
Each release publishes two images, for x86_64 (amd64) and arm64, in the GitHub Container Registry. Each
is tagged with the release's version and with latest:
ghcr.io/joaoh82/yardsort-host-full, the one to start from. It has the tools agents use: Node.js, Bun, Go, Rust, Python, the GitHub CLI,git,ripgrep,jq, the build basics, and therustunnelclient the dashboard's tunnel runs. It also has the agents whose licences let anyone hand them on: Codex CLI, OpenCode, Pi and Oh My Pi. Claude Code, Cursor's CLI and Grok are not in it:install-agentinstalls those from each vendor, into the home volume, where a new container finds them./usr/share/doc/yardsort-host-full/NOTICE.mdin the image lists what is in it, and under which licence.ghcr.io/joaoh82/yardsort-host, the host alone, withgit, to build an image of your own on.
The example crates/host/compose.yaml runs the full image. Copy it, and
from its folder:
docker compose pull
docker compose run --rm host sign-in https://remote.example.com --name "Build box"
docker compose run --rm host install-agent claude
docker compose up -d
docker compose exec host claude # sign Claude Code in, once
docker compose exec host yardsort-host pair
docker compose exec host ys project add /repos/my-service
docker compose exec host ys workspace new my-service "Fix the flaky login test"
YARDSORT_VERSION=0.30.0 docker compose pull takes a given release rather than latest. Sign in by
pasting the address back, as above: forwarding the port does not reach into the container. pair from
docker compose exec is a terminal of your own, as an SSH login is.
- It runs as an ordinary user,
yardsort, undertini, which reaps what the agents leave behind. In the published images its ids are 1000. If your repositories' owner has other ids, build the images yourself, as below, so that what the agents write in them is yours. - Its volumes:
/datathe profile, withsettings.tomlin it;/credentialsthe host's sign-in;/worktreesthe workspaces;/home/yardsortthe agents' home, with whatinstall-agentinstalled, their sign-ins and their conversations; and your repositories wherever you mount them, at the path you add them by. Keep each its own volume. The home volume holds the agents' sign-ins: guard it as you would/credentials. - It publishes no port: the host only reaches out. Never give it the Docker socket, which is root
on the computer it runs on. The dashboard is served on the
container's own
127.0.0.1, which a published port would not reach: there it is opened through a rustunnel tunnel, whose client the full image carries.
Stopping or restarting the container ends the agents, since the terminal daemon lives inside it.
Their workspaces, worktrees and records stay in the volumes, and so do their conversations, which
the agents keep in the workspaces and your home: resume them with ys.
Checking an image. Each is signed with Sigstore by the release workflow, with no key to keep, and carries an SBOM and the build's provenance. With cosign, name the release's tag in both places:
cosign verify ghcr.io/joaoh82/yardsort-host-full:0.30.0 \
--certificate-identity https://github.com/joaoh82/yardsort/.github/workflows/release.yml@refs/tags/v0.30.0 \
--certificate-oidc-issuer https://token.actions.githubusercontent.com
The identity is the release workflow at that tag: the workflow runs only from a version's tag, a rebuild too, so an image signed any other way is not one of these.
Building them yourself, from the repository's root, the slim image first, with your own ids:
docker build -f crates/host/Dockerfile --build-arg UID="$(id -u)" --build-arg GID="$(id -g)" -t yardsort-host .
docker build -f crates/host/Dockerfile.full --build-arg SLIM=yardsort-host -t yardsort-host-full .
Then set image: yardsort-host-full in the compose file. To add something of your own, build FROM
either image.
Installing an agent
yardsort-host install-agent claude # or cursor, grok, codex, opencode, pi, omp
It installs an agent into ~/.local, as you, or brings one up to date. Run it as the user that runs
serve, since that is where the agents it starts look; it refuses to run as root.
The dashboard's Install does the same from a browser.
- Claude Code, Cursor's CLI and Grok come from each vendor's own installer:
https://claude.ai/install.sh,https://cursor.com/installandhttps://x.ai/cli/install.sh. It names the vendor and where their terms are before it runs one. Installing one is accepting those terms; Yardsort hands on no copy of them.--installer <file>runs an installer you downloaded and read yourself instead. - Codex CLI, OpenCode, Pi and Oh My Pi come from npm, as their newest release. The full image has
them already, at the versions its release pinned; this is how to take a newer one between releases.
It needs
npm, from Node.js 22 or later. Oh My Pi also needs Bun.
~/.local/bin comes first on the full image's PATH, so what you install there is what the agents run.
On a computer of your own it must be on your login shell's PATH, as Ubuntu and Debian put it once the
folder exists; install-agent says when it is not. Sign the agent in as its own guide says, as the same
user, before starting it with ys.
Projects and agents
On a computer with no screen, ys is how you add projects and start agents:
ys project add ~/src/my-service
ys workspace new my-service "Fix the flaky login test"
ys attach # watch it here; detaching leaves it running
The repositories have to be on that computer first, with a way to push from it: see Git and GitHub.
A paired device that may type can start work too: a new workspace, another agent in one, or a conversation that ended taken up again, as Remote says, from the phone or from the desktop app on another computer (Reaching another computer). It offers the agents this profile has turned on and can find, with the models and efforts its settings list for them.
The desktop app on another computer, let type, can also open a shell in a workspace here, rename,
archive or delete a workspace, and have this host clone a repository and add it as a project. A
clone goes into ~/Projects, made when it is first needed, or the folder you name in
settings.toml:
[remote]
projects_dir = "~/code" # a whole path, or one starting with ~ for this user's home
Such a computer can read a workspace's changes and files too, by paths inside the workspace, and
commit, push and open or merge its pull request: see
Remote. The host does those as itself, so give it a Git
name and email (git config --global user.name and user.email), credentials that can push, and
gh auth login if pull requests should be opened and merged from it.
The host keeps a Notifications list of its agents: one that
asks for a permission, finishes a stretch of work, or stops with an error. The desktop app on
another computer that may watch here shows those rows in its own list, and what is marked seen
there is marked here. An agent that finished while yardsort-host was stopped is listed when it
starts again.
It is cloned with this host's own Git sign-in, from an HTTPS or SSH address, and never to a path a
device names. In a container, point projects_dir at a folder in a volume if clones should outlast
the container.
Git and GitHub
The agents commit, push and open pull requests as the user that runs the host, with whatever that user can reach. Nothing of yours is there on a new server, so give it three things, as that user. Each can be done from a browser instead, under Git in the dashboard.
A name for its commits:
git config --global user.name "Your Name"
git config --global user.email you@example.com
The GitHub CLI, signed in. Yardsort opens and reads pull requests through
gh, here as on a desk computer
(Commits and pull requests). It is also what the phone's pull request
badges, cards and list come from: the host reads them with gh in each project's checkout when the
phone asks, and again at once after a merge, a push or a pull request opened from the phone
(Pull requests on the phone). gh can carry git's
pushes too, so
no SSH key is needed. Install it as GitHub says;
the full container image has it. Then:
gh auth login --hostname github.com --git-protocol https --web
It prints a one-time code and an address. Open the address in a browser on any computer and type
the code: nothing has to open on the server. Choosing HTTPS makes gh the one git asks for a
password, so git push works from then on. A server has no keyring, so gh keeps its token in a
file in that user's home, ~/.config/gh/hosts.yml: guard that home as you would the host's sign-in.
The repositories, cloned where you will add them from:
gh repo clone you/my-service ~/src/my-service
ys project add ~/src/my-service
What you sign in with is what every agent there can use. gh auth login in a browser hands the
server everything your account can do. To hand it less:
- A fine-grained token, made in GitHub's settings for the repositories this computer works on
alone, with what the work needs: Contents and Pull requests, read and write, to push and open pull
requests. Give it to
ghon its input, so that it is in no command line:gh auth login --with-token, then paste it and press Ctrl-D. Thengh auth setup-git, for git to use it. - A deploy key, for git alone, on one repository:
ssh-keygen -t ed25519 -C "build box"there, and add~/.ssh/id_ed25519.pubunder the repository's Settings → Deploy keys, with write access. Clone by the SSH address. Pull requests still needgh.
For another forge, give git a key or a token the same way; Yardsort's pull request features are GitHub's.
In a container, run the same commands with docker compose exec host before them. They are kept in
the home volume, with the agents' sign-ins.
When the server goes, take them back: gh auth logout there, and delete the token or the key at
GitHub, which is what makes a copy of the disk worth nothing.
After a restart
What a restart does to the agents depends on what restarted:
| What restarted | The agents |
|---|---|
The service, serve alone, or an upgrade | Keep running. The phone reaches the same computer again. |
| The computer, the container, or the terminal daemon | End with it. Their conversations can be resumed. |
The host started again settles what ended: ys session list --all shows those agents as ended. To carry on with one, name it by the start of the id that list prints:
ys session list --all
ys session resume 6051993d # the same conversation, in a new terminal
ys session fork 6051993d # a copy of it that goes its own way
Either keeps running after the command returns, and the phone sees it as it would any agent. A paired
device that may type can resume one too, with Resume beside it. A
resume picks up the conversation where the agent left it, as Resume does in the app, so it works
only for an agent that can resume one by its id or the most recent one in its folder; ys says why
when one cannot.
When an agent there asks for a permission, a phone that allows notifications gets An agent needs you, and opening it opens that agent's terminal; see Notifications.
Workflows, smoke tests, schedules and triggers do not run on a headless host yet.
ys workflow run, ys test run and ys schedule run say so and queue nothing, rather than queue work
nobody would carry out, and ys trigger says its triggers will not fire.
Only a person can pair a device
yardsort-host pair
Run in a terminal of your own on that computer, an SSH login say, it shows a QR code and a code to
type, good once for five minutes. Enter it on the phone. When the phone asks, pair shows its name
and what it asks for. When the phone asked to see workflow runs, watching includes reading them.
It asks you: Allow viewing, allow viewing and typing, or deny. If you allow it, and
the phone asked to approve or answer workflows, it then asks whether it may also do that. With
more than one project, it then asks which ones it may reach,
all of them if you just press Enter. Nothing is let in without your answer.
The device can be a phone, or the desktop app on another computer, signed in under Settings → Remote →
Other computers (Reaching another computer). The app asks to
watch and to type, as a phone does, and pair asks the same questions it asks a phone.
Or pair from the dashboard's Remote tab, in a browser you signed in to it: the same code, QR code and questions, answered on the page.
pair is refused from any terminal Yardsort started, and from anything an agent runs: the host checks
who is at the other end of its socket, and refuses a process that carries a launched session's
markers, descends from the terminal daemon, or types at one of the daemon's terminals, and one whose
input is not a terminal at all. A command run from the dashboard, or typed into its
terminal, is refused the same way: it is the host's own child, and marked as one.
The dashboard's own Remote tab does pair, for whoever is signed in to the dashboard: a code, the same questions, the same answers (Remote). That is the one way a device is let in without a terminal of your own, and it is why the dashboard's sign-in link is itself given only at one.
This is a guard, not a wall. A program running as the same user can read everything the host can, its sign-in included. What the guard stops is an agent letting a device in by accident, or because something it read told it to: nothing an agent is given can approve a device.
yardsort-host devices # the devices let in
yardsort-host revoke "My phone" # by its name, or the id `devices` shows
Taking a device's access away needs no check: it is always safe. Its channel closes at once.
Syncing projects
A project here can sync with your other computers signed in to the same account, as Syncing projects describes for the app. With the host running:
yardsort-host sync status # what syncs, the last pass, and what you could link
yardsort-host sync on my-service # shows what it sends, and asks
yardsort-host sync link my-service fa737444 # to one another computer syncs
yardsort-host sync stop my-service # unlink this computer; the others keep it
yardsort-host sync checkout my-service fix-login # another computer's workspace, here too
yardsort-host sync remove my-service # from the server, for every computer; asks first
A project is named as ys project list shows it, or by its id. sync on prints the project's
name, its remote's address, without any user or password, and how many approved notes and
workspaces go with it,
says the server keeps them in plain text, and asks before sending. status lists the projects your other computers sync that this one
does not, each by the start of its id, its name and its remote, and says which project here has
the same remote; link takes that id or the name. Nothing is linked by itself. --yes skips the
question on and remove ask.
checkout takes a workspace as ys sync status lists it, by name, or by the start of the id it
shows when two of your other computers have one of that name, as the refusal then lists: it
fetches the branch from the project's remote and makes a workspace on it here, refusing a branch here
with commits the remote's has not, which it leaves as it is. Push the branch from the other computer
first.
Like pair, on, link, stop, checkout and remove are refused from a terminal Yardsort started, from
anything an agent runs, and from input that is not a terminal (the guard).
status is not; nor is ys sync status, which is all ys offers of sync,
and which lists your other computers' workspaces of each synced project. None of them is made here.
Memory there
A project's memory works here as in the app's Memory view: agents propose notes with
ys memory propose, and you decide. With the host running:
yardsort-host memory list my-service # every note, by the start of its id
yardsort-host memory write my-service "The tests need TZ=UTC."
yardsort-host memory approve 4a1b2c3d # or reject, revoke, restore
yardsort-host memory edit 4a1b2c3d "The tests need TZ=UTC and LANG=C."
yardsort-host memory settle 4a1b2c3d --other # or --standing, or --text "…"
list shows what waits for you, what is approved and what is set aside, each with where it came
from, and first any note two computers changed at once: the text that stands, which agents get, and
the other computer's beside it. settle keeps the one that stands (--standing), the other
computer's (--other), or a third (--text), on every computer the project
syncs with. A note from another computer says which.
All of them are behind the guard, as pair is, list included:
no agent approves its own proposal, and none reads more of the memory than
ys memory gives it, the approved notes of a project that shares them.
Upgrading
Replace the two programs and restart serve. The install line does the first, and keeps a service
file you changed:
curl -fsSL https://raw.githubusercontent.com/joaoh82/yardsort/main/crates/host/packaging/install.sh | sh
systemctl --user restart yardsort-host
Or from a tarball you unpacked:
install -Dm755 bin/yardsort-host bin/ys -t ~/.local/bin/
systemctl --user restart yardsort-host
The agents keep running. A terminal daemon of the same kind is kept and reused; one from an earlier
release keeps its agents running until they end, while new ones start in a new daemon, and
yardsort-host status counts both. In a container, pull the new image, or build it again, and recreate
the container, which ends the agents: docker compose pull && docker compose up -d. What
install-agent installed stays in the home volume.
Backing up
What to keep:
- The profile (
~/.local/share/dev.yardsort.app, or/datain the container): the database, with your projects, workspaces and devices. settings.toml, which on Linux is in~/.config/dev.yardsort.appunless the profile was named with--data-dirorYARDSORT_DATA_DIR, when it is in the profile. See Where things are.- Your repositories and the worktree root, as you would anyway.
- In a container, the home volume,
/home/yardsort, if you want the agents' conversations back. It also holds their sign-ins, so a backup of it is a copy of those: keep it as you would keep them. Whatinstall-agentput there can be installed again instead.
Leave the sign-in out, or at least do not count on it. It changes each time the host renews it,
and a restored copy older than the last renewal looks stolen to the server, which then signs this
computer out. After restoring, run yardsort-host sign-in again: it keeps the same host, with its
devices still paired. A backup of the sign-in is also a copy of this computer's identity, readable by
anyone who can read the backup.
Exporting your account
yardsort-host account export # yardsort-account-<date>.json, here
yardsort-host account export --out ~/account.json # or where you say
Saves everything the server keeps of this computer's account as one JSON file: the account, your
devices and computers, which phones get notifications and your settings for them, and every synced
project, note and workspace name. Never a credential or a push token. It says what the file holds
first and asks; --yes does not ask. An existing file is kept: name another with --out. The file is
readable by your user only. See Exporting your account for
everything it holds and leaves out.
Like pair, it is refused from any terminal Yardsort started and from anything an agent runs, since
the file holds every synced note. serve has to be running.
Deleting your account
yardsort-host account delete
Deletes everything the server keeps of this computer's account, for every device: every phone and computer signed in to it, the devices each lets in, which phones get notifications, and every synced project, note and workspace name. It cannot be undone; export the account first to keep a copy. Everything on this computer stays: projects, workspaces and agents keep running, and Remote turns off here.
It says what goes and what stays, and asks you to type delete. Then, as with sign-in, it prints an
address: open it in a browser on any computer and sign in again, even if that browser is signed in
already. The browser is sent to an address starting http://127.0.0.1:<port>/signed-in that goes
nowhere there: paste it back, or forward the port over SSH first and it finishes by itself. Signing
in again is what deletes, and it has to be within five minutes and as the same person: as someone
else, the server says so and deletes nothing. Stop the command before then and nothing is deleted.
If the host stops answering after it printed the address, the command cannot tell whether the
account went, and says so: yardsort-host status tells, once the host runs again.
Like pair, it is refused from any terminal Yardsort started and from anything an agent runs or the
dashboard runs. serve has to be running. You can also delete the account from
your computer, your phone or your server's web page: see Deleting your account.
When the account is deleted elsewhere
Deleted from another device or the web page, the next time this computer reaches the server,
yardsort-host status says so:
Link: stopped: This computer's account was deleted at the server. Everything on this computer is still here. Sign in again with `yardsort-host sign-in`.
Its projects, workspaces and agents keep running. Signing in again starts a new, empty account.
Signing out
yardsort-host sign-out
Removes this computer at the server, signs its device out there, and forgets the kept sign-in. Every
paired device loses it. Works whether serve is running or not.
Where things are
| What | Where |
|---|---|
| The profile | --data-dir, else YARDSORT_DATA_DIR, else ~/.local/share/dev.yardsort.app: the database, the daemon's log, the activity inbox and spool |
settings.toml | YARDSORT_CONFIG_DIR when that is set, unless --data-dir named the profile. Otherwise in the profile when YARDSORT_DATA_DIR is set. Otherwise, on Linux, $XDG_CONFIG_HOME/dev.yardsort.app, else ~/.config/dev.yardsort.app; elsewhere, the profile |
| The sign-in | YARDSORT_CREDENTIALS_DIR, else credentials in the profile |
| The dashboard's sessions | dashboard/sessions.json in the profile: who is signed in to the dashboard, by a hash of each session |
| Worktrees | ~/yardsort, or YARDSORT_WORKTREE_ROOT, or the setting in settings.toml, as for the app |
serve's control socket | $XDG_RUNTIME_DIR/yardsort/<tag>.host.sock, else host.sock in the profile; only its user can reach it |
| The terminal daemon's | $XDG_RUNTIME_DIR/yardsort/<tag>.sock, else daemon.sock in the profile |
Where XDG_RUNTIME_DIR is not set, as in a shell from sudo -iu or su, the sockets are looked for in
/run/user/<uid>, the folder logind keeps for that user, so that such a shell and the systemd service
reach the same host and the same daemon. A daemon that an earlier release started in such a shell is
listening at daemon.sock in the profile; it is still looked for there, and used for as long as it runs,
so upgrading does not start a second one beside it.
Give ys the same profile as serve, with the same YARDSORT_DATA_DIR or --data-dir, or it looks at
another one.