A repository manager is used by people a few times a day and by machines all day long. Depotify is built for both: every action in the browser has an API behind it, and machines get credentials made for machines.
Personal access tokens
A build server should not know anybody's password. In Depotify every program — git, dnf, pip, npm, Docker, a CI job, a script — signs in with a personal access token:
- A token belongs to a person and carries that person's groups and roles — and never more.
- It has its own scopes, which narrow it further:
pypi:readcan install packages and nothing else;rpm:writecan publish RPMs but not delete them;artifact:deletecan clean up the file store;<tool>:admincan manage repositories and rules. A token without a scope for a tool cannot use that tool at all. - It has an expiry date, can be revoked at once, and stops working the moment its owner's account is disabled or closed.
- It is shown once, when it is created. Depotify stores only a hash of it; it never appears in a log, even when it is refused.
git clone https://alice:<token>@depo.example.com/git/team/app.git
curl -H "Authorization: Bearer <token>" https://depo.example.com/files/releases/
People manage their tokens on their own Access tokens page, choosing scopes from a tree — all tools, one tool, or single scopes — with the consequences of each written beside it.

For SSH, the same accounts hold SSH keys for git, Mercurial and Subversion.
One sign-in for all your Depotify servers
Many teams run more than one Depotify server — git in one place, packages in another. When they sign in through FFS's own identity provider, the servers share one account, one sign-in and one set of credentials:
- One token for every server.
ffs-logingets a central token: it shows a code, you approve it in a browser where you are already signed in — your second factor applies there — and it is kept for git's credential helper and~/.netrc. Every server that trusts the provider accepts it, with the scopes you chose. - Revoked once, refused everywhere.
ffs-login logout, or revoking it on the provider's own page, stops it on every server at once. - SSH keys, added once. A key added at the provider works on the SSH port of every server; removed there, it stops everywhere.
ffs-login login https://id.example.com/idp --server depo.example.com,git.example.com \
--scopes git:read,git:write --netrc --git
git clone https://git.example.com/git/team/app.git # no password asked
depo-upload takes the same token: access rel name release token login "depo.example.com" uses what ffs-login keeps on the machine, so a release file never holds a secret.
A REST API for every repository
Every tool answers the same management API under its own prefix, so a script written for one tool works for the next:
| Request | Does |
|---|---|
GET /<tool>/ | the repositories the caller may read, with what they may do there |
POST /<tool>/~api/repos | create a repository |
POST /<tool>/~api/repos/<name>/delete | delete one — naming it again if it holds anything |
GET /<tool>/~api/policy · PUT | read and replace the rules, with lint and conflict detection |
POST /<tool>/~api/simulate | ask the rule engine what it would decide, and why |
GET /<tool>/~api/audit | the audit log, filtered by resource, user, action, outcome |
The file store under every package tool adds the operations people use in the browser: upload, download, list a folder, move, delete to the trash, restore, purge, schedule a deletion, wipe, see a file's revisions, restore an older one, lock one, and look inside an archive. Times are UTC ISO timestamps; answers are JSON.
Ask before you send
Uploading a gigabyte only to be told "already exists" or "not allowed" wastes the network and the build. Depotify answers those questions before the bytes leave the machine:
- What may I do here? One request returns, for the caller, whether each action is allowed at a path — and if not, the reason and the rule — plus whether the repository keeps revisions, accepts unsigned packages, its upload limit, and whether it is a release or remote repository.
- What is already there? Size, checksum and signature state of a path, readable with a narrow right that does not let anyone download the content itself.
- Promote without uploading. Content the server already holds can be placed at a new path —
testingtostable— without sending a single byte, with every rule and immutability check applied as for an upload. - Refuse early. Uploads support
Expect: 100-continue, so a refusal the client could not predict still arrives before the body is sent; a checksum sent with the upload is verified and a mismatch stores nothing.
depo-upload: releases as a file
depo-upload is a command-line tool that turns a release into a short, checked file — which repositories, which packages, from where, with which account — and then sends only what really has to go.
// release.upload
version 1;
endpoint prod https://depo.example.com;
access rel name release token in "/etc/depo/release.token";
source built dir "build/packages" recursive;
repo stable as rpm path "el9/stable" on prod by rel;
set on-exists skip;
set unsigned refuse;
upload repo stable from built;
$ depo-upload --plan release.upload
plan: 12 files — 9 to send (48 MiB), 2 already there, 1 refused
stable rpm prod as rel
send new app-2.1.0-1.el9.x86_64 31 MiB
skip identical libapp-2.0.4-1.el9.x86_64 the repository holds exactly these bytes
refuse unsigned tools-2.1.0-1.el9.x86_64 this repository refuses unsigned packages
- Checked as a whole. A file with an unknown name, a credential in a URL or a missing token file is refused with every problem named and a suggestion — before anything is contacted.
- Planned, then done.
--checkresolves every name,--planasks the server and shows what would happen and why, a plain run does it. - Secrets stay where they are. Tokens are read from files the file names; the tool never prints a token, only where it came from.
- Machine-readable output for pipelines.
Built for CI
- Tokens with exactly the scopes a pipeline needs, and an expiry.
- Deploy keys as their own kind of subject in the rules.
- Re-runs that are safe —
depo-uploadskips what the repository already holds byte for byte. - Scheduled jobs (deletion, wiping) with their own API, cancellable and reschedulable.
- Every action in the audit log, attributed to the person behind the token.
