yardsort

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 runs yardsort-host. Their sign-ins and their licences are yours to see to. yardsort-host install-agent installs 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 the rustunnel client 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-agent installs those from each vendor, into the home volume, where a new container finds them. /usr/share/doc/yardsort-host-full/NOTICE.md in the image lists what is in it, and under which licence.
  • ghcr.io/joaoh82/yardsort-host, the host alone, with git, 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, under tini, 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: /data the profile, with settings.toml in it; /credentials the host's sign-in; /worktrees the workspaces; /home/yardsort the agents' home, with what install-agent installed, 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/install and https://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 gh on its input, so that it is in no command line: gh auth login --with-token, then paste it and press Ctrl-D. Then gh 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.pub under the repository's Settings → Deploy keys, with write access. Clone by the SSH address. Pull requests still need gh.

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 restartedThe agents
The service, serve alone, or an upgradeKeep running. The phone reaches the same computer again.
The computer, the container, or the terminal daemonEnd 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 /data in the container): the database, with your projects, workspaces and devices.
  • settings.toml, which on Linux is in ~/.config/dev.yardsort.app unless the profile was named with --data-dir or YARDSORT_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. What install-agent put 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

WhatWhere
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.tomlYARDSORT_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-inYARDSORT_CREDENTIALS_DIR, else credentials in the profile
The dashboard's sessionsdashboard/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.