Okay/Spec

Okay dares to ask the big questions. What if group chat was hypertext? What if discord let you write arbitrary HTML? What if protocols were bad?

in summary

The Okay standard introduces a simple and flexible way to represent group chats within HTML documents, and some methods of interacting with them.

• Messages are sent to Rooms, which are organised into Spaces.
• Like all good protocols, all communication happens over HTTP(S) and WebSockets.
• All data in Okay is formatted according to standardised HTML patterns (much like how Microformats work). We call these Michaelformats because I thought it would be funny.
• You can receive events as they happen by subscribing to them.
• Authentication uses the magic of client-side certificates. When a user adds a space, the client registers itself with the server using a fresh certificate, and then uses that to sign each subsequent request.

the warning (Hot Chip album)

This standard is deeply unserious. It is also deeply in progress. Implement at your own peril.

conventions

The key words “must”, “must not”, “required”, “shall”, “shall not”, “should”, “should not”, “recommended”, “may”, and “optional” in this document are to be interpreted as described in BCP14, although we use bold colourful text instead of capitals (so it doesn’t look like we’re yelling at you. This is a relaxed and cordial protocol specification).

controversies

• What “server” means is kind of nebulous.
• What do we do about invalid HTML?
• Should room names be unique?
• check out webauthn. maybe it's a better idea than client side certs lol

connections

Connections in Okay should happen over HTTPS. Plaintext HTTP is acceptable for testing purposes.

A typical connection to a never before seen space usually goes like this:

• The user hands the client a URI to examine;
• The client issues a GET request to the URI and checks the response against the discovery requirements;
• If the response meets all requirements, it generates a new key pair and registers itself;
• Once everyone’s happy, the client can begin posting messages to rooms.

processing documents

Much of the Okay protocol involves retrieving documents and scanning them for special markup.

michaelformats

The Okay Standard introduces a number of HTML patterns known as michaelformats. These are identical in concept to (and heavily plagiarise from) microformats.

linking to stuff

Unless otherwise specified, michaelformats can be included inline or linked in a <a/> or <link/> element, using the michaelformat's name as the rel attribute.

As an example, each of these elements are functionally equivalent:

<!-- a room directory, rendered inline -->
<div class="ok-rooms">
    <!-- ... -->
</div>

<!-- a room directory, linked with an anchor tag -->
<a href="/rooms/" rel="ok-rooms">Room Directory</a>

<!-- a room directory, linked with an link tag -->
<link href="/rooms/" rel="ok-rooms">

The value of the href attribute must be a valid URL potentially surrounded by spaces, as defined in the HTML standard.

When a client encounters a URI with a fragment, it must search for an element with a matching id in the linked document. If the specified element is present, the client must not scan the document for the desired markup, and instead consider the linked element to be the desired markup. If multiple instances of the same id exist in the document, the client must ignore all but the first instance. make this make sense

sending stuff

Sometimes you need to send stuff to the server. That's fine. That's okay. You'll be okay.

forms

Forms come in various forms.

Servers must accept form responses as application/x-www-form-urlencoded or application/json.

spaces

Conceptually, a space is an isolated container that stores room state and user data. They are each represented by a HTML element which provides URIs for clients to send their requests to (for example, its room directory or registration page). The URI of the document that contains this is called the space’s root URI.

discovery

For a client to recognise a document as containing a space, it must:

• Respond with 200 OK upon a GET request;
• Have a MIME type of text/html;
• Respond with a valid HTML document; define valid
• Have the Access-Control-Allow-Origin header set to *;
• Contain valid ok-space markup.

If a document contains multiple spaces, the client should prompt the user to select which space it should use.

ok-space

Spaces are declared using the ok-space michaelformat. Upon retrieving a document, the client must scan for elements with the ok-space class, as well as links and anchors with the ok-space rel attribute. Here's an example of valid ok-space markup:

<nav class="ok-space">
  <h1>This is an Okay space</h1>
  <a href="/rooms/" rel="ok-rooms">Rooms</a>
  <a href="/register/" rel="ok-register">Registration</a>
  <a href="/prefs/" rel="ok-prefs">Preferences</a>
</nav>

For an element to be considered valid ok-space markup, it must be a non-void element (ideally a <nav />) with the ok-space class and contain anchor elements with valid rel and href attributes. Any invalid anchors or elements not specified in the format must be ignored by the client. The inner text of the anchor elements is not significant and mustbe ignored by clients.

A list of valid anchor rel attributes and their purposes is described below:

Key: ◈ required, ◇ optional, ❖ can be specified multiple times

◈	ok-rooms	The space's room directory.
◈	ok-register	The space's registration page.
◈	ok-prefs	The space's preferences page.

linking to other spaces

A document can direct clients to another document containing a space using an <a /> or <link /> element with the rel="ok-space" attribute. The client must scan the linked document for valid ok-space markup, but it must not follow any further links or anchors with the rel="ok-space" attribute.

The URI provided may include a fragment component to specify which element the client should treat as ok-spacemarkup (e.g., https://example.com/#my-elem). The linked element must be valid ok-space markup. If the fragment is specified and the corresponding element is present in the linked document, the client must not scan any other part of the document for ok-space markup.

<!-- link to a space with the id "space" -->
<link rel="ok-space" href="https://example.ok/#space" />
<!-- anchors work, too. thanks to the lack of fragment (the bit after the #), 
     this link forces the client to rummage around for spaces like an animal -->
<a rel="ok-space" href="https://benfoldsfive.example/">
    chat in the official Ben Folds Five space!!!
</a>

metadata

Spaces can provide metadata about themselves to help users identify them.

<nav class="ok-space">
    <h1 class="ok-title"></h1>
    <p class="ok-subtitle"></p>
    <p class="ok-description"></p>
    <img class="ok-icon" src="">
    <!-- ... -->
</nav>

Space metadata can be declared anywhere within the ok-space element, using the class names given below:

Class Name	Tag	Purpose
ok-icon	<img /> or <picture />.	An image to represent the space visually. These are typically square and rendered at small sizes.
ok-title	Any non-void element, <h1 /> preferred.	What the space is called in common parlance.
ok-subtitle	Any non-void element, <p /> preferred.	An extra bit of text that is displayed alongside the title in certain contexts.
ok-description	Any non-void element, <p /> preferred.	A long description of what the space is about.

Clients may strip out child elements for some or all of the metadata elements, but should retain any text content from within the stripped elements.

class name bikeshedding

initiation

A client must register itself with a space before it can perform most actions.

keys

When registering with a space, a client should transparently generate a key pair (what type(s)?) and store it for use in subsequent requests.

registration

The registration page allows clients to register their public key and profile with the space.

directory

The room directory is represented using the ok-rooms michaelformat. It contains the list of every room in a space. This list may be paginated.

A space's room directory must be present in its ok-space element, either linked using the ok-rooms rel value or included inline.

Each room in the space must be linked with a single <a /> element with the ok-room rel value. Rooms must not be included inline in the room directory.

Here's an example of what a room directory might look like:

<main class="ok-rooms">
  <h1>Rooms on This Server</h1>
  <ul>
    <li><a href="/rooms/1" rel="ok-room">General</a></li>
    <li><a href="/rooms/evil" rel="ok-room">Evildoing Room (evil)</a></li>
  </ul>
</main>

A room directory is still just a rat in a cage.

sections

A <section /> element denotes a section, which allows severs to provide more structure to their room directory. Sections must have a heading of any level as a direct descendant and one or more room links. Anything within the section that isn't a header or room link must be ignored by the client.

pagination

Many lists can be paginated when it would be impractical to send its entire contents. This is common in message lists and room directories if you're getting a bit silly with it.

critical reception

It’s okay.