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:read can install packages and nothing else; rpm:write can publish RPMs but not delete them; artifact:delete can clean up the file store; <tool>:admin can 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.

Choosing a token's scopes: all tools, one tool, or single scopes
Choosing a token's scopes: all tools, one tool, or single scopes

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-login gets 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:

RequestDoes
GET /<tool>/the repositories the caller may read, with what they may do there
POST /<tool>/~api/reposcreate a repository
POST /<tool>/~api/repos/<name>/deletedelete one — naming it again if it holds anything
GET /<tool>/~api/policy · PUTread and replace the rules, with lint and conflict detection
POST /<tool>/~api/simulateask the rule engine what it would decide, and why
GET /<tool>/~api/auditthe 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 — testing to stable — 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. --check resolves every name, --plan asks 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-upload skips 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.