~ knotless Search/
↑↓ move↵ open⇧↵ all results
0
0
127 lines · 12.8 KB Raw History
# Changelog

What changed in each version of Monolith for those who run it or call it,
from the change files in `.changeset/` (see `knope.toml`).
## 0.7.0 (2026-11-21)

### Features

#### Spaces' issuer keys hold up at scale

A spaces token (a delegation token, credential or service auth) issued by an account on this server is now verified against the key the server already holds for it, with nothing read from the PLC directory. Other issuers' keys are used for `PDS_DID_CACHE_SECS` (an hour by default), then go on being used while they are read again in the background, up to the new `PDS_DID_CACHE_MAX_SECS` (a day by default), after which they are read again first. The server keeps up to one key for each 1 KiB of `PDS_CACHE_BYTES` (262,144 by default), forgetting the one used longest ago past that rather than all of them, and writes them to `PDS_DATA_DIR/issuer-keys` at shutdown and each minute they change, so a restart does not read every issuer's document again.

### Fixes

#### Blobs in a bucket are read and stored over kept connections

With `PDS_BLOBSTORE_S3_BUCKET` set, the server keeps a connection to the store open for up to 90 seconds between requests, instead of 2, so most `getBlob`s and uploads no longer open a connection and do a TLS handshake first. A request that fails before any answer, as when the store closes an idle connection just as the request is sent, is sent once more over a new connection, within the same timeout.

#### Spaces' tokens no longer wait for the PLC directory

The key of a delegation token's, a space credential's or a revocation's issuer is kept for `PDS_DID_CACHE_SECS` (an hour by default) rather than five minutes. Once it is half that old, a token it verifies is answered at once and the issuer's document is read again after it, so a busy issuer's calls never wait for the directory; calls that need the same issuer's document at once share one read of it. Reads from the PLC directory now reuse an open connection instead of making a new one each time, which saves a round trip and a TLS handshake on each; posts to it still take a connection of their own.

## 0.6.0 (2026-11-20)

### Features

#### getBlob's log line names the blob and the bytes sent

The `request` line of a `com.atproto.sync.getBlob` answered `200`, or `500` when the store failed to read the blob, has `repo` and `cid`, the account's DID and the blob's CID; one answered `200` has `bytes` too, the bytes of the blob the server handed to the connection: the blob's size when it was sent whole, fewer when the client left first or the store's read failed partway. `did` stays the account whose token the request carried. `pds admin logs --method com.atproto.sync.getBlob` shows which blobs are fetched, and which fetches were cut short.

### Fixes

#### Email sending takes lettre 0.11.24's fixes

The server sends email with lettre 0.11.24, which fixes four advisories in 0.11.23. RUSTSEC-2026-0564: a CR or LF in a display name made formatting a message panic. RUSTSEC-2026-0565: an SMTP server could make the client buffer a never-ending reply until memory ran out. RUSTSEC-2026-0560: a man-in-the-middle could slip replies of its own in after `STARTTLS`. RUSTSEC-2026-0561: a message with bare line endings could end early and smuggle SMTP commands after it.

#### A request answered before its body is read keeps its connection

When the server answers a request before reading its whole body, the connection now stays usable for the next request. Examples are an OAuth sign-in or PAR body past 100 KiB, a sign-in refused for its CSRF token, an upload past its limit, or a path not served. If at most 4 MiB of the body is left, the server reads and discards the rest after answering. If more is left, or the body is chunked, the answer says `Connection: close`.

Before, the server closed such connections without saying so. A client that keeps connections open could then send its next request on the closed connection and get "socket hang up" or a reset instead of an answer.

## 0.5.1 (2026-11-17)

### Fixes

#### Consent says what an app may do in spaces, from your side

The consent page's space rows now say what the app may do as you, rather than reading the scope word for word:

- **Others' spaces:** where the scope names any owner, or another account, the row is the spaces "you're in", not "Everyone's", as the space itself still decides who gets in.
- **Writes:** these are "your own" records, since a write in a space only ever reaches the writer's own records.
- **Managing:** changing who's in a space or deleting it reads "the ones you made", as only a space's owner can.

Each part of a space row or a data row is now a sentence of its own ("Read everything in them. Add, change and remove your own notes."), with no semicolons.

#### Spaces are carried across upgrades from 0.2.0 on

A server upgraded on a data directory written by 0.2.0 or any later release keeps its spaces: their records, members and history answer as they did before. Only 0.1.0's spaces, written before every account's log began with the spaces mark, are let go when the account is first loaded, together with any blob that only those spaces held. The spec and guides used to say spaces were never carried across versions. They now describe what the server does.

## 0.5.0 (2026-11-17)

### Features

#### Consent shows permission sets as the reference does

The consent page gives every `include:` scope a row of its own, as the reference's page does: also for a set with no title, and also beside `transition:generic`. A row's heading is the set's title, or its NSID when it has none. Under the heading is the set's detail, or else the NSID when the set has a title. A closed `Details` disclosure in the row lists what the set grants: its methods and the services they reach, and its collections with the actions asked of each. A set's grant is no longer folded into the "Your data in …" and "Other services" rows. The "From <authority>" line is gone, and titles and details are shown in full.

#### Consent shows space permissions in plain words

The consent page now says what an app asks of spaces, in the same plain words as its other rows, rather than listing each `space:` token as it is written. Each space an app asks for has a row of its own, named by whose spaces they are and the type's title: "Your Workspace spaces", "@bob.test's Board spaces", "Every space you're in". Its sentence says what the app may do there: read everything, or only what you've written; add, change or remove which kinds of records; make new spaces, change who's in them or delete them. A permission set's `Details` lists its spaces the same way. To say this, the authorization page's `__authorizeData` now carries `spaces`, each space type's declaration, and `spaceHandles`, the verified handles of the accounts that own the spaces asked for, when the scope asks for any space, as the reference's spaces alpha does.

#### Permission sets grant space permissions

A permission set may now grant `space` permissions, as the spaces proposal and the reference's spaces alpha allow. Each one's `spaceType` must be under the set's own namespace, and never `*`; its collections may be anywhere. An `include:` of such a set gives the token's scope those `space:` permissions. They are written and rewritten as a `space:` scope asked for directly would be: a bare type gets the collections its declaration lists, and `self` becomes the account's DID. The authorization page and the code grant resolve those space types' declarations too. Before this, a set's `space` permissions were dropped, so an app that asked for its space access through a set got a token the space methods refused.

## 0.4.0 (2026-11-15)

### Features

#### OAuth apps can use spaces

The space methods take OAuth access tokens, allowed what their `space:` permissions allow, as the spaces alpha of the reference serves them (`spec/OAUTH-SCOPES.md`, "Spaces"). A client asking for `space:<type>` keeps it in its token: a bare type's collections are those its space type declaration lists, resolved as permission sets are, and `authority=self` becomes the account's DID. A call its scope does not allow is `403 ScopeMissingError`, naming the `space:` scope that would; `transition:generic` allows nothing of a space, and `getDelegationToken` needs `read`. A request naming a space type that does not resolve to a declaration is sent back to its client from the authorization page with `invalid_scope`. Before, the space methods refused every OAuth token as `400 InvalidToken`, and no token kept a `space:` permission.

### Fixes

#### `pds_log_bytes` no longer counts journal segments already deleted

With `PDS_SYNC` `together`, the `pds_log_bytes` gauge, and `_stats`' `logBytes`, could count the journal's segments for a while after they were deleted: until the journal had deleted all of them, syncing the directory after each. A segment's bytes now leave the gauge as its file is deleted.

#### Loopback clients with long scopes can sign in

PAR keeps a `client_id` of up to 18470 bytes, not 2048: the longest loopback client ID naming a `redirect_uri` of 2048 bytes and a `scope` of 4096, every byte of both percent-encoded. A loopback client's ID carries its whole scope, so clients asking for many permissions, such as the knotless CLI (whose ID is 2857 bytes), were refused with `invalid_request: client_id is too long` although every part of their request was within its own cap.

#### A space's `listRecords` cursor is a record's URI, as the reference's is

`com.atproto.space.listRecords` answers its cursor as the URI of the page's last record, `{space}/{repo}/{collection}/{rkey}`, as the reference does, where it answered `{collection}/{rkey}`. It takes a cursor of that form as a position, whether or not that record exists, so a client can start a page below a key of its choosing, as knotless does to read a private repository's refs; before, such a cursor listed nothing. A cursor that is not a record URI of the space and repo asked is `400 InvalidCursor`.

## 0.3.0 (2026-11-14)

### Features

#### Accounts sign in with passkeys

An account can sign in on the OAuth sign-in page with a passkey instead of its password, and with no email code. `pds passkey add --name <name>` (or the `passkey_add` MCP tool), with the account's password session, answers a link, good for 15 minutes, to open in a browser on the device that is to keep the passkey; `pds passkey list` and `pds passkey remove --id <id>` list and remove them. The sign-in page offers the device's passkeys in the "Handle or email" field's autofill, and with a `Sign in with a passkey` button. Passkeys are bound to the host of `PDS_PUBLIC_URL`: a browser makes none for an IP address, and once the URL names another host those made before are no longer offered. A password reset removes the account's passkeys.

### Fixes

#### A large import's log is compacted at once

The log of an account that moved in a large repository with `com.atproto.repo.importRepo` is compacted in seconds, not in about an hour: the import is one commit of every record, whose index was larger than compaction's cache keeps, so it read the whole commit again for each record it wrote out, and the account's next write, such as `activateAccount`, waited for it all that time. Compaction now indexes each commit once, holding its index until it ends, counted in `PDS_CACHE_BYTES` as what it holds besides.

#### importRepo keeps every record as the CAR file has it

A repository moved in with `com.atproto.repo.importRepo` whose records hold a map that JSON writes as another value, such as a blob ref whose `ref` is a map of the one key `$link` rather than a link, as some servers wrote them, no longer leaves the account's log unreadable: before, the server logged `store failure` ("record …, which the commit … does not sign") on the import and on every write after it, could not compact the account's log, and stopped when it next read such a record from the log. Each record is now kept byte for byte at the CID the CAR names, through compaction and restarts, and the blob such a `ref` names is the account's to hold, listed by `listMissingBlobs` until it is uploaded. The same holds for a space repo's records imported with `com.atproto.space.importRepo`.

#### Monolith is licensed MIT or Apache-2.0

Monolith may be used, changed and shared under the MIT license or the Apache License 2.0, at your option. Both are in the binary's archive and in the image, at `/usr/share/doc/monolith/`, whose `org.opencontainers.image.licenses` label names them. The specifications vendored under `spec/` keep their own licenses.

## 0.2.0 (2026-11-14)

### Features

#### Each version is published as an image and a binary

Each release is published as the image `knotless.dev/chadtmiller.com/monolith`, tagged with its version and `latest`, and as the `pds` binary for Linux x86-64 on the repository's releases page, with its SHA-256. The image's labels name its version and the commit it was built from, and `/xrpc/_health` answers its version.