chmod 600 for cache file

Fix topic div being hidden on iOS devices

.github/workflows/test.yaml

@@ -0,0 +1,22 @@
+name: test
+on: [push, pull_request]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Install Go
+        uses: actions/setup-go@v2
+        with:
+          go-version: '1.17.x'
+      - name: Checkout code
+        uses: actions/checkout@v2
+      - name: Install dependencies
+        run: sudo apt update && sudo apt install -y python3-pip
+      - name: Build docs (required for tests)
+        run: make docs
+      - name: Run tests, formatting, vetting and linting
+        run: make check
+      - name: Run coverage
+        run: make coverage
+      - name: Upload coverage to codecov.io
+        run: make coverage-upload

.gitignore

@@ -1,3 +1,5 @@
 dist/
+build/
 .idea/
+server/docs/
 *.iml

.goreleaser.yml

@@ -13,7 +13,7 @@ builds:
     goos: [linux]
     goarch: [amd64]
   -
-    id: ntfy_arm67
+    id: ntfy_armv7
     binary: ntfy
     env:
       - CGO_ENABLED=1 # required for go-sqlite3
@@ -23,9 +23,7 @@ builds:
       - "-linkmode=external -extldflags=-static -s -w -X main.version={{.Version}} -X main.commit={{.Commit}} -X main.date={{.Date}}"
     goos: [linux]
     goarch: [arm]
-    goarm:
-      - 6
-      - 7
+    goarm: [7]
   -
     id: ntfy_arm64
     binary: ntfy
@@ -54,7 +52,11 @@ nfpms:
         type: config
       - src: config/ntfy.service
         dst: /lib/systemd/system/ntfy.service
+      - dst: /var/cache/ntfy
+        type: dir
     scripts:
+      postinstall: "scripts/postinst.sh"
+      preremove: "scripts/prerm.sh"
       postremove: "scripts/postrm.sh"
 archives:
   -
@@ -78,12 +80,35 @@ changelog:
       - '^docs:'
       - '^test:'
 dockers:
-  - dockerfile: Dockerfile
-    ids:
-      - ntfy
-    goos: linux
+  - image_templates:
+      - &amd64_image "binwiederhier/ntfy:{{ .Tag }}-amd64"
+    use: buildx
+    dockerfile: Dockerfile
     goarch: amd64
+    build_flag_templates:
+      - "--platform=linux/amd64"
+  - image_templates:
+      - &arm64v8_image "binwiederhier/ntfy:{{ .Tag }}-arm64v8"
+    use: buildx
+    dockerfile: Dockerfile
+    build_flag_templates:
+      - "--platform=linux/arm64/v8"
+  - image_templates:
+      - &armv7_image "binwiederhier/ntfy:{{ .Tag }}-armv7"
+    use: buildx
+    dockerfile: Dockerfile
+    goarch: arm
+    goarm: 7
+    build_flag_templates:
+      - "--platform=linux/arm/v7"
+docker_manifests:
+  - name_template: "binwiederhier/ntfy:latest"
     image_templates:
-      - "binwiederhier/ntfy:latest"
-      - "binwiederhier/ntfy:{{ .Tag }}"
-      - "binwiederhier/ntfy:v{{ .Major }}.{{ .Minor }}"
+      - *amd64_image
+      - *arm64v8_image
+      - *armv7_image
+  - name_template: "binwiederhier/ntfy:{{ .Tag }}"
+    image_templates:
+      - *amd64_image
+      - *arm64v8_image
+      - *armv7_image

LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyyy] [name of copyright owner]
+   Copyright 2021 Philipp C. Heckel
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

LICENSE.GPLv2

@@ -290,8 +290,8 @@ to attach them to the start of each source file to most effectively
 convey the exclusion of warranty; and each file should have at least
 the "copyright" line and a pointer to where the full notice is found.
 
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
+    ntfy
+    Copyright (C) 2021 Philipp C. Heckel
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by

Makefile

@@ -38,6 +38,13 @@ help:
 	@echo "  make install-lint                - Install golint"
 
 
+# Documentation
+docs-deps: .PHONY
+	pip3 install -r requirements.txt
+
+docs: docs-deps
+	mkdocs build
+
 # Test/check targets
 
 check: test fmt-check vet lint staticcheck
@@ -65,7 +72,7 @@ coverage-upload:
 # Lint/formatting targets
 
 fmt:
-	$(GO) fmt ./...
+	gofmt -s -w .
 
 fmt-check:
 	test -z $(shell gofmt -l .)
@@ -79,7 +86,7 @@ lint:
 
 staticcheck: .PHONY
 	rm -rf build/staticcheck
-	which staticcheck || go get honnef.co/go/tools/cmd/staticcheck
+	which staticcheck || go install honnef.co/go/tools/cmd/staticcheck@latest
 	mkdir -p build/staticcheck
 	ln -s "$(GO)" build/staticcheck/go
 	PATH="$(PWD)/build/staticcheck:$(PATH)" staticcheck ./...
@@ -88,7 +95,7 @@ staticcheck: .PHONY
 
 # Building targets
 
-build-deps: .PHONY
+build-deps: docs
 	which arm-linux-gnueabi-gcc || { echo "ERROR: ARMv6/v7 cross compiler not installed. On Ubuntu, run: apt install gcc-arm-linux-gnueabi"; exit 1; }
 	which aarch64-linux-gnu-gcc || { echo "ERROR: ARM64 cross compiler not installed. On Ubuntu, run: apt install gcc-aarch64-linux-gnu"; exit 1; }
 
@@ -113,7 +120,14 @@ clean: .PHONY
 
 # Releasing targets
 
-release: build-deps
+release-check-tags:
+	$(eval LATEST_TAG := $(shell git describe --abbrev=0 --tags | cut -c2-))
+	if ! grep -q $(LATEST_TAG) docs/install.md; then\
+	 	echo "ERROR: Must update docs/install.md with latest tag first.";\
+	 	exit 1;\
+	fi
+
+release: build-deps release-check-tags check
 	goreleaser release --rm-dist --debug
 
 release-snapshot: build-deps
@@ -129,4 +143,4 @@ install:
 install-deb:
 	sudo systemctl stop ntfy || true
 	sudo apt-get purge ntfy || true
-	sudo dpkg -i dist/*.deb
+	sudo dpkg -i dist/ntfy_*_linux_amd64.deb

README.md

@@ -1,12 +1,19 @@
 ![ntfy](server/static/img/ntfy.png)
 
-# ntfy.sh | simple HTTP-based pub-sub
+# ntfy.sh | Send push notifications to your phone or desktop via PUT/POST
+[![Release](https://img.shields.io/github/release/binwiederhier/ntfy.svg?color=success&style=flat-square)](https://github.com/binwiederhier/ntfy/releases/latest)
+[![Go Reference](https://pkg.go.dev/badge/heckel.io/ntfy.svg)](https://pkg.go.dev/heckel.io/ntfy)
+[![Tests](https://github.com/binwiederhier/ntfy/workflows/test/badge.svg)](https://github.com/binwiederhier/ntfy/actions)
+[![Go Report Card](https://goreportcard.com/badge/github.com/binwiederhier/ntfy)](https://goreportcard.com/report/github.com/binwiederhier/ntfy)
+[![codecov](https://codecov.io/gh/binwiederhier/ntfy/branch/main/graph/badge.svg?token=A597KQ463G)](https://codecov.io/gh/binwiederhier/ntfy)
+[![Slack channel](https://img.shields.io/badge/slack-@gophers/binwiederhier-success.svg?logo=slack)](https://gophers.slack.com/archives/C01JMTPGF2Q)
+[![Healthcheck](https://healthchecks.io/badge/68b65976-b3b0-4102-aec9-980921/kcoEgrLY.svg)](https://ntfy.statuspage.io/)
 
 **ntfy** (pronounce: *notify*) is a simple HTTP-based [pub-sub](https://en.wikipedia.org/wiki/Publish%E2%80%93subscribe_pattern) notification service.
 It allows you to **send notifications to your phone or desktop via scripts** from any computer, entirely **without signup or cost**.
 It's also open source (as you can plainly see) if you want to run your own.
 
-I run a free version of it at **[ntfy.sh](https://ntfy.sh)**, and there's an [Android app](https://play.google.com/store/apps/details?id=io.heckel.ntfy)
+I run a free version of it at **[ntfy.sh](https://ntfy.sh)**, and there's an [open source](https://github.com/binwiederhier/ntfy-android) [Android app](https://play.google.com/store/apps/details?id=io.heckel.ntfy)
 too.
 
 <p>
@@ -17,188 +24,21 @@ too.
   <img src="server/static/img/screenshot-phone-notification.jpg" height="180">
 </p>
 
-## Usage
+## **[Documentation](https://ntfy.sh/docs/)**
 
-### Publishing messages
-
-Publishing messages can be done via PUT or POST using. Topics are created on the fly by subscribing or publishing to them.
-Because there is no sign-up, **the topic is essentially a password**, so pick something that's not easily guessable.
-
-Here's an example showing how to publish a message using `curl`:
-
-```
-curl -d "long process is done" ntfy.sh/mytopic
-```
-
-Here's an example in JS with `fetch()` (see [full example](examples)):
-
-```
-fetch('https://ntfy.sh/mytopic', {
-  method: 'POST', // PUT works too
-  body: 'Hello from the other side.'
-})
-```
-
-### Subscribe to a topic
-You can create and subscribe to a topic either in this web UI, or in your own app by subscribing to an
-[EventSource](https://developer.mozilla.org/en-US/docs/Web/API/EventSource), a JSON feed, or raw feed.
-
-#### Subscribe via web
-If you subscribe to a topic via this web UI in the field below, messages published to any subscribed topic
-will show up as **desktop notification**.
-
-You can try this easily on **[ntfy.sh](https://ntfy.sh)**.
-
-#### Subscribe via phone
-You can use the [Ntfy Android App](https://play.google.com/store/apps/details?id=io.heckel.ntfy) to receive 
-notifications directly on your phone. Just like the server, this app is also [open source](https://github.com/binwiederhier/ntfy-android).
-
-#### Subscribe via your app, or via the CLI
-Using [EventSource](https://developer.mozilla.org/en-US/docs/Web/API/EventSource) in JS, you can consume
-notifications like this (see [full example](examples)):
-
-```javascript
-const eventSource = new EventSource('https://ntfy.sh/mytopic/sse');<br/>
-eventSource.onmessage = (e) => {<br/>
-  // Do something with e.data<br/>
-};
-```
-
-You can also use the same `/sse` endpoint via `curl` or any other HTTP library:
-
-```
-$ curl -s ntfy.sh/mytopic/sse
-event: open
-data: {"id":"weSj9RtNkj","time":1635528898,"event":"open","topic":"mytopic"}
-
-data: {"id":"p0M5y6gcCY","time":1635528909,"event":"message","topic":"mytopic","message":"Hi!"}
-
-event: keepalive
-data: {"id":"VNxNIg5fpt","time":1635528928,"event":"keepalive","topic":"test"}
-```
-
-To consume JSON instead, use the `/json` endpoint, which prints one message per line:
-
-```
-$ curl -s ntfy.sh/mytopic/json
-{"id":"SLiKI64DOt","time":1635528757,"event":"open","topic":"mytopic"}
-{"id":"hwQ2YpKdmg","time":1635528741,"event":"message","topic":"mytopic","message":"Hi!"}
-{"id":"DGUDShMCsc","time":1635528787,"event":"keepalive","topic":"mytopic"}
-```
-
-Or use the `/raw` endpoint if you need something super simple (empty lines are keepalive messages):
-
-```
-$ curl -s ntfy.sh/mytopic/raw
-
-This is a notification
-```
-
-#### Message buffering and polling
-Messages are buffered in memory for a few hours to account for network interruptions of subscribers.
-You can read back what you missed by using the `since=...` query parameter. It takes either a
-duration (e.g. `10m` or `30s`) or a Unix timestamp (e.g. `1635528757`):
-
-```
-$ curl -s "ntfy.sh/mytopic/json?since=10m"
-# Same output as above, but includes messages from up to 10 minutes ago
-```
-
-You can also just poll for messages if you don't like the long-standing connection using the `poll=1`
-query parameter. The connection will end after all available messages have been read. This parameter has to be
-combined with `since=`.
-
-```
-$ curl -s "ntfy.sh/mytopic/json?poll=1&since=10m"
-# Returns messages from up to 10 minutes ago and ends the connection
-```
-
-## Examples
-There are a few usage examples in the [examples](examples) directory. I'm sure there are tons of other ways to use it.
-
-## Installation
-Please check out the [releases page](https://github.com/binwiederhier/ntfy/releases) for binaries and
-deb/rpm packages.
-
-1. Install ntfy using one of the methods described below
-2. Then (optionally) edit `/etc/ntfy/config.yml`
-3. Then just run it with `ntfy` (or `systemctl start ntfy` when using the deb/rpm).
-
-### Binaries and packages
-**Debian/Ubuntu** (*from a repository*)**:**
-```bash
-curl -sSL https://archive.heckel.io/apt/pubkey.txt | sudo apt-key add -
-sudo apt install apt-transport-https
-sudo sh -c "echo 'deb [arch=amd64] https://archive.heckel.io/apt debian main' > /etc/apt/sources.list.d/archive.heckel.io.list"  
-sudo apt update
-sudo apt install ntfy
-```
-
-**Debian/Ubuntu** (*manual install*)**:**
-```bash
-wget https://github.com/binwiederhier/ntfy/releases/download/v1.4.6/ntfy_1.4.6_amd64.deb
-dpkg -i ntfy_1.4.6_amd64.deb
-```
-
-**Fedora/RHEL/CentOS:**
-```bash
-rpm -ivh https://github.com/binwiederhier/ntfy/releases/download/v1.4.6/ntfy_1.4.6_amd64.rpm
-```
-
-**Docker:**
-Without cache:
-```
-docker run -p 80:80 -it binwiederhier/ntfy
-```
-
-With cache:
-```bash
-docker run \
-  -v /var/cache/ntfy:/var/cache/ntfy \
-  -p 80:80 \
-  -it \
-  binwiederhier/ntfy \
-    --cache-file /var/cache/ntfy/cache.db
-```
-
-**Go:**
-```bash
-go get -u heckel.io/ntfy
-```
-
-**Manual install:**
-```bash
-# x86_64/amd64
-wget https://github.com/binwiederhier/ntfy/releases/download/v1.4.6/ntfy_1.4.6_linux_x86_64.tar.gz
-
-# ARMv6
-wget https://github.com/binwiederhier/ntfy/releases/download/v1.4.6/ntfy_1.4.6_linux_armv6.tar.gz
-
-# ARMv7
-wget https://github.com/binwiederhier/ntfy/releases/download/v1.4.6/ntfy_1.4.6_linux_armv7.tar.gz
-
-# arm64
-wget https://github.com/binwiederhier/ntfy/releases/download/v1.4.6/ntfy_1.4.6_linux_arm64.tar.gz
-
-# Extract and run
-sudo tar -C /usr/bin -zxf ntfy_1.4.6_linux_x86_64.tar.gz ntfy
-./ntfy
-```
-
-## Building
-Building `ntfy` is simple. Here's how you do it:
-
-```
-make build-simple
-# Builds to dist/ntfy_linux_amd64/ntfy
-``` 
-
-To build releases, I use [GoReleaser](https://goreleaser.com/). If you have that installed, you can run `make build` or
-`make build-snapshot`.
+[Getting started](https://ntfy.sh/docs/) |
+[Android/iOS](https://ntfy.sh/docs/subscribe/phone/) |
+[API](https://ntfy.sh/docs/publish/) |
+[Install / Self-hosting](https://ntfy.sh/docs/install/) |
+[Building](https://ntfy.sh/docs/develop/)
 
 ## Contributing
 I welcome any and all contributions. Just create a PR or an issue.
 
+## Contact me
+You can directly contact me [on Slack](https://gophers.slack.com/archives/C01JMTPGF2Q), or via the [GitHub issues](https://github.com/binwiederhier/ntfy/issues),
+or find more contact information [on my website](https://heckel.io/about).
+
 ## License
 Made with ❤️ by [Philipp C. Heckel](https://heckel.io).   
 The project is dual licensed under the [Apache License 2.0](LICENSE) and the [GPLv2 License](LICENSE.GPLv2).
@@ -210,5 +50,6 @@ Third party libraries and resources:
 * [GoReleaser](https://goreleaser.com/) (MIT) is used to create releases
 * [github.com/mattn/go-sqlite3](https://github.com/mattn/go-sqlite3) (MIT) is used to provide the persistent message cache
 * [Firebase Admin SDK](https://github.com/firebase/firebase-admin-go) (Apache 2.0) is used to send FCM messages
+* [github/gemoji](https://github.com/github/gemoji) (MIT) is used for emoji support (specifically the [emoji.json](https://raw.githubusercontent.com/github/gemoji/master/db/emoji.json) file)
 * [Lightbox with vanilla JS](https://yossiabramov.com/blog/vanilla-js-lightbox) 
 * [Statically linking go-sqlite3](https://www.arp242.net/static-go.html)

cmd/app.go

@@ -18,7 +18,10 @@ import (
 func New() *cli.App {
 	flags := []cli.Flag{
 		&cli.StringFlag{Name: "config", Aliases: []string{"c"}, EnvVars: []string{"NTFY_CONFIG_FILE"}, Value: "/etc/ntfy/config.yml", DefaultText: "/etc/ntfy/config.yml", Usage: "config file"},
-		altsrc.NewStringFlag(&cli.StringFlag{Name: "listen-http", Aliases: []string{"l"}, EnvVars: []string{"NTFY_LISTEN_HTTP"}, Value: config.DefaultListenHTTP, Usage: "ip:port used to as listen address"}),
+		altsrc.NewStringFlag(&cli.StringFlag{Name: "listen-http", Aliases: []string{"l"}, EnvVars: []string{"NTFY_LISTEN_HTTP"}, Value: config.DefaultListenHTTP, Usage: "ip:port used to as HTTP listen address"}),
+		altsrc.NewStringFlag(&cli.StringFlag{Name: "listen-https", Aliases: []string{"L"}, EnvVars: []string{"NTFY_LISTEN_HTTPS"}, Usage: "ip:port used to as HTTPS listen address"}),
+		altsrc.NewStringFlag(&cli.StringFlag{Name: "key-file", Aliases: []string{"K"}, EnvVars: []string{"NTFY_KEY_FILE"}, Usage: "private key file, if listen-https is set"}),
+		altsrc.NewStringFlag(&cli.StringFlag{Name: "cert-file", Aliases: []string{"E"}, EnvVars: []string{"NTFY_CERT_FILE"}, Usage: "certificate file, if listen-https is set"}),
 		altsrc.NewStringFlag(&cli.StringFlag{Name: "firebase-key-file", Aliases: []string{"F"}, EnvVars: []string{"NTFY_FIREBASE_KEY_FILE"}, Usage: "Firebase credentials file; if set additionally publish to FCM topic"}),
 		altsrc.NewStringFlag(&cli.StringFlag{Name: "cache-file", Aliases: []string{"C"}, EnvVars: []string{"NTFY_CACHE_FILE"}, Usage: "cache file used for message caching"}),
 		altsrc.NewDurationFlag(&cli.DurationFlag{Name: "cache-duration", Aliases: []string{"b"}, EnvVars: []string{"NTFY_CACHE_DURATION"}, Value: config.DefaultCacheDuration, Usage: "buffer messages for this time to allow `since` requests"}),
@@ -50,6 +53,9 @@ func New() *cli.App {
 func execRun(c *cli.Context) error {
 	// Read all the options
 	listenHTTP := c.String("listen-http")
+	listenHTTPS := c.String("listen-https")
+	keyFile := c.String("key-file")
+	certFile := c.String("cert-file")
 	firebaseKeyFile := c.String("firebase-key-file")
 	cacheFile := c.String("cache-file")
 	cacheDuration := c.Duration("cache-duration")
@@ -68,12 +74,21 @@ func execRun(c *cli.Context) error {
 		return errors.New("keepalive interval cannot be lower than five seconds")
 	} else if managerInterval < 5*time.Second {
 		return errors.New("manager interval cannot be lower than five seconds")
-	} else if cacheDuration < managerInterval {
+	} else if cacheDuration > 0 && cacheDuration < managerInterval {
 		return errors.New("cache duration cannot be lower than manager interval")
+	} else if keyFile != "" && !util.FileExists(keyFile) {
+		return errors.New("if set, key file must exist")
+	} else if certFile != "" && !util.FileExists(certFile) {
+		return errors.New("if set, certificate file must exist")
+	} else if listenHTTPS != "" && (keyFile == "" || certFile == "") {
+		return errors.New("if listen-https is set, both key-file and cert-file must be set")
 	}
 
 	// Run server
 	conf := config.New(listenHTTP)
+	conf.ListenHTTPS = listenHTTPS
+	conf.KeyFile = keyFile
+	conf.CertFile = certFile
 	conf.FirebaseKeyFile = firebaseKeyFile
 	conf.CacheFile = cacheFile
 	conf.CacheDuration = cacheDuration

config/config.go

@@ -27,6 +27,9 @@ const (
 // Config is the main config struct for the application. Use New to instantiate a default config struct.
 type Config struct {
 	ListenHTTP                   string
+	ListenHTTPS                  string
+	KeyFile                      string
+	CertFile                     string
 	FirebaseKeyFile              string
 	CacheFile                    string
 	CacheDuration                time.Duration
@@ -43,6 +46,9 @@ type Config struct {
 func New(listenHTTP string) *Config {
 	return &Config{
 		ListenHTTP:                   listenHTTP,
+		ListenHTTPS:                  "",
+		KeyFile:                      "",
+		CertFile:                     "",
 		FirebaseKeyFile:              "",
 		CacheFile:                    "",
 		CacheDuration:                DefaultCacheDuration,

config/config.yml

@@ -5,24 +5,48 @@
 #
 # listen-http: ":80"
 
+# Listen address for the HTTPS web server. If set, you must also set "key-file" and "cert-file".
+# Format: <hostname>:<port>
+#
+# listen-https:
+
+# Path to the private key file for the HTTPS web server. Not used if "listen-https" is not set.
+# Format: <filename>
+#
+# key-file:
+
+# Path to the cert file for the HTTPS web server. Not used if "listen-https" is not set.
+# Format: <filename>
+#
+# cert-file:
+
 # If set, also publish messages to a Firebase Cloud Messaging (FCM) topic for your app.
-# This is optional and only required to support Android apps (which don't allow background services anymore).
+# This is optional and only required to save battery when using the Android app.
 #
 # firebase-key-file: <filename>
 
 # If set, messages are cached in a local SQLite database instead of only in-memory. This
 # allows for service restarts without losing messages in support of the since= parameter.
 #
+# To disable the cache entirely (on-disk/in-memory), set "cache-duration" to 0.
+#
+# Note: If you are running ntfy with systemd, make sure this cache file is owned by the
+#       ntfy user and group by running: chown ntfy.ntfy <filename>.
+#
 # cache-file: <filename>
 
 # Duration for which messages will be buffered before they are deleted.
 # This is required to support the "since=..." and "poll=1" parameter.
 #
+# You can disable the cache entirely by setting this to 0.
+#
 # cache-duration: 12h
 
 # Interval in which keepalive messages are sent to the client. This is to prevent
 # intermediaries closing the connection for inactivity.
 #
+# Note that the Android app has a hardcoded timeout at 77s, so it should be less than that.
+#
 # keepalive-interval: 30s
 
 # Interval in which the manager prunes old messages, deletes topics

config/config_test.go

@@ -0,0 +1,12 @@
+package config_test
+
+import (
+	"github.com/stretchr/testify/assert"
+	"heckel.io/ntfy/config"
+	"testing"
+)
+
+func TestConfig_New(t *testing.T) {
+	c := config.New(":1234")
+	assert.Equal(t, ":1234", c.ListenHTTP)
+}

config/ntfy.service

@@ -3,8 +3,12 @@ Description=ntfy server
 After=network.target
 
 [Service]
+User=ntfy
+Group=ntfy
 ExecStart=/usr/bin/ntfy
 Restart=on-failure
+AmbientCapabilities=CAP_NET_BIND_SERVICE
+LimitNOFILE=10000
 
 [Install]
 WantedBy=multi-user.target

docs/config.md

@@ -0,0 +1,348 @@
+# Configuring the ntfy server
+The ntfy server can be configured in three ways: using a config file (typically at `/etc/ntfy/config.yml`, 
+see [config.yml](https://github.com/binwiederhier/ntfy/blob/main/config/config.yml)), via command line arguments 
+or using environment variables.
+
+## Quick start
+By default, simply running `ntfy` will start the server at port 80. No configuration needed. Batteries included 😀. 
+If everything works as it should, you'll see something like this:
+```
+$ ntfy                
+2021/11/30 19:59:08 Listening on :80
+```
+
+You can immediately start [publishing messages](publish.md), or subscribe via the [Android app](subscribe/phone.md),
+[the web UI](subscribe/web.md), or simply via [curl or your favorite HTTP client](subscribe/api.md). To configure 
+the server further, check out the [config options table](#config-options) or simply type `ntfy --help` to
+get a list of [command line options](#command-line-options).
+
+## Message cache
+If desired, ntfy can temporarily keep notifications in an in-memory or an on-disk cache. Caching messages for a short period
+of time is important to allow [phones](subscribe/phone.md) and other devices with brittle Internet connections to be able to retrieve
+notifications that they may have missed. 
+
+By default, ntfy keeps messages **in-memory for 12 hours**, which means that **cached messages do not survive an application
+restart**. You can override this behavior using the following config settings:
+
+* `cache-file`: if set, ntfy will store messages in a SQLite based cache (default is empty, which means in-memory cache).
+  **This is required if you'd like messages to be retained across restarts**.
+* `cache-duration`: defines the duration for which messages are stored in the cache (default is `12h`). 
+
+You can also entirely disable the cache by setting `cache-duration` to `0`. When the cache is disabled, messages are only
+passed on to the connected subscribers, but never stored on disk or even kept in memory longer than is needed to forward
+the message to the subscribers.
+
+Subscribers can retrieve cached messaging using the [`poll=1` parameter](subscribe/api.md#polling), as well as the
+[`since=` parameter](subscribe/api.md#fetching-cached-messages).
+
+## Behind a proxy (TLS, etc.)
+!!! warning
+    If you are running ntfy behind a proxy, you must set the `behind-proxy` flag. Otherwise, all visitors are
+    [rate limited](#rate-limiting) as if they are one.
+
+It may be desirable to run ntfy behind a proxy, e.g. so you can provide TLS certificates using Let's Encrypt using certbot,
+or simply because you'd like to share the ports (80/443) with other services. Whatever your reasons may be, there are a 
+few things to consider. 
+
+### Rate limiting
+If you are running ntfy behind a proxy (e.g. nginx, HAproxy or Apache), you should set the `behind-proxy` 
+flag. This will instruct the [rate limiting](#rate-limiting) logic to use the `X-Forwarded-For` header as the primary 
+identifier for a visitor, as opposed to the remote IP address. If the `behind-proxy` flag is not set, all visitors will
+be counted as one, because from the perspective of the ntfy server, they all share the proxy's IP address.
+
+=== "/etc/ntfy/config.yml"
+    ```
+    # Tell ntfy to use "X-Forwarded-For" to identify visitors
+    behind-proxy: true
+    ```
+
+### TLS/SSL
+ntfy supports HTTPS/TLS by setting the `listen-https` [config option](#config-options). However, if you 
+are behind a proxy, it is recommended that TLS/SSL termination is done by the proxy itself (see below).
+
+I highly recommend using [certbot](https://certbot.eff.org/). I use it with the [dns-route53 plugin](https://certbot-dns-route53.readthedocs.io/en/stable/), 
+which lets you use [AWS Route 53](https://aws.amazon.com/route53/) as the challenge. That's much easier than using the
+HTTP challenge. I've found [this guide](https://nandovieira.com/using-lets-encrypt-in-development-with-nginx-and-aws-route53) to
+be incredibly helpful.
+
+### nginx/Apache2
+For your convenience, here's a working config that'll help configure things behind a proxy. In this 
+example, ntfy runs on `:2586` and we proxy traffic to it. We also redirect HTTP to HTTPS for GET requests against a topic
+or the root domain:
+
+=== "nginx (/etc/nginx/sites-*/ntfy)"
+    ```
+    server {
+      listen 80;
+      server_name ntfy.sh;
+
+      location / {
+        # Redirect HTTP to HTTPS, but only for GET topic addresses, since we want 
+        # it to work with curl without the annoying https:// prefix
+        set $redirect_https "";
+        if ($request_method = GET) {
+          set $redirect_https "yes";
+        }
+        if ($request_uri ~* "^/[-_a-z0-9]{0,64}$") {
+          set $redirect_https "${redirect_https}yes";
+        }
+        if ($redirect_https = "yesyes") {
+          return 302 https://$http_host$request_uri$is_args$query_string;
+        }
+
+        proxy_pass http://127.0.0.1:2586;
+        proxy_http_version 1.1;
+    
+        proxy_buffering off;
+        proxy_redirect off;
+     
+        proxy_set_header Host $http_host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    
+        proxy_connect_timeout 1m;
+        proxy_send_timeout 1m;
+        proxy_read_timeout 1m;
+      }
+    }
+    
+    server {
+      listen 443 ssl;
+      server_name ntfy.sh;
+    
+      ssl_session_cache builtin:1000 shared:SSL:10m;
+      ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
+      ssl_ciphers HIGH:!aNULL:!eNULL:!EXPORT:!CAMELLIA:!DES:!MD5:!PSK:!RC4;
+      ssl_prefer_server_ciphers on;
+    
+      ssl_certificate /etc/letsencrypt/live/ntfy.sh/fullchain.pem;
+      ssl_certificate_key /etc/letsencrypt/live/ntfy.sh/privkey.pem;
+    
+      location / {
+        proxy_pass http://127.0.0.1:2586;
+        proxy_http_version 1.1;
+    
+        proxy_buffering off;
+        proxy_redirect off;
+     
+        proxy_set_header Host $http_host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    
+        proxy_connect_timeout 1m;
+        proxy_send_timeout 1m;
+        proxy_read_timeout 1m;
+      }
+    }
+    ```
+
+=== "Apache2 (/etc/apache2/sites-*/ntfy.conf)"
+    ```
+    <VirtualHost *:80>
+        ServerName ntfy.sh
+        
+        SetEnv proxy-nokeepalive 1
+        SetEnv proxy-sendchunked 1
+        
+        ProxyPass / http://127.0.0.1:2586/
+        ProxyPassReverse / http://127.0.0.1:2586/
+        
+        # Higher than the max message size of 512k 
+        LimitRequestBody 102400
+        
+        # Redirect HTTP to HTTPS, but only for GET topic addresses, since we want 
+        # it to work with curl without the annoying https:// prefix 
+        RewriteEngine on
+        RewriteCond %{REQUEST_METHOD} GET
+        RewriteRule ^/([-_A-Za-z0-9]{0,64})$ https://%{SERVER_NAME}/$1 [R,L]
+    </VirtualHost>
+    
+    <VirtualHost *:443>
+        ServerName ntfy.sh
+        
+        SSLEngine on
+        SSLCertificateFile /etc/letsencrypt/live/ntfy.sh/fullchain.pem
+        SSLCertificateKeyFile /etc/letsencrypt/live/ntfy.sh/privkey.pem
+        Include /etc/letsencrypt/options-ssl-apache.conf
+        
+        SetEnv proxy-nokeepalive 1
+        SetEnv proxy-sendchunked 1
+        
+        ProxyPass / http://127.0.0.1:2586/
+        ProxyPassReverse / http://127.0.0.1:2586/
+        
+        # Higher than the max message size of 512k 
+        LimitRequestBody 102400
+        
+        # Redirect HTTP to HTTPS, but only for GET topic addresses, since we want 
+        # it to work with curl without the annoying https:// prefix 
+        RewriteEngine on
+        RewriteCond %{REQUEST_METHOD} GET
+        RewriteRule ^/([-_A-Za-z0-9]{0,64})$ https://%{SERVER_NAME}/$1 [R,L]
+    </VirtualHost>
+    ```
+
+## Firebase (FCM)
+!!! info
+    Using Firebase is **optional** and only works if you modify and [build your own Android .apk](develop.md#android-app).
+    For a self-hosted instance, it's easier to just not bother with FCM.
+
+[Firebase Cloud Messaging (FCM)](https://firebase.google.com/docs/cloud-messaging) is the Google approved way to send
+push messages to Android devices. FCM is the only method that an Android app can receive messages without having to run a
+[foreground service](https://developer.android.com/guide/components/foreground-services).
+
+For the main host [ntfy.sh](https://ntfy.sh), the [ntfy Android app](subscribe/phone.md) uses Firebase to send messages
+to the device. For other hosts, instant delivery is used and FCM is not involved.
+
+To configure FCM for your self-hosted instance of the ntfy server, follow these steps:
+
+1. Sign up for a [Firebase account](https://console.firebase.google.com/)
+2. Create a Firebase app and download the key file (e.g. `myapp-firebase-adminsdk-...json`)
+3. Place the key file in `/etc/ntfy`, set the `firebase-key-file` in `config.yml` accordingly and restart the ntfy server
+4. Build your own Android .apk following [these instructions](develop.md#android-app)
+
+Example:
+```
+# If set, also publish messages to a Firebase Cloud Messaging (FCM) topic for your app.
+# This is optional and only required to support Android apps (which don't allow background services anymore).
+#
+firebase-key-file: "/etc/ntfy/ntfy-sh-firebase-adminsdk-ahnce-9f4d6f14b5.json"
+```
+
+## Rate limiting
+!!! info
+    Be aware that if you are running ntfy behind a proxy, you must set the `behind-proxy` flag. 
+    Otherwise all visitors are rate limited as if they are one.
+
+By default, ntfy runs without authentication, so it is vitally important that we protect the server from abuse or overload.
+There are various limits and rate limits in place that you can use to configure the server. Let's do the easy ones first:
+
+* `global-topic-limit` defines the total number of topics before the server rejects new topics. It defaults to 5000.
+* `visitor-subscription-limit` is the number of subscriptions (open connections) per visitor. This value defaults to 30.
+
+A **visitor** is identified by its IP address (or the `X-Forwarded-For` header if `behind-proxy` is set). All config 
+options that start with the word `visitor` apply only on a per-visitor basis.   
+
+In addition to the limits above, there is a requests/second limit per visitor for all sensitive GET/PUT/POST requests.
+This limit uses a [token bucket](https://en.wikipedia.org/wiki/Token_bucket) (using Go's [rate package](https://pkg.go.dev/golang.org/x/time/rate)):
+
+Each visitor has a bucket of 60 requests they can fire against the server (defined by `visitor-request-limit-burst`). 
+After the 60, new requests will encounter a `429 Too Many Requests` response. The visitor request bucket is refilled at a rate of one
+request every 10s (defined by `visitor-request-limit-replenish`)
+
+* `visitor-request-limit-burst` is the initial bucket of requests each visitor has. This defaults to 60.
+* `visitor-request-limit-replenish` is the rate at which the bucket is refilled (one request per x). Defaults to 10s.
+
+During normal usage, you shouldn't encounter this limit at all, and even if you burst a few requests shortly (e.g. when you 
+reconnect after a connection drop), it shouldn't have any effect.
+
+
+## Tuning for scale
+If you're running ntfy for your home server, you probably don't need to worry about scale at all. In its default config,
+if it's not behind a proxy, the ntfy server can keep about **as many connections as the open file limit allows**.
+This limit is typically called `nofile`. Other than that, RAM and CPU are obviously relevant. You may also want to check
+out [this discussion on Reddit](https://www.reddit.com/r/golang/comments/r9u4ee/how_many_actively_connected_http_clients_can_a_go/).
+
+Depending on *how you run it*, here are a few limits that are relevant:
+
+### For systemd services
+If you're running ntfy in a systemd service (e.g. for .deb/.rpm packages), the main limiting factor is the
+`LimitNOFILE` setting in the systemd unit. The default open files limit for `ntfy.service` is 10000. You can override it
+by creating a `/etc/systemd/system/ntfy.service.d/override.conf` file. As far as I can tell, `/etc/security/limits.conf`
+is not relevant.
+
+=== "/etc/systemd/system/ntfy.service.d/override.conf"
+    ```
+    # Allow 20,000 ntfy connections (and give room for other file handles)
+    [Service]
+    LimitNOFILE=20500
+    ```
+
+### Outside of systemd
+If you're running outside systemd, you may want to adjust your `/etc/security/limits.conf` file to
+increase the `nofile` setting. Here's an example that increases the limit to 5000. You can find out the current setting
+by running `ulimit -n`, or manually override it temporarily by running `ulimit -n 50000`.
+
+=== "/etc/security/limits.conf"
+    ```
+    # Increase open files limit globally
+    * hard nofile 20500
+    ```
+
+### Proxy limits (nginx, Apache2)
+If you are running [behind a proxy](#behind-a-proxy-tls-etc) (e.g. nginx, Apache), the open files limit of the proxy is also
+relevant. So if your proxy runs inside of systemd, increase the limits in systemd for the proxy. Typically, the proxy
+open files limit has to be **double the number of how many connections you'd like to support**, because the proxy has
+to maintain the client connection and the connection to ntfy.
+
+=== "/etc/nginx/nginx.conf"
+    ```
+    events {
+      # Allow 40,000 proxy connections (2x of the desired ntfy connection count;
+      # and give room for other file handles)
+      worker_connections 40500;
+    }
+    ```
+=== "/etc/systemd/system/nginx.service.d/override.conf"
+    ```
+    # Allow 40,000 proxy connections (2x of the desired ntfy connection count;
+    # and give room for other file handles)
+    [Service]
+    LimitNOFILE=40500
+    ```
+
+## Config options
+Each config option can be set in the config file `/etc/ntfy/config.yml` (e.g. `listen-http: :80`) or as a
+CLI option (e.g. `--listen-http :80`. Here's a list of all available options. Alternatively, you can set an environment
+variable before running the `ntfy` command (e.g. `export NTFY_LISTEN_HTTP=:80`).
+
+| Config option | Env variable | Format | Default | Description |
+|---|---|---|---|---|
+| `listen-http` | `NTFY_LISTEN_HTTP` | `[host]:port` | `:80` | Listen address for the HTTP web server |
+| `listen-https` | `NTFY_LISTEN_HTTPS` | `[host]:port` | - | Listen address for the HTTPS web server. If set, you also need to set `key-file` and `cert-file`. |
+| `key-file` | `NTFY_KEY_FILE` | *filename* | - | HTTPS/TLS private key file, only used if `listen-https` is set. |
+| `cert-file` | `NTFY_CERT_FILE` | *filename* | - | HTTPS/TLS certificate file, only used if `listen-https` is set. |
+| `firebase-key-file` | `NTFY_FIREBASE_KEY_FILE` | *filename* | - | If set, also publish messages to a Firebase Cloud Messaging (FCM) topic for your app. This is optional and only required to save battery when using the Android app. See [Firebase (FCM](#firebase-fcm). |
+| `cache-file` | `NTFY_CACHE_FILE` | *filename* | - | If set, messages are cached in a local SQLite database instead of only in-memory. This allows for service restarts without losing messages in support of the since= parameter. See [message cache](#message-cache). |
+| `cache-duration` | `NTFY_CACHE_DURATION` | *duration* | 12h | Duration for which messages will be buffered before they are deleted. This is required to support the `since=...` and `poll=1` parameter. Set this to `0` to disable the cache entirely. |
+| `keepalive-interval` | `NTFY_KEEPALIVE_INTERVAL` | *duration* | 30s | Interval in which keepalive messages are sent to the client. This is to prevent intermediaries closing the connection for inactivity. Note that the Android app has a hardcoded timeout at 77s, so it should be less than that. |
+| `manager-interval` | `$NTFY_MANAGER_INTERVAL` | *duration* | 1m | Interval in which the manager prunes old messages, deletes topics and prints the stats. |
+| `global-topic-limit` | `NTFY_GLOBAL_TOPIC_LIMIT` | *number* | 5000 | Rate limiting: Total number of topics before the server rejects new topics. |
+| `visitor-subscription-limit` | `NTFY_VISITOR_SUBSCRIPTION_LIMIT` | *number* | 30 | Rate limiting: Number of subscriptions per visitor (IP address) |
+| `visitor-request-limit-burst` | `NTFY_VISITOR_REQUEST_LIMIT_BURST` | *number* | 60 | Allowed GET/PUT/POST requests per second, per visitor. This setting is the initial bucket of requests each visitor has |
+| `visitor-request-limit-replenish` | `NTFY_VISITOR_REQUEST_LIMIT_REPLENISH` | *duration* | 10s | Strongly related to `visitor-request-limit-burst`: The rate at which the bucket is refilled |
+| `behind-proxy` | `NTFY_BEHIND_PROXY` | *bool* | false | If set, the X-Forwarded-For header is used to determine the visitor IP address instead of the remote address of the connection. |
+
+The format for a *duration* is: `<number>(smh)`, e.g. 30s, 20m or 1h.
+
+## Command line options
+```
+$ ntfy --help
+NAME:
+   ntfy - Simple pub-sub notification service
+
+USAGE:
+   ntfy [OPTION..]
+
+GLOBAL OPTIONS:
+   --config value, -c value                           config file (default: /etc/ntfy/config.yml) [$NTFY_CONFIG_FILE]
+   --listen-http value, -l value                      ip:port used to as listen address (default: ":80") [$NTFY_LISTEN_HTTP]
+   --firebase-key-file value, -F value                Firebase credentials file; if set additionally publish to FCM topic [$NTFY_FIREBASE_KEY_FILE]
+   --cache-file value, -C value                       cache file used for message caching [$NTFY_CACHE_FILE]
+   --cache-duration since, -b since                   buffer messages for this time to allow since requests (default: 12h0m0s) [$NTFY_CACHE_DURATION]
+   --keepalive-interval value, -k value               interval of keepalive messages (default: 30s) [$NTFY_KEEPALIVE_INTERVAL]
+   --manager-interval value, -m value                 interval of for message pruning and stats printing (default: 1m0s) [$NTFY_MANAGER_INTERVAL]
+   --global-topic-limit value, -T value               total number of topics allowed (default: 5000) [$NTFY_GLOBAL_TOPIC_LIMIT]
+   --visitor-subscription-limit value, -V value       number of subscriptions per visitor (default: 30) [$NTFY_VISITOR_SUBSCRIPTION_LIMIT]
+   --visitor-request-limit-burst value, -B value      initial limit of requests per visitor (default: 60) [$NTFY_VISITOR_REQUEST_LIMIT_BURST]
+   --visitor-request-limit-replenish value, -R value  interval at which burst limit is replenished (one per x) (default: 10s) [$NTFY_VISITOR_REQUEST_LIMIT_REPLENISH]
+   --behind-proxy, -P                                 if set, use X-Forwarded-For header to determine visitor IP address (for rate limiting) (default: false) [$NTFY_BEHIND_PROXY]
+
+Try 'ntfy COMMAND --help' for more information.
+
+ntfy v1.4.8 (7b8185c), runtime go1.17, built at 1637872539
+Copyright (C) 2021 Philipp C. Heckel, distributed under the Apache License 2.0
+```
+

docs/develop.md

@@ -0,0 +1,71 @@
+# Building
+
+## ntfy server
+The ntfy server source code is available [on GitHub](https://github.com/binwiederhier/ntfy). 
+To quickly build on amd64, you can use `make build-simple`:
+
+```
+git clone git@github.com:binwiederhier/ntfy.git
+cd ntfy
+make build-simple
+```
+
+That'll generate a statically linked binary in `dist/ntfy_linux_amd64/ntfy`.
+
+For all other platforms (including Docker), and for production or other snapshot builds, you should use the amazingly 
+awesome [GoReleaser](https://goreleaser.com/) make targets:
+
+```
+Build:
+  make build                       - Build
+  make build-snapshot              - Build snapshot
+  make build-simple                - Build (using go build, without goreleaser)
+  make clean                       - Clean build folder
+
+Releasing (requires goreleaser):
+  make release                     - Create a release
+  make release-snapshot            - Create a test release
+```
+
+There are currently no platform-specific make targets, so they will build for all platforms (which may take a while).
+
+## Android app
+The ntfy Android app source code is available [on GitHub](https://github.com/binwiederhier/ntfy-android).
+The Android app has two flavors:
+
+* **Google Play:** The `play` flavor includes Firebase (FCM) and requires a Firebase account
+* **F-Droid:** The `fdroid` flavor does not include Firebase or Google dependencies
+
+First check out the repository:
+
+```
+git clone git@github.com:binwiederhier/ntfy-android.git
+cd ntfy-android
+```
+
+Then either follow the steps for building with or without Firebase.
+
+### Building without Firebase (F-Droid flavor)
+Without Firebase, you may want to still change the default `app_base_url` in [strings.xml](https://github.com/binwiederhier/ntfy-android/blob/main/app/src/main/res/values/strings.xml)
+if you're self-hosting the server. Then run:
+```
+# To build an unsigned .apk (app/build/outputs/apk/fdroid/*.apk)
+./gradlew assembleFdroidRelease
+
+# To build a bundle .aab (app/fdroid/release/*.aab)
+./gradlew bundleFdroidRelease
+```
+
+### Building with Firebase (FCM, Google Play flavor)
+To build your own version with Firebase, you must:
+* Create a Firebase/FCM account
+* Place your account file at `app/google-services.json`
+* And change `app_base_url` in [strings.xml](https://github.com/binwiederhier/ntfy-android/blob/main/app/src/main/res/values/strings.xml)
+* Then run:
+```
+# To build an unsigned .apk (app/build/outputs/apk/play/*.apk)
+./gradlew assemblePlayRelease
+
+# To build a bundle .aab (app/play/release/*.aab)
+./gradlew bundlePlayRelease
+```

docs/examples.md

@@ -0,0 +1,77 @@
+# Examples
+
+There are a million ways to use ntfy, but here are some inspirations. I try to collect
+<a href="https://github.com/binwiederhier/ntfy/tree/main/examples">examples on GitHub</a>, so be sure to check
+those out, too.
+
+## A long process is done: backups, copying data, pipelines, ...
+I started adding notifications pretty much all of my scripts. Typically, I just chain the <tt>curl</tt> call
+directly to the command I'm running. The following example will either send <i>Laptop backup succeeded</i>
+or ⚠️ <i>Laptop backup failed</i> directly to my phone:
+
+```
+rsync -a root@laptop /backups/laptop \
+  && zfs snapshot ... \
+  && curl -H prio:low -d "Laptop backup succeeded" ntfy.sh/backups \
+  || curl -H tags:warning -H prio:high -d "Laptop backup failed" ntfy.sh/backups
+```
+
+## Server-sent messages in your web app
+Just as you can [subscribe to topics in the Web UI](subscribe/web.md), you can use ntfy in your own
+web application. Check out the <a href="/example.html">live example</a> or just look the source of this page.
+
+## Notify on SSH login
+Years ago my home server was broken into. That shook me hard, so every time someone logs into any machine that I
+own, I now message myself. Here's an example of how to use <a href="https://en.wikipedia.org/wiki/Linux_PAM">PAM</a>
+to notify yourself on SSH login.
+
+=== "/etc/pam.d/sshd"
+    ```
+    # at the end of the file
+    session optional pam_exec.so /usr/bin/ntfy-ssh-login.sh
+    ```
+
+=== "/usr/bin/ntfy-ssh-login.sh"
+    ```bash
+    #!/bin/bash
+    if [ "${PAM_TYPE}" = "open_session" ]; then
+      curl \
+        -H prio:high \
+        -H tags:warning \
+        -d "SSH login: ${PAM_USER} from ${PAM_RHOST}" \
+        ntfy.sh/alerts
+    fi
+    ```
+
+## Collect data from multiple machines
+The other day I was running tasks on 20 servers, and I wanted to collect the interim results
+as a CSV in one place. Each of the servers was publishing to a topic as the results completed (`publish-result.sh`), 
+and I had one central collector to grab the results as they came in (`collect-results.sh`).
+
+It looked something like this:
+
+=== "collect-results.sh"
+    ```bash
+    while read result; do
+      [ -n "$result" ] && echo "$result" >> results.csv
+    done < <(stdbuf -i0 -o0 curl -s ntfy.sh/results/raw)
+    ```
+=== "publish-result.sh" 
+    ```bash
+    // This script was run on each of the 20 servers. It was doing heavy processing ...
+    
+    // Publish script results
+    curl -d "$(hostname),$count,$time" ntfy.sh/results
+    ```
+
+## Ansible, Salt and Puppet
+You can easily integrate ntfy into Ansible, Salt, or Puppet to notify you when runs are done or are highstated.
+One of my co-workers uses the following Ansible task to let him know when things are done:
+
+```yml
+- name: Send ntfy.sh update
+  uri:
+    url: "https://ntfy.sh/{{ ntfy_channel }}"
+    method: POST
+    body: "{{ inventory_hostname }} reseeding complete"
+```

docs/faq.md

@@ -0,0 +1,48 @@
+# Frequently asked questions (FAQ)
+
+## Isn't this like ...?
+Who knows. I didn't do a lot of research before making this. It was fun making it.
+
+## Can I use this in my app? Will it stay free?
+Yes. As long as you don't abuse it, it'll be available and free of charge. I do not plan on monetizing
+the service.
+
+## What are the uptime guarantees?
+Best effort.
+
+## What happens if there are multiple subscribers to the same topic?
+As per usual with pub-sub, all subscribers receive notifications if they are
+subscribed to a topic.
+
+## Will you know what topics exist, can you spy on me?
+If you don't trust me or your messages are sensitive, run your own server. It's <a href="https://github.com/binwiederhier/ntfy">open source</a>.
+That said, the logs do not contain any topic names or other details about you.
+Messages are cached for the duration configured in `config.yml` (12h by default) to facilitate service restarts, message polling and to overcome
+client network disruptions.
+
+## Can I self-host it?
+Yes. The server (including this Web UI) can be self-hosted, and the Android app supports adding topics from
+your own server as well. Check out the [install instructions](install.md).
+
+## Why is Firebase used?
+In addition to caching messages locally and delivering them to long-polling subscribers, all messages are also
+published to Firebase Cloud Messaging (FCM) (if `FirebaseKeyFile` is set, which it is on ntfy.sh). This
+is to facilitate notifications on Android. 
+
+If you do not care for Firebase, I suggest you install the [F-Droid version](https://f-droid.org/en/packages/io.heckel.ntfy/)
+of the app and [self-host your own ntfy server](install.md).
+
+## How much battery does the Android app use?
+If you use the ntfy.sh server and you don't use the [instant delivery](subscribe/phone.md#instant-delivery) feature, 
+the Android app uses no additional battery, since Firebase Cloud Messaging (FCM) is used. If you use your own server, 
+or you use *instant delivery*, the app has to maintain a constant connection to the server, which consumes about 4% of
+battery in 17h of use (on my phone). I use it, and it makes no difference to me.
+
+## What is instant delivery?
+[Instant delivery](subscribe/phone.md#instant-delivery) is a feature in the Android app. If turned on, the app maintains a constant connection to the
+server and listens for incoming notifications. This consumes <a href="#battery-usage">additional battery</a>,
+but delivers notifications instantly.
+
+## Why is there no iOS app (yet)?
+I don't have an iPhone or a Mac, so I didn't make an iOS app yet. It'd be awesome if
+<a href="https://github.com/binwiederhier/ntfy/issues/4">someone else could help out</a>.

docs/index.md

@@ -0,0 +1,83 @@
+# Getting started
+ntfy lets you **send push notifications to your phone or desktop via scripts from any computer**, using simple HTTP PUT
+or POST requests. I use it to notify myself when scripts fail, or long-running commands complete.
+
+## Step 1: Get the app
+<a href="https://play.google.com/store/apps/details?id=io.heckel.ntfy"><img src="../../static/img/badge-googleplay.png"></a>
+<a href="https://f-droid.org/en/packages/io.heckel.ntfy/"><img src="../../static/img/badge-fdroid.png"></a>
+<a href="https://github.com/binwiederhier/ntfy/issues/4"><img src="../../static/img/badge-appstore.png"></a>
+
+To [receive notifications on your phone](subscribe/phone.md), install the app, either via Google Play or F-Droid.
+Once installed, open it and subscribe to a topic of your choosing. Topics don't have to explicitly be created, so just
+pick a name and use it later when you [publish a message](publish.md). Note that **topic names are public, so it's wise 
+to choose something that cannot be guessed easily.** 
+
+For this guide, we'll just use `mytopic` as our topic name:
+
+<figure markdown>
+  ![adding a topic](static/img/getting-started-add.png){ width=500 }
+  <figcaption>Creating/adding your first topic</figcaption>
+</figure>
+
+That's it. After you tap "Subscribe", the app is listening for new messages on that topic.
+
+## Step 2: Send a message
+Now let's [send a message](publish.md) to our topic. It's easy in every language, since we're just using HTTP PUT or POST. The message
+is in the request body. Here's an example showing how to publish a simple message using a POST request:
+
+=== "Command line (curl)"
+    ```
+    curl -d "Backup successful 😀" ntfy.sh/mytopic
+    ```
+
+=== "HTTP"
+    ``` http
+    POST /mytopic HTTP/1.1
+    Host: ntfy.sh
+    
+    Backup successful 😀
+    ```
+
+=== "JavaScript"
+    ``` javascript
+    fetch('https://ntfy.sh/mytopic', {
+        method: 'POST', // PUT works too
+        body: 'Backup successful 😀'
+    })
+    ```
+
+=== "Go"
+    ``` go
+    http.Post("https://ntfy.sh/mytopic", "text/plain",
+       strings.NewReader("Backup successful 😀"))
+    ```
+
+=== "PHP"
+    ``` php-inline
+    file_get_contents('https://ntfy.sh/mytopic', false, stream_context_create([
+        'http' => [
+            'method' => 'POST', // PUT also works
+            'header' => 'Content-Type: text/plain',
+            'content' => 'Backup successful 😀'
+        ]
+    ]));
+    ```
+
+This will create a notification that looks like this:
+
+<figure markdown>
+  ![basic notification](static/img/basic-notification.png){ width=500 }
+  <figcaption>Android notification</figcaption>
+</figure>
+
+That's it. You're all set. Go play and read the rest of the docs. I highly recommend reading at least the page on
+[publishing messages](publish.md), as well as the detailed page on the [Android app](subscribe/phone.md).
+
+Here's another video showing the entire process:
+
+<figure>
+  <video controls muted autoplay loop width="650" src="static/img/overview.mp4"></video>
+  <figcaption>Sending push notifications to your Android phone</figcaption>
+</figure>
+
+

docs/install.md

@@ -0,0 +1,170 @@
+# Install your own ntfy server
+**Self-hosting your own ntfy server** is pretty straight forward. Just install the binary, package or Docker image, then 
+configure it and run it. Just like any other software. No fuzz. 
+
+!!! info
+    The following steps are only required if you want to **self-host your own ntfy server**. If you just want to 
+    [send messages using ntfy.sh](publish.md), you don't need to install anything.
+
+## General steps
+The ntfy server comes as a statically linked binary and is shipped as tarball, deb/rpm packages and as a Docker image.
+We support amd64, armv7 and arm64.
+
+1. Install ntfy using one of the methods described below
+2. Then (optionally) edit `/etc/ntfy/config.yml` (see [configuration](config.md))
+3. Then just run it with `ntfy` (or `systemctl start ntfy` when using the deb/rpm).
+
+## Binaries and packages
+Please check out the [releases page](https://github.com/binwiederhier/ntfy/releases) for binaries and
+deb/rpm packages.
+
+=== "x86_64/amd64"
+    ```bash
+    wget https://github.com/binwiederhier/ntfy/releases/download/v1.5.3/ntfy_1.5.3_linux_x86_64.tar.gz
+    sudo tar -C /usr/bin -zxf ntfy_*.tar.gz ntfy
+    sudo ./ntfy
+    ```
+
+=== "armv7/armhf"
+    ```bash
+    wget https://github.com/binwiederhier/ntfy/releases/download/v1.5.3/ntfy_1.5.3_linux_armv7.tar.gz
+    sudo tar -C /usr/bin -zxf ntfy_*.tar.gz ntfy
+    sudo ./ntfy
+    ```
+
+=== "arm64"
+    ```bash
+    wget https://github.com/binwiederhier/ntfy/releases/download/v1.5.3/ntfy_1.5.3_linux_arm64.tar.gz
+    sudo tar -C /usr/bin -zxf ntfy_*.tar.gz ntfy
+    sudo ./ntfy
+    ```
+
+## Debian/Ubuntu repository
+Installation via Debian repository:
+
+=== "x86_64/amd64"
+    ```bash
+    curl -sSL https://archive.heckel.io/apt/pubkey.txt | sudo apt-key add -
+    sudo apt install apt-transport-https
+    sudo sh -c "echo 'deb [arch=amd64] https://archive.heckel.io/apt debian main' \
+        > /etc/apt/sources.list.d/archive.heckel.io.list"  
+    sudo apt update
+    sudo apt install ntfy
+    sudo systemctl enable ntfy
+    sudo systemctl start ntfy
+    ```
+
+=== "armv7/armhf"
+    ```bash
+    curl -sSL https://archive.heckel.io/apt/pubkey.txt | sudo apt-key add -
+    sudo apt install apt-transport-https
+    sudo sh -c "echo 'deb [arch=armhf] https://archive.heckel.io/apt debian main' \
+        > /etc/apt/sources.list.d/archive.heckel.io.list"  
+    sudo apt update
+    sudo apt install ntfy
+    sudo systemctl enable ntfy
+    sudo systemctl start ntfy
+    ```
+
+=== "arm64"
+    ```bash
+    curl -sSL https://archive.heckel.io/apt/pubkey.txt | sudo apt-key add -
+    sudo apt install apt-transport-https
+    sudo sh -c "echo 'deb [arch=arm64] https://archive.heckel.io/apt debian main' \
+        > /etc/apt/sources.list.d/archive.heckel.io.list"  
+    sudo apt update
+    sudo apt install ntfy
+    sudo systemctl enable ntfy
+    sudo systemctl start ntfy
+    ```
+
+Manually installing the .deb file:
+
+=== "x86_64/amd64"
+    ```bash
+    wget https://github.com/binwiederhier/ntfy/releases/download/v1.5.3/ntfy_1.5.3_linux_amd64.deb
+    sudo dpkg -i ntfy_*.deb
+    sudo systemctl enable ntfy
+    sudo systemctl start ntfy
+    ```
+
+=== "armv7/armhf"
+    ```bash
+    wget https://github.com/binwiederhier/ntfy/releases/download/v1.5.3/ntfy_1.5.3_linux_armv7.deb
+    sudo dpkg -i ntfy_*.deb
+    sudo systemctl enable ntfy
+    sudo systemctl start ntfy
+    ```
+
+=== "arm64"
+    ```bash
+    wget https://github.com/binwiederhier/ntfy/releases/download/v1.5.3/ntfy_1.5.3_linux_arm64.deb
+    sudo dpkg -i ntfy_*.deb
+    sudo systemctl enable ntfy
+    sudo systemctl start ntfy
+    ```
+
+## Fedora/RHEL/CentOS
+
+=== "x86_64/amd64"
+    ```bash
+    sudo rpm -ivh https://github.com/binwiederhier/ntfy/releases/download/v1.5.3/ntfy_1.5.3_linux_amd64.rpm
+    sudo systemctl enable ntfy 
+    sudo systemctl start ntfy
+    ```
+
+=== "armv7/armhf"
+    ```bash
+    sudo rpm -ivh https://github.com/binwiederhier/ntfy/releases/download/v1.5.3/ntfy_1.5.3_linux_armv7.rpm
+    sudo systemctl enable ntfy 
+    sudo systemctl start ntfy
+    ```
+
+=== "arm64"
+    ```bash
+    sudo rpm -ivh https://github.com/binwiederhier/ntfy/releases/download/v1.5.3/ntfy_1.5.3_linux_arm64.rpm
+    sudo systemctl enable ntfy 
+    sudo systemctl start ntfy
+    ```
+
+## Docker
+The [ntfy image](https://hub.docker.com/r/binwiederhier/ntfy) is available for amd64, armv7 and arm64. It should be pretty
+straight forward to use.
+
+The server exposes its web UI and the API on port 80, so you need to expose that in Docker. To use the persistent 
+[message cache](config.md#message-cache), you also need to map a volume to `/var/cache/ntfy`. To change other settings, you should map `/etc/ntfy`,
+so you can edit `/etc/ntfy/config.yml`.
+
+Basic usage (no cache or additional config):
+```
+docker run -p 80:80 -it binwiederhier/ntfy
+```
+
+With persistent cache (configured as command line arguments):
+```bash
+docker run \
+  -v /var/cache/ntfy:/var/cache/ntfy \
+  -p 80:80 \
+  -it \
+  binwiederhier/ntfy \
+    --cache-file /var/cache/ntfy/cache.db
+```
+
+With other config options (configured via `/etc/ntfy/config.yml`, see [configuration](config.md) for details):
+```bash
+docker run \
+  -v /etc/ntfy:/etc/ntfy \
+  -p 80:80 \
+  -it \
+  binwiederhier/ntfy
+```
+
+## Go
+To install via Go, simply run:
+```bash
+go install heckel.io/ntfy@latest
+```
+
+!!! info
+    Please [let me know](https://github.com/binwiederhier/ntfy/issues) if there are any issues with this installation
+    method. The SQLite bindings require CGO and it works for me, but I have the feeling it may not work for everyone.

docs/privacy.md

@@ -0,0 +1,12 @@
+# Privacy policy
+
+I love free software, and I'm doing this because it's fun. I have no bad intentions, and **I will
+never monetize or sell your information, and this service and software will always stay free and open.**
+
+Neither the server nor the app record any personal information, or share any of the messages and topics with
+any outside service. All data is exclusively used to make the service function properly. The only external service
+I use is Firebase Cloud Messaging (FCM) service, which is required to provide instant Android notifications (see
+[FAQ](faq.md) for details). To avoid FCM altogether, download the F-Droid version.
+
+The web server does not log or otherwise store request paths, remote IP addresses or even topics or messages,
+aside from a short on-disk cache to support service restarts.

docs/publish.md

@@ -0,0 +1,452 @@
+# Publishing
+Publishing messages can be done via HTTP PUT or POST. Topics are created on the fly by subscribing or publishing to them.
+Because there is no sign-up, **the topic is essentially a password**, so pick something that's not easily guessable.
+
+Here's an example showing how to publish a simple message using a POST request:
+
+=== "Command line (curl)"
+    ```
+    curl -d "Backup successful 😀" ntfy.sh/mytopic
+    ```
+
+=== "HTTP"
+    ``` http
+    POST /mytopic HTTP/1.1
+    Host: ntfy.sh
+
+    Backup successful 😀
+    ```
+=== "JavaScript"
+    ``` javascript
+    fetch('https://ntfy.sh/mytopic', {
+      method: 'POST', // PUT works too
+      body: 'Backup successful 😀'
+    })
+    ```
+
+=== "Go"
+    ``` go
+    http.Post("https://ntfy.sh/mytopic", "text/plain",
+        strings.NewReader("Backup successful 😀"))
+    ```
+
+=== "PHP"
+    ``` php-inline
+    file_get_contents('https://ntfy.sh/mytopic', false, stream_context_create([
+        'http' => [
+            'method' => 'POST', // PUT also works
+            'header' => 'Content-Type: text/plain',
+            'content' => 'Backup successful 😀'
+        ]
+    ]));
+    ```
+
+If you have the [Android app](subscribe/phone.md) installed on your phone, this will create a notification that looks like this:
+
+<figure markdown>
+  ![basic notification](static/img/basic-notification.png){ width=500 }
+  <figcaption>Android notification</figcaption>
+</figure>
+
+There are more features related to publishing messages: You can set a [notification priority](#message-priority), 
+a [title](#message-title), and [tag messages](#tags-emojis) 🥳 🎉. Here's an example that uses some of them at together:
+
+=== "Command line (curl)"
+    ```
+    curl \
+      -H "Title: Unauthorized access detected" \
+      -H "Priority: urgent" \
+      -H "Tags: warning,skull" \
+      -d "Remote access to phils-laptop detected. Act right away." \
+      ntfy.sh/phil_alerts
+    ```
+
+=== "HTTP"
+    ``` http
+    POST /phil_alerts HTTP/1.1
+    Host: ntfy.sh
+    Title: Unauthorized access detected
+    Priority: urgent
+    Tags: warning,skull
+    
+    Remote access to phils-laptop detected. Act right away.
+    ```
+
+=== "JavaScript"
+    ``` javascript
+    fetch('https://ntfy.sh/phil_alerts', {
+        method: 'POST', // PUT works too
+        body: 'Remote access to phils-laptop detected. Act right away.',
+        headers: {
+            'Title': 'Unauthorized access detected',
+            'Priority': 'urgent',
+            'Tags': 'warning,skull'
+        }
+    })
+    ```
+
+=== "Go"
+    ``` go
+	req, _ := http.NewRequest("POST", "https://ntfy.sh/phil_alerts",
+		strings.NewReader("Remote access to phils-laptop detected. Act right away."))
+	req.Header.Set("Title", "Unauthorized access detected")
+	req.Header.Set("Priority", "urgent")
+	req.Header.Set("Tags", "warning,skull")
+	http.DefaultClient.Do(req)
+    ```
+
+=== "PHP"
+    ``` php-inline
+    file_get_contents('https://ntfy.sh/phil_alerts', false, stream_context_create([
+        'http' => [
+            'method' => 'POST', // PUT also works
+            'header' =>
+                "Content-Type: text/plain\r\n" .
+                "Title: Unauthorized access detected\r\n" .
+                "Priority: urgent\r\n" .
+                "Tags: warning,skull",
+            'content' => 'Remote access to phils-laptop detected. Act right away.'
+        ]
+    ]));
+    ```
+
+<figure markdown>
+  ![priority notification](static/img/priority-notification.png){ width=500 }
+  <figcaption>Urgent notification with tags and title</figcaption>
+</figure>
+
+## Message title
+The notification title is typically set to the topic short URL (e.g. `ntfy.sh/mytopic`). To override the title, 
+you can set the `X-Title` header (or any of its aliases: `Title`, `ti`, or `t`).
+
+=== "Command line (curl)"
+    ```
+    curl -H "X-Title: Dogs are better than cats" -d "Oh my ..." ntfy.sh/controversial
+    curl -H "Title: Dogs are better than cats" -d "Oh my ..." ntfy.sh/controversial
+    curl -H "t: Dogs are better than cats" -d "Oh my ..." ntfy.sh/controversial
+    ```
+
+=== "HTTP"
+    ``` http
+    POST /controversial HTTP/1.1
+    Host: ntfy.sh
+    Title: Dogs are better than cats
+    
+    Oh my ...
+    ```
+
+=== "JavaScript"
+    ``` javascript
+    fetch('https://ntfy.sh/controversial', {
+        method: 'POST',
+        body: 'Oh my ...',
+        headers: { 'Title': 'Dogs are better than cats' }
+    })
+    ```
+
+=== "Go"
+    ``` go
+    req, _ := http.NewRequest("POST", "https://ntfy.sh/controversial", strings.NewReader("Oh my ..."))
+    req.Header.Set("Title", "Dogs are better than cats")
+    http.DefaultClient.Do(req)
+    ```
+
+=== "PHP"
+    ``` php-inline
+    file_get_contents('https://ntfy.sh/controversial', false, stream_context_create([
+        'http' => [
+            'method' => 'POST',
+            'header' =>
+                "Content-Type: text/plain\r\n" .
+                "Title: Dogs are better than cats",
+            'content' => 'Oh my ...'
+        ]
+    ]));
+    ```
+
+<figure markdown>
+  ![notification with title](static/img/notification-with-title.png){ width=500 }
+  <figcaption>Detail view of notification with title</figcaption>
+</figure>
+
+## Message priority
+All messages have a priority, which defines how urgently your phone notifies you. You can set custom
+notification sounds and vibration patterns on your phone to map to these priorities (see [Android config](subscribe/phone.md)).
+
+The following priorities exist:
+
+| Priority | Icon | ID | Name | Description |
+|---|---|---|---|---|
+| Max priority | ![min priority](static/img/priority-5.svg) | `5` | `max`/`urgent` | Really long vibration bursts, default notification sound with a pop-over notification. |
+| High priority | ![min priority](static/img/priority-4.svg) | `4` | `high` | Long vibration burst, default notification sound with a pop-over notification. |
+| **Default priority** | *(none)* | `3` | `default` | Short default vibration and sound. Default notification behavior. |
+| Low priority | ![min priority](static/img/priority-2.svg) |`2` | `low` | No vibration or sound. Notification will not visibly show up until notification drawer is pulled down. |
+| Min priority | ![min priority](static/img/priority-1.svg) | `1` | `min` | No vibration or sound. The notification will be under the fold in "Other notifications". |
+
+You can set the priority with the header `X-Priority` (or any of its aliases: `Priority`, `prio`, or `p`).
+
+=== "Command line (curl)"
+    ```
+    curl -H "X-Priority: 5" -d "An urgent message" ntfy.sh/phil_alerts
+    curl -H "Priority: low" -d "Low priority message" ntfy.sh/phil_alerts
+    curl -H p:4 -d "A high priority message" ntfy.sh/phil_alerts
+    ```
+
+=== "HTTP"
+    ``` http
+    POST /phil_alerts HTTP/1.1
+    Host: ntfy.sh
+    Priority: 5
+
+    An urgent message
+    ```
+
+=== "JavaScript"
+    ``` javascript
+    fetch('https://ntfy.sh/phil_alerts', {
+        method: 'POST',
+        body: 'An urgent message',
+        headers: { 'Priority': '5' }
+    })
+    ```
+
+=== "Go"
+    ``` go
+    req, _ := http.NewRequest("POST", "https://ntfy.sh/phil_alerts", strings.NewReader("An urgent message"))
+    req.Header.Set("Priority", "5")
+    http.DefaultClient.Do(req)
+    ```
+
+=== "PHP"
+    ``` php-inline
+    file_get_contents('https://ntfy.sh/phil_alerts', false, stream_context_create([
+        'http' => [
+            'method' => 'POST',
+            'header' =>
+                "Content-Type: text/plain\r\n" .
+                "Priority: 5",
+            'content' => 'An urgent message'
+        ]
+    ]));
+    ```
+
+<figure markdown>
+  ![priority notification](static/img/priority-detail-overview.png){ width=500 }
+  <figcaption>Detail view of priority notifications</figcaption>
+</figure>
+
+## Tags & emojis 🥳 🎉
+You can tag messages with emojis and other relevant strings:
+
+* **Emojis**: If a tag matches an [emoji short code](emojis.md), it'll be converted to an emoji and prepended 
+  to title or message.
+* **Other tags:** If a tag doesn't match, it will be listed below the notification. 
+
+This feature is useful for things like warnings (⚠️, ️🚨, or 🚩), but also to simply tag messages otherwise (e.g. script 
+names, hostnames, etc.). Use [the emoji short code list](emojis.md) to figure out what tags can be converted to emojis. 
+Here's an **excerpt of emojis** I've found very useful in alert messages:
+
+<table class="remove-md-box"><tr>
+<td>
+    <table><thead><tr><th>Tag</th><th>Emoji</th></tr></thead><tbody>
+    <tr><td><code>+1</code></td><td>👍️</td></tr>
+    <tr><td><code>partying_face</code></td><td>🥳</td></tr>
+    <tr><td><code>tada</code></td><td>🎉</td></tr>
+    <tr><td><code>heavy_check_mark</code></td><td>✔️</td></tr>
+    <tr><td><code>loudspeaker</code></td><td>📢</td></tr>
+    <tr><td>...</td><td>...</td></tr>
+    </tbody></table>
+</td>
+<td>
+    <table><thead><tr><th>Tag</th><th>Emoji</th></tr></thead><tbody> 
+    <tr><td><code>-1</code></td><td>👎️</td></tr>
+    <tr><td><code>warning</code></td><td>⚠️</td></tr>
+    <tr><td><code>rotating_light</code></td><td>️🚨</td></tr>
+    <tr><td><code>triangular_flag_on_post</code></td><td>🚩</td></tr>
+    <tr><td><code>skull</code></td><td>💀</td></tr>
+    <tr><td>...</td><td>...</td></tr>
+    </tbody></table>
+</td>
+<td>
+    <table><thead><tr><th>Tag</th><th>Emoji</th></tr></thead><tbody>
+    <tr><td><code>facepalm</code></td><td>🤦</td></tr>
+    <tr><td><code>no_entry</code></td><td>⛔</td></tr>
+    <tr><td><code>no_entry_sign</code></td><td>🚫</td></tr>
+    <tr><td><code>cd</code></td><td>💿</td></tr> 
+    <tr><td><code>computer</code></td><td>💻</td></tr>
+    <tr><td>...</td><td>...</td></tr>
+    </tbody></table>
+</td>
+</tr></table>
+
+You can set tags with the `X-Tags` header (or any of its aliases: `Tags`, `tag`, or `ta`). Specify multiple tags by separating
+them with a comma, e.g. `tag1,tag2,tag3`.
+
+=== "Command line (curl)"
+    ```
+    curl -H "X-Tags: warning,mailsrv13,daily-backup" -d "Backup of mailsrv13 failed" ntfy.sh/backups
+    curl -H "Tags: horse,unicorn" -d "Unicorns are just horses with unique horns" ntfy.sh/backups
+    curl -H ta:dog -d "Dogs are awesome" ntfy.sh/backups
+    ```
+
+=== "HTTP"
+    ``` http
+    POST /backups HTTP/1.1
+    Host: ntfy.sh
+    Tags: warning,mailsrv13,daily-backup
+    
+    Backup of mailsrv13 failed
+    ```
+
+=== "JavaScript"
+    ``` javascript
+    fetch('https://ntfy.sh/backups', {
+        method: 'POST',
+        body: 'Backup of mailsrv13 failed',
+        headers: { 'Tags': 'warning,mailsrv13,daily-backup' }
+    })
+    ```
+
+=== "Go"
+    ``` go
+    req, _ := http.NewRequest("POST", "https://ntfy.sh/backups", strings.NewReader("Backup of mailsrv13 failed"))
+    req.Header.Set("Tags", "warning,mailsrv13,daily-backup")
+    http.DefaultClient.Do(req)
+    ```
+
+=== "PHP"
+    ``` php-inline
+    file_get_contents('https://ntfy.sh/backups', false, stream_context_create([
+        'http' => [
+            'method' => 'POST',
+            'header' =>
+                "Content-Type: text/plain\r\n" .
+                "Tags: warning,mailsrv13,daily-backup",
+            'content' => 'Backup of mailsrv13 failed'
+        ]
+    ]));
+    ```
+
+<figure markdown>
+  ![priority notification](static/img/notification-with-tags.png){ width=500 }
+  <figcaption>Detail view of notifications with tags</figcaption>
+</figure>
+
+## Advanced features
+
+### Message caching
+!!! info
+    If `Cache: no` is used, messages will only be delivered to connected subscribers, and won't be re-delivered if a 
+    client re-connects. If a subscriber has (temporary) network issues or is reconnecting momentarily, 
+    **messages might be missed**.
+
+By default, the ntfy server caches messages on disk for 12 hours (see [message caching](config.md#message-cache)), so
+all messages you publish are stored server-side for a little while. The reason for this is to overcome temporary 
+client-side network disruptions, but arguably this feature also may raise privacy concerns.
+
+To avoid messages being cached server-side entirely, you can set `X-Cache` header (or its alias: `Cache`) to `no`. 
+This will make sure that your message is not cached on the server, even if server-side caching is enabled. Messages
+are still delivered to connected subscribers, but [`since=`](subscribe/api.md#fetching-cached-messages) and 
+[`poll=1`](subscribe/api.md#polling) won't return the message anymore.
+
+=== "Command line (curl)"
+    ```
+    curl -H "X-Cache: no" -d "This message won't be stored server-side" ntfy.sh/mytopic
+    curl -H "Cache: no" -d "This message won't be stored server-side" ntfy.sh/mytopic
+    ```
+
+=== "HTTP"
+    ``` http
+    POST /mytopic HTTP/1.1
+    Host: ntfy.sh
+    Cache: no
+
+    This message won't be stored server-side
+    ```
+
+=== "JavaScript"
+    ``` javascript
+    fetch('https://ntfy.sh/mytopic', {
+        method: 'POST',
+        body: 'This message won't be stored server-side',
+        headers: { 'Cache': 'no' }
+    })
+    ```
+
+=== "Go"
+    ``` go
+    req, _ := http.NewRequest("POST", "https://ntfy.sh/mytopic", strings.NewReader("This message won't be stored server-side"))
+    req.Header.Set("Cache", "no")
+    http.DefaultClient.Do(req)
+    ```
+
+=== "PHP"
+    ``` php-inline
+    file_get_contents('https://ntfy.sh/mytopic', false, stream_context_create([
+        'http' => [
+            'method' => 'POST',
+            'header' =>
+                "Content-Type: text/plain\r\n" .
+                "Cache: no",
+            'content' => 'This message won't be stored server-side'
+        ]
+    ]));
+    ```
+
+### Firebase
+!!! info
+    If `Firebase: no` is used and [instant delivery](subscribe/phone.md#instant-delivery) isn't enabled in the Android 
+    app (Google Play variant only), **message delivery will be significantly delayed (up to 15 minutes)**. To overcome 
+    this delay, simply enable instant delivery.
+
+The ntfy server can be configured to use [Firebase Cloud Messaging (FCM)](https://firebase.google.com/docs/cloud-messaging)
+(see [Firebase config](config.md#firebase-fcm)) for message delivery on Android (to minimize the app's battery footprint). 
+The ntfy.sh server is configured this way, meaning that all messages published to ntfy.sh are also published to corresponding
+FCM topics.
+
+If you'd like to avoid forwarding messages to Firebase, you can set the `X-Firebase` header (or its alias: `Firebase`)
+to `no`. This will instruct the server not to forward messages to Firebase.
+
+=== "Command line (curl)"
+    ```
+    curl -H "X-Firebase: no" -d "This message won't be forwarded to FCM" ntfy.sh/mytopic
+    curl -H "Firebase: no" -d "This message won't be forwarded to FCM" ntfy.sh/mytopic
+    ```
+
+=== "HTTP"
+    ``` http
+    POST /mytopic HTTP/1.1
+    Host: ntfy.sh
+    Firebase: no
+
+    This message won't be forwarded to FCM
+    ```
+
+=== "JavaScript"
+    ``` javascript
+    fetch('https://ntfy.sh/mytopic', {
+        method: 'POST',
+        body: 'This message won't be forwarded to FCM',
+        headers: { 'Firebase': 'no' }
+    })
+    ```
+
+=== "Go"
+    ``` go
+    req, _ := http.NewRequest("POST", "https://ntfy.sh/mytopic", strings.NewReader("This message won't be forwarded to FCM"))
+    req.Header.Set("Firebase", "no")
+    http.DefaultClient.Do(req)
+    ```
+
+=== "PHP"
+    ``` php-inline
+    file_get_contents('https://ntfy.sh/mytopic', false, stream_context_create([
+        'http' => [
+            'method' => 'POST',
+            'header' =>
+                "Content-Type: text/plain\r\n" .
+                "Firebase: no",
+            'content' => 'This message won't be stored server-side'
+        ]
+    ]));
+    ```

docs/static/css/extra.css

@@ -0,0 +1,115 @@
+:root {
+    --md-primary-fg-color:        #3a9784;
+    --md-primary-fg-color--light: #3a9784;
+    --md-primary-fg-color--dark:  #3a9784;
+}
+
+.md-header__button.md-logo :is(img, svg) {
+    width: unset !important;
+}
+
+article {
+    padding-bottom: 50px;
+}
+
+figure img, figure video {
+    border-radius: 7px;
+}
+
+body[data-md-color-scheme="default"] figure img, body[data-md-color-scheme="default"] figure video {
+    filter: drop-shadow(3px 3px 3px #ccc);
+}
+
+body[data-md-color-scheme="slate"] figure img, body[data-md-color-scheme="slate"] figure video {
+    filter: drop-shadow(3px 3px 3px #1a1313);
+}
+
+figure video {
+    width: 100%;
+    max-height: 450px;
+}
+
+.remove-md-box {
+    background: none;
+    border: none;
+    margin: 0 auto;
+}
+
+.remove-md-box td {
+    padding: 0 10px
+}
+
+/* Lightbox; thanks to https://yossiabramov.com/blog/vanilla-js-lightbox */
+
+.screenshots {
+    text-align: center;
+}
+
+.screenshots img {
+    height: 230px;
+    margin: 3px;
+    border-radius: 5px;
+    filter: drop-shadow(2px 2px 2px #ddd);
+}
+
+.screenshots .nowrap {
+    white-space: nowrap;
+}
+
+.lightbox {
+    opacity: 0;
+    visibility: hidden;
+    position: fixed;
+    left:0;
+    right: 0;
+    top: 0;
+    bottom: 0;
+    z-index: -1;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    transition: all 0.15s ease-in;
+}
+
+.lightbox.show {
+    background-color: rgba(0,0,0, 0.75);
+    opacity: 1;
+    visibility: visible;
+    z-index: 1000;
+}
+
+.lightbox img {
+    max-width: 90%;
+    max-height: 90%;
+    filter: drop-shadow(5px 5px 10px #222);
+    border-radius: 5px;
+}
+
+.lightbox .close-lightbox {
+    cursor: pointer;
+    position: absolute;
+    top: 30px;
+    right: 30px;
+    width: 20px;
+    height: 20px;
+}
+
+.lightbox .close-lightbox::after,
+.lightbox .close-lightbox::before {
+    content: '';
+    width: 3px;
+    height: 20px;
+    background-color: #ddd;
+    position: absolute;
+    border-radius: 5px;
+    transform: rotate(45deg);
+}
+
+.lightbox .close-lightbox::before {
+    transform: rotate(-45deg);
+}
+
+.lightbox .close-lightbox:hover::after,
+.lightbox .close-lightbox:hover::before {
+    background-color: #fff;
+}

docs/static/img/priority-1.svg

@@ -0,0 +1,47 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   height="24px"
+   viewBox="0 0 24 24"
+   width="24px"
+   fill="#000000"
+   version="1.1"
+   id="svg1428"
+   sodipodi:docname="priority_1_24dp.svg"
+   inkscape:version="1.1.1 (3bf5ae0, 2021-09-20)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <defs
+     id="defs1432" />
+  <sodipodi:namedview
+     id="namedview1430"
+     pagecolor="#505050"
+     bordercolor="#eeeeee"
+     borderopacity="1"
+     inkscape:pageshadow="0"
+     inkscape:pageopacity="0"
+     inkscape:pagecheckerboard="0"
+     showgrid="false"
+     inkscape:zoom="20.517358"
+     inkscape:cx="22.834324"
+     inkscape:cy="15.742768"
+     inkscape:window-width="1863"
+     inkscape:window-height="1025"
+     inkscape:window-x="57"
+     inkscape:window-y="27"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg1428" />
+  <path
+     style="color:#000000;fill:#999999;fill-opacity:1;stroke-width:0.0919748;stroke-linecap:round;stroke-linejoin:round;-inkscape-stroke:none"
+     d="m 12.195014,20.828316 a 1.2747098,1.2747098 0 0 0 0.661605,-0.185206 l 6.646593,-4.037178 a 1.2745823,1.2745823 0 0 0 0.427537,-1.751107 1.2745823,1.2745823 0 0 0 -1.750928,-0.427718 l -5.984807,3.635327 -5.9848086,-3.635327 a 1.2745823,1.2745823 0 0 0 -1.750927,0.427718 1.2745823,1.2745823 0 0 0 0.427536,1.751107 l 6.6464146,4.037178 a 1.2747098,1.2747098 0 0 0 0.661785,0.185206 z"
+     id="rect3554" />
+  <path
+     style="color:#000000;fill:#b3b3b3;fill-opacity:1;stroke:none;stroke-width:0.0919748;stroke-linecap:round;stroke-linejoin:round;-inkscape-stroke:none"
+     d="m 12.195014,15.694014 a 1.2747098,1.2747098 0 0 0 0.661605,-0.185206 l 6.646593,-4.037176 A 1.2745823,1.2745823 0 0 0 19.930749,9.7205243 1.2745823,1.2745823 0 0 0 18.179821,9.2928073 L 12.195014,12.928134 6.2102054,9.2928073 a 1.2745823,1.2745823 0 0 0 -1.750927,0.427717 1.2745823,1.2745823 0 0 0 0.427536,1.7511077 l 6.6464146,4.037176 a 1.2747098,1.2747098 0 0 0 0.661785,0.185206 z"
+     id="path9314" />
+  <path
+     style="color:#000000;fill:#cccccc;fill-opacity:1;stroke:none;stroke-width:0.0919748;stroke-linecap:round;stroke-linejoin:round;-inkscape-stroke:none"
+     d="m 12.116784,10.426777 a 1.2747098,1.2747098 0 0 0 0.661606,-0.185205 l 6.646593,-4.0371767 a 1.2745823,1.2745823 0 0 0 0.427537,-1.751108 1.2745823,1.2745823 0 0 0 -1.750928,-0.427718 l -5.984808,3.635327 -5.9848066,-3.635327 a 1.2745823,1.2745823 0 0 0 -1.750928,0.427718 1.2745823,1.2745823 0 0 0 0.427537,1.751108 L 11.455,10.241572 a 1.2747098,1.2747098 0 0 0 0.661784,0.185205 z"
+     id="path9316" />
+</svg>

docs/static/img/priority-2.svg

@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   height="24px"
+   viewBox="0 0 24 24"
+   width="24px"
+   fill="#000000"
+   version="1.1"
+   id="svg1428"
+   sodipodi:docname="priority_2_24dp.svg"
+   inkscape:version="1.1.1 (3bf5ae0, 2021-09-20)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <defs
+     id="defs1432" />
+  <sodipodi:namedview
+     id="namedview1430"
+     pagecolor="#505050"
+     bordercolor="#eeeeee"
+     borderopacity="1"
+     inkscape:pageshadow="0"
+     inkscape:pageopacity="0"
+     inkscape:pagecheckerboard="0"
+     showgrid="false"
+     inkscape:zoom="20.517358"
+     inkscape:cx="22.834324"
+     inkscape:cy="15.742768"
+     inkscape:window-width="1863"
+     inkscape:window-height="1025"
+     inkscape:window-x="57"
+     inkscape:window-y="27"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg1428" />
+  <path
+     style="color:#000000;fill:#999999;fill-opacity:1;stroke-width:0.0919748;stroke-linecap:round;stroke-linejoin:round;-inkscape-stroke:none"
+     d="m 12.172712,17.774352 a 1.2747098,1.2747098 0 0 0 0.661605,-0.185206 l 6.646593,-4.037178 a 1.2745823,1.2745823 0 0 0 0.427537,-1.751107 1.2745823,1.2745823 0 0 0 -1.750928,-0.427718 L 12.172712,15.00847 6.1879033,11.373143 a 1.2745823,1.2745823 0 0 0 -1.750927,0.427718 1.2745823,1.2745823 0 0 0 0.427536,1.751107 l 6.6464147,4.037178 a 1.2747098,1.2747098 0 0 0 0.661785,0.185206 z"
+     id="rect3554" />
+  <path
+     style="color:#000000;fill:#b3b3b3;fill-opacity:1;stroke:none;stroke-width:0.0919748;stroke-linecap:round;stroke-linejoin:round;-inkscape-stroke:none"
+     d="m 12.172712,12.64005 a 1.2747098,1.2747098 0 0 0 0.661605,-0.185206 L 19.48091,8.4176679 A 1.2745823,1.2745823 0 0 0 19.908447,6.6665602 1.2745823,1.2745823 0 0 0 18.157519,6.2388432 L 12.172712,9.8741699 6.1879033,6.2388432 a 1.2745823,1.2745823 0 0 0 -1.750927,0.427717 1.2745823,1.2745823 0 0 0 0.427536,1.7511077 l 6.6464147,4.0371761 a 1.2747098,1.2747098 0 0 0 0.661785,0.185206 z"
+     id="path9314" />
+</svg>

docs/static/img/priority-4.svg

@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   height="24px"
+   viewBox="0 0 24 24"
+   width="24px"
+   fill="#000000"
+   version="1.1"
+   id="svg1428"
+   sodipodi:docname="priority_4_24dp.svg"
+   inkscape:version="1.1.1 (3bf5ae0, 2021-09-20)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <defs
+     id="defs1432" />
+  <sodipodi:namedview
+     id="namedview1430"
+     pagecolor="#505050"
+     bordercolor="#eeeeee"
+     borderopacity="1"
+     inkscape:pageshadow="0"
+     inkscape:pageopacity="0"
+     inkscape:pagecheckerboard="0"
+     showgrid="false"
+     inkscape:zoom="20.517358"
+     inkscape:cx="22.834324"
+     inkscape:cy="15.742768"
+     inkscape:window-width="1863"
+     inkscape:window-height="1025"
+     inkscape:window-x="57"
+     inkscape:window-y="27"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg1428" />
+  <path
+     style="color:#000000;fill:#c60000;fill-opacity:1;stroke:none;stroke-width:0.0919748;stroke-linecap:round;stroke-linejoin:round;-inkscape-stroke:none"
+     d="M 12.116784,6.5394415 A 1.2747098,1.2747098 0 0 0 11.455179,6.724648 l -6.6465926,4.037176 a 1.2745823,1.2745823 0 0 0 -0.427537,1.751108 1.2745823,1.2745823 0 0 0 1.7509281,0.427717 l 5.9848065,-3.635327 5.984809,3.635327 A 1.2745823,1.2745823 0 0 0 19.85252,12.512932 1.2745823,1.2745823 0 0 0 19.424984,10.761824 L 12.778569,6.724648 A 1.2747098,1.2747098 0 0 0 12.116784,6.5394415 Z"
+     id="path9314" />
+  <path
+     style="color:#000000;fill:#de0000;fill-opacity:1;stroke:none;stroke-width:0.0919748;stroke-linecap:round;stroke-linejoin:round;-inkscape-stroke:none"
+     d="m 12.195014,11.806679 a 1.2747098,1.2747098 0 0 0 -0.661606,0.185205 l -6.6465924,4.037177 a 1.2745823,1.2745823 0 0 0 -0.427537,1.751108 1.2745823,1.2745823 0 0 0 1.750928,0.427718 l 5.9848074,-3.635327 5.984807,3.635327 a 1.2745823,1.2745823 0 0 0 1.750928,-0.427718 1.2745823,1.2745823 0 0 0 -0.427537,-1.751108 l -6.646414,-4.037177 a 1.2747098,1.2747098 0 0 0 -0.661784,-0.185205 z"
+     id="path9316" />
+</svg>

docs/static/img/priority-5.svg

@@ -0,0 +1,47 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   height="24px"
+   viewBox="0 0 24 24"
+   width="24px"
+   fill="#000000"
+   version="1.1"
+   id="svg1428"
+   sodipodi:docname="priority_5_24dp.svg"
+   inkscape:version="1.1.1 (3bf5ae0, 2021-09-20)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <defs
+     id="defs1432" />
+  <sodipodi:namedview
+     id="namedview1430"
+     pagecolor="#505050"
+     bordercolor="#eeeeee"
+     borderopacity="1"
+     inkscape:pageshadow="0"
+     inkscape:pageopacity="0"
+     inkscape:pagecheckerboard="0"
+     showgrid="false"
+     inkscape:zoom="20.517358"
+     inkscape:cx="22.834323"
+     inkscape:cy="15.742767"
+     inkscape:window-width="1863"
+     inkscape:window-height="1025"
+     inkscape:window-x="57"
+     inkscape:window-y="27"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg1428" />
+  <path
+     style="color:#000000;fill:#aa0000;fill-opacity:1;stroke-width:0.0919748;stroke-linecap:round;stroke-linejoin:round;-inkscape-stroke:none"
+     d="M 12.116784,3.40514 A 1.2747098,1.2747098 0 0 0 11.455179,3.5903463 L 4.8085864,7.6275238 A 1.2745823,1.2745823 0 0 0 4.3810494,9.3786313 1.2745823,1.2745823 0 0 0 6.1319775,9.8063489 L 12.116784,6.1710217 18.101593,9.8063489 A 1.2745823,1.2745823 0 0 0 19.85252,9.3786313 1.2745823,1.2745823 0 0 0 19.424984,7.6275238 L 12.778569,3.5903463 A 1.2747098,1.2747098 0 0 0 12.116784,3.40514 Z"
+     id="rect3554" />
+  <path
+     style="color:#000000;fill:#c60000;fill-opacity:1;stroke:none;stroke-width:0.0919748;stroke-linecap:round;stroke-linejoin:round;-inkscape-stroke:none"
+     d="M 12.116784,8.5394415 A 1.2747098,1.2747098 0 0 0 11.455179,8.724648 l -6.6465926,4.037176 a 1.2745823,1.2745823 0 0 0 -0.427537,1.751108 1.2745823,1.2745823 0 0 0 1.7509281,0.427717 l 5.9848065,-3.635327 5.984809,3.635327 A 1.2745823,1.2745823 0 0 0 19.85252,14.512932 1.2745823,1.2745823 0 0 0 19.424984,12.761824 L 12.778569,8.724648 A 1.2747098,1.2747098 0 0 0 12.116784,8.5394415 Z"
+     id="path9314" />
+  <path
+     style="color:#000000;fill:#de0000;fill-opacity:1;stroke:none;stroke-width:0.0919748;stroke-linecap:round;stroke-linejoin:round;-inkscape-stroke:none"
+     d="m 12.195014,13.806679 a 1.2747098,1.2747098 0 0 0 -0.661606,0.185205 l -6.6465924,4.037177 a 1.2745823,1.2745823 0 0 0 -0.427537,1.751108 1.2745823,1.2745823 0 0 0 1.750928,0.427718 l 5.9848074,-3.635327 5.984807,3.635327 a 1.2745823,1.2745823 0 0 0 1.750928,-0.427718 1.2745823,1.2745823 0 0 0 -0.427537,-1.751108 l -6.646414,-4.037177 a 1.2747098,1.2747098 0 0 0 -0.661784,-0.185205 z"
+     id="path9316" />
+</svg>

docs/static/js/extra.js

@@ -0,0 +1,99 @@
+// Link tabs, as per https://facelessuser.github.io/pymdown-extensions/extensions/tabbed/#linked-tabs
+
+const savedTab = localStorage.getItem('savedTab')
+const tabs = document.querySelectorAll(".tabbed-set > input")
+for (const tab of tabs) {
+    tab.addEventListener("click", () => {
+        const current = document.querySelector(`label[for=${tab.id}]`)
+        const pos = current.getBoundingClientRect().top
+        const labelContent = current.innerHTML
+        const labels = document.querySelectorAll('.tabbed-set > label, .tabbed-alternate > .tabbed-labels > label')
+        for (const label of labels) {
+            if (label.innerHTML === labelContent) {
+                document.querySelector(`input[id=${label.getAttribute('for')}]`).checked = true
+            }
+        }
+
+        // Preserve scroll position
+        const delta = (current.getBoundingClientRect().top) - pos
+        window.scrollBy(0, delta)
+
+        // Save
+        localStorage.setItem('savedTab', labelContent)
+    })
+
+    // Select saved tab
+    const current = document.querySelector(`label[for=${tab.id}]`)
+    const labelContent = current.innerHTML
+    if (savedTab === labelContent) {
+        tab.checked = true
+    }
+}
+
+// Lightbox for screenshot
+
+const lightbox = document.createElement('div');
+lightbox.classList.add('lightbox');
+document.body.appendChild(lightbox);
+
+const showScreenshotOverlay = (e, el, group, index) => {
+    lightbox.classList.add('show');
+    document.addEventListener('keydown', nextScreenshotKeyboardListener);
+    return showScreenshot(e, group, index);
+};
+
+const showScreenshot = (e, group, index) => {
+    const actualIndex = resolveScreenshotIndex(group, index);
+    lightbox.innerHTML = '<div class="close-lightbox"></div>' + screenshots[group][actualIndex].innerHTML;
+    lightbox.querySelector('img').onclick = (e) => { return showScreenshot(e, group, actualIndex+1); };
+    currentScreenshotGroup = group;
+    currentScreenshotIndex = actualIndex;
+    e.stopPropagation();
+    return false;
+};
+
+const nextScreenshot = (e) => {
+    return showScreenshot(e, currentScreenshotGroup, currentScreenshotIndex+1);
+};
+
+const previousScreenshot = (e) => {
+    return showScreenshot(e, currentScreenshotGroup, currentScreenshotIndex-1);
+};
+
+const resolveScreenshotIndex = (group, index) => {
+    if (index < 0) {
+        return screenshots[group].length - 1;
+    } else if (index > screenshots[group].length - 1) {
+        return 0;
+    }
+    return index;
+};
+
+const hideScreenshotOverlay = (e) => {
+    lightbox.classList.remove('show');
+    document.removeEventListener('keydown', nextScreenshotKeyboardListener);
+};
+
+const nextScreenshotKeyboardListener = (e) => {
+    switch (e.keyCode) {
+        case 37:
+            previousScreenshot(e);
+            break;
+        case 39:
+            nextScreenshot(e);
+            break;
+    }
+};
+
+let currentScreenshotGroup = '';
+let currentScreenshotIndex = 0;
+let screenshots = {};
+Array.from(document.getElementsByClassName('screenshots')).forEach((sg) => {
+    const group = sg.id;
+    screenshots[group] = [...sg.querySelectorAll('a')];
+    screenshots[group].forEach((el, index) => {
+        el.onclick = (e) => { return showScreenshotOverlay(e, el, group, index); };
+    });
+});
+
+lightbox.onclick = hideScreenshotOverlay;

docs/subscribe/api.md

@@ -0,0 +1,260 @@
+# Subscribe via API
+You can create and subscribe to a topic either in the [web UI](web.md), via the [phone app](phone.md), or in your own 
+app or script by subscribing the API. This page describes how to subscribe via API. You may also want to check out the 
+page that describes how to [publish messages](../publish.md).
+
+The subscription API relies on a simple HTTP GET request with a streaming HTTP response, i.e **you open a GET request and
+the connection stays open forever**, sending messages back as they come in. There are three different API endpoints, which 
+only differ in the response format:
+
+* [JSON stream](#subscribe-as-json-stream): `<topic>/json` returns a JSON stream, with one JSON message object per line
+* [SSE stream](#subscribe-as-sse-stream): `<topic>/sse` returns messages as [Server-Sent Events (SSE)](https://en.wikipedia.org/wiki/Server-sent_events), which
+  can be used with [EventSource](https://developer.mozilla.org/en-US/docs/Web/API/EventSource)
+* [Raw stream](#subscribe-as-raw-stream): `<topic>/raw` returns messages as raw text, with one line per message
+
+## Subscribe as JSON stream
+Here are a few examples of how to consume the JSON endpoint (`<topic>/json`). For almost all languages, **this is the 
+recommended way to subscribe to a topic**. The notable exception is JavaScript, for which the 
+[SSE/EventSource stream](#subscribe-as-sse-stream) is much easier to work with.
+
+=== "Command line (curl)"
+    ```
+    $ curl -s ntfy.sh/disk-alerts/json
+    {"id":"SLiKI64DOt","time":1635528757,"event":"open","topic":"mytopic"}
+    {"id":"hwQ2YpKdmg","time":1635528741,"event":"message","topic":"mytopic","message":"Disk full"}
+    {"id":"DGUDShMCsc","time":1635528787,"event":"keepalive","topic":"mytopic"}
+    ...
+    ```
+
+=== "HTTP"
+    ``` http
+    GET /disk-alerts/json HTTP/1.1
+    Host: ntfy.sh
+
+    HTTP/1.1 200 OK
+    Content-Type: application/x-ndjson; charset=utf-8
+    Transfer-Encoding: chunked
+    
+    {"id":"SLiKI64DOt","time":1635528757,"event":"open","topic":"mytopic"}
+    {"id":"hwQ2YpKdmg","time":1635528741,"event":"message","topic":"mytopic","message":"Disk full"}
+    {"id":"DGUDShMCsc","time":1635528787,"event":"keepalive","topic":"mytopic"}
+    ...
+    ```
+
+=== "Go"
+    ``` go
+    resp, err := http.Get("https://ntfy.sh/disk-alerts/json")
+    if err != nil {
+        log.Fatal(err)
+    }
+    defer resp.Body.Close()
+    scanner := bufio.NewScanner(resp.Body)
+    for scanner.Scan() {
+        println(scanner.Text())
+    }
+    ```
+
+=== "PHP"
+    ``` php-inline
+    $fp = fopen('https://ntfy.sh/disk-alerts/json', 'r');
+    if (!$fp) die('cannot open stream');
+    while (!feof($fp)) {
+        echo fgets($fp, 2048);
+        flush();
+    }
+    fclose($fp);
+    ```
+
+## Subscribe as SSE stream
+Using [EventSource](https://developer.mozilla.org/en-US/docs/Web/API/EventSource) in JavaScript, you can consume
+notifications via a [Server-Sent Events (SSE)](https://en.wikipedia.org/wiki/Server-sent_events) stream. It's incredibly 
+easy to use. Here's what it looks like. You may also want to check out the [live example](/example.html).
+
+=== "Command line (curl)"
+    ```
+    $ curl -s ntfy.sh/mytopic/sse
+    event: open
+    data: {"id":"weSj9RtNkj","time":1635528898,"event":"open","topic":"mytopic"}
+    
+    data: {"id":"p0M5y6gcCY","time":1635528909,"event":"message","topic":"mytopic","message":"Hi!"}
+    
+    event: keepalive
+    data: {"id":"VNxNIg5fpt","time":1635528928,"event":"keepalive","topic":"test"}
+    ...
+    ```
+
+=== "HTTP"
+    ``` http
+    GET /mytopic/sse HTTP/1.1
+    Host: ntfy.sh
+
+    HTTP/1.1 200 OK
+    Content-Type: text/event-stream; charset=utf-8
+    Transfer-Encoding: chunked
+
+    event: open
+    data: {"id":"weSj9RtNkj","time":1635528898,"event":"open","topic":"mytopic"}
+    
+    data: {"id":"p0M5y6gcCY","time":1635528909,"event":"message","topic":"mytopic","message":"Hi!"}
+    
+    event: keepalive
+    data: {"id":"VNxNIg5fpt","time":1635528928,"event":"keepalive","topic":"test"}
+    ...
+    ```
+
+=== "JavaScript"
+    ``` javascript
+    const eventSource = new EventSource('https://ntfy.sh/mytopic/sse');
+    eventSource.onmessage = (e) => {
+      console.log(e.data);
+    };
+    ```
+
+## Subscribe as raw stream
+The `/raw` endpoint will output one line per message, and **will only include the message body**. It's useful for extremely
+simple scripts, and doesn't include all the data. Additional fields such as [priority](../publish.md#message-priority), 
+[tags](../publish.md#tags--emojis--) or [message title](../publish.md#message-title) are not included in this output 
+format. Keepalive messages are sent as empty lines.
+
+=== "Command line (curl)"
+    ```
+    $ curl -s ntfy.sh/disk-alerts/raw
+    
+    Disk full
+    ...
+    ```
+
+=== "HTTP"
+    ``` http
+    GET /disk-alerts/raw HTTP/1.1
+    Host: ntfy.sh
+
+    HTTP/1.1 200 OK
+    Content-Type: text/plain; charset=utf-8
+    Transfer-Encoding: chunked
+
+    Disk full
+    ...
+    ```
+
+=== "Go"
+    ``` go
+    resp, err := http.Get("https://ntfy.sh/disk-alerts/raw")
+    if err != nil {
+        log.Fatal(err)
+    }
+    defer resp.Body.Close()
+    scanner := bufio.NewScanner(resp.Body)
+    for scanner.Scan() {
+        println(scanner.Text())
+    }
+    ```
+
+=== "PHP"
+    ``` php-inline
+    $fp = fopen('https://ntfy.sh/disk-alerts/raw', 'r');
+    if (!$fp) die('cannot open stream');
+    while (!feof($fp)) {
+        echo fgets($fp, 2048);
+        flush();
+    }
+    fclose($fp);
+    ```
+
+## JSON message format
+Both the [`/json` endpoint](#subscribe-as-json-stream) and the [`/sse` endpoint](#subscribe-as-sse-stream) return a JSON
+format of the message. It's very straight forward:
+
+| Field | Required | Type | Example | Description |
+|---|---|---|---|---|
+| `id` | ✔️ | *string* | `hwQ2YpKdmg` | Randomly chosen message identifier |
+| `time` | ✔️ | *int* | `1635528741` | Message date time, as Unix time stamp |  
+| `event` | ✔️ | `open`, `keepalive` or `message` | `message` | Message type, typically you'd be only interested in `message` |
+| `topic` | ✔️ | *string* | `topic1,topic2` | Comma-separated list of topics the message is associated with; only one for all `message` events, but may be a list in `open` events |
+| `message` | - | *string* | `Some message` | Message body; always present in `message` events |
+| `title` | - | *string* | `Some title` | Message [title](../publish.md#message-title); if not set defaults to `ntfy.sh/<topic>` |
+| `tags` | - | *string array* | `["tag1","tag2"]` | List of [tags](../publish.md#tags-emojis) that may or not map to emojis |
+| `priority` | - | *1, 2, 3, 4, or 5* | `4` | Message [priority](../publish.md#message-priority) with 1=min, 3=default and 5=max |
+
+Here's an example for each message type:
+
+=== "Notification message"
+    ``` json
+    {
+      "id": "wze9zgqK41",
+      "time": 1638542110,
+      "event": "message",
+      "topic": "phil_alerts",
+      "priority": 5,
+      "tags": [
+        "warning",
+        "skull"
+      ],
+      "title": "Unauthorized access detected",
+      "message": "Remote access to phils-laptop detected. Act right away."
+    }
+    ```
+
+
+=== "Notification message (minimal)"
+    ``` json
+    {
+      "id": "wze9zgqK41",
+      "time": 1638542110,
+      "event": "message",
+      "topic": "phil_alerts",
+      "message": "Remote access to phils-laptop detected. Act right away."
+    }
+    ```
+
+=== "Open message"
+    ``` json
+    {
+      "id": "2pgIAaGrQ8",
+      "time": 1638542215,
+      "event": "open",
+      "topic": "phil_alerts"
+    }
+    ```
+
+=== "Keepalive message" 
+    ``` json
+    {
+      "id": "371sevb0pD",
+      "time": 1638542275,
+      "event": "keepalive",
+      "topic": "phil_alerts"
+    }
+    ```    
+
+## Advanced features
+
+### Fetching cached messages
+Messages may be cached for a couple of hours (see [message caching](../config.md#message-cache)) to account for network
+interruptions of subscribers. If the server has configured message caching, you can read back what you missed by using 
+the `since=` query parameter. It takes either a duration (e.g. `10m` or `30s`), a Unix timestamp (e.g. `1635528757`) 
+or `all` (all cached messages).
+
+```
+curl -s "ntfy.sh/mytopic/json?since=10m"
+```
+
+### Polling
+You can also just poll for messages if you don't like the long-standing connection using the `poll=1`
+query parameter. The connection will end after all available messages have been read. This parameter can be
+combined with `since=` (defaults to `since=all`).
+
+```
+curl -s "ntfy.sh/mytopic/json?poll=1"
+```
+
+### Subscribing to multiple topics
+It's possible to subscribe to multiple topics in one HTTP call by providing a
+comma-separated list of topics in the URL. This allows you to reduce the number of connections you have to maintain:
+
+```
+$ curl -s ntfy.sh/mytopic1,mytopic2/json
+{"id":"0OkXIryH3H","time":1637182619,"event":"open","topic":"mytopic1,mytopic2,mytopic3"}
+{"id":"dzJJm7BCWs","time":1637182634,"event":"message","topic":"mytopic1","message":"for topic 1"}
+{"id":"Cm02DsxUHb","time":1637182643,"event":"message","topic":"mytopic2","message":"for topic 2"}
+```

docs/subscribe/phone.md

@@ -0,0 +1,87 @@
+# Subscribe from your phone
+You can use the [ntfy Android App](https://play.google.com/store/apps/details?id=io.heckel.ntfy) to receive 
+notifications directly on your phone. Just like the server, this app is also [open source](https://github.com/binwiederhier/ntfy-android).
+Since I don't have an iPhone or a Mac, I didn't make an iOS app yet. I'd be awesome if [someone else could help out](https://github.com/binwiederhier/ntfy/issues/4).
+
+## Android
+<a href="https://play.google.com/store/apps/details?id=io.heckel.ntfy"><img src="../../static/img/badge-googleplay.png"></a>
+<a href="https://f-droid.org/en/packages/io.heckel.ntfy/"><img src="../../static/img/badge-fdroid.png"></a>
+
+You can get the Android app from both [Google Play](https://play.google.com/store/apps/details?id=io.heckel.ntfy) and 
+from [F-Droid](https://f-droid.org/en/packages/io.heckel.ntfy/). Both are largely identical, with the one exception that
+the F-Droid flavor does not use Firebase.
+
+### Overview
+A picture is worth a thousand words. Here are a few screenshots showing what the app looks like. It's all pretty
+straight forward. You can add topics and as soon as you add them, you can [publish messages](../publish.md) to them.
+
+<div id="android-screenshots" class="screenshots">
+    <a href="../../static/img/android-screenshot-main.jpg"><img src="../../static/img/android-screenshot-main.jpg"/></a>
+    <a href="../../static/img/android-screenshot-detail.jpg"><img src="../../static/img/android-screenshot-detail.jpg"/></a>
+    <a href="../../static/img/android-screenshot-add.jpg"><img src="../../static/img/android-screenshot-add.jpg"/></a>
+    <a href="../../static/img/android-screenshot-add-instant.jpg"><img src="../../static/img/android-screenshot-add-instant.jpg"/></a>
+    <a href="../../static/img/android-screenshot-add-other.jpg"><img src="../../static/img/android-screenshot-add-other.jpg"/></a>
+</div>
+
+If those screenshots are still not enough, here's a video:
+
+<figure>
+  <video controls muted autoplay loop width="650" src="../../static/img/overview.mp4"></video>
+  <figcaption>Sending push notifications to your Android phone</figcaption>
+</figure>
+
+### Message priority
+When you [publish messages](../publish.md#message-priority) to a topic, you can define a priority. This priority defines
+how urgently Android will notify you about the notification, and whether they make a sound and/or vibrate.
+
+By default, messages with default priority or higher (>= 3) will vibrate and make a sound. Messages with high or urgent
+priority (>= 4) will also show as pop-over, like so:
+
+<figure markdown>
+  ![priority notification](../static/img/priority-notification.png){ width=500 }
+  <figcaption>High and urgent notifications show as pop-over</figcaption>
+</figure>
+
+You can change these settings in Android by long-pressing on the app, and tapping "Notifications". You can then configure
+the settings (and custom sounds or vibration) for each of the priorities:
+
+<figure markdown>
+  ![notification settings](../static/img/android-notification-settings.png){ width=500 }
+  <figcaption>Per-priority sound/vibration settings</figcaption>
+</figure>
+
+### Instant delivery
+Instant delivery allows you to receive messages on your phone instantly, **even when your phone is in doze mode**, i.e. 
+when the screen turns off, and you leave it on the desk for a while. This is achieved with a foreground service, which 
+you'll see as a permanent notification that looks like this:
+
+<figure markdown>
+  ![foreground service](../static/img/foreground-service.png){ width=500 }
+  <figcaption>Instant delivery foreground notification</figcaption>
+</figure>
+
+Android does not allow you to dismiss this notification, unless you turn off the notification channel in the settings.
+To do so, long-press on the foreground notification (screenshot above) and navigate to the settings. Then toggle the 
+"Subscription Service" off:
+
+<figure markdown>
+  ![foreground service](../static/img/notification-settings.png){ width=500 }
+  <figcaption>Turning off the persistent instant delivery notification</figcaption>
+</figure>
+
+### Limitations without instant delivery
+Without instant delivery, **messages may arrive with a significant delay** (sometimes many minutes, or even hours later). If you've ever picked up your phone and 
+suddenly had 10 messages that were sent long before you know what I'm talking about.
+
+The reason for this is [Firebase Cloud Messaging (FCM)](https://firebase.google.com/docs/cloud-messaging). FCM is the 
+*only* Google approved way to send push messages to Android devices, and it's what pretty much all apps use to deliver push 
+notifications. Firebase is overall pretty bad at delivering messages in time, but on Android, most apps are stuck with it.
+
+The ntfy Android app uses Firebase only for the main host `ntfy.sh`, and only in the Google Play flavor of the app.
+It won't use Firebase for any self-hosted servers, and not at all in the the F-Droid flavor.
+
+## iPhone/iOS
+I almost feel devious for putting the *Download on the App Store* button on this page. Currently, there is no iOS app
+for ntfy, but it's in the works. You can track the status on GitHub.
+
+<a href="https://github.com/binwiederhier/ntfy/issues/4"><img src="../../static/img/badge-appstore.png"></a>

docs/subscribe/web.md

@@ -0,0 +1,20 @@
+# Subscribe from the Web UI
+You can use the Web UI to subscribe to topics as well. If you do, and you keep the website open, **notifications will
+pop up as desktop notifications**. Simply type in the topic name and click the *Subscribe* button. The browser will 
+keep a connection open and listen for incoming notifications.
+
+To learn how to send messages, check out the [publishing page](../publish.md).
+
+<div id="web-screenshots" class="screenshots">
+    <a href="../../static/img/web-subscribe.png"><img src="../../static/img/web-subscribe.png"/></a>
+    <a href="../../static/img/web-notification.png"><img src="../../static/img/web-notification.png"/></a>
+    <a href="../../static/img/web-detail.png"><img src="../../static/img/web-detail.png"/></a> 
+</div>
+
+To keep receiving desktop notifications from ntfy, you need to keep the website open. What I do, and what I highly recommend,
+is to pin the tab so that it's always open, but sort of out of the way:
+
+<figure markdown>
+  ![pinned](../static/img/web-pin.png){ width=500 }
+  <figcaption>Pin web app to move it out of the way</figcaption>
+</figure>

examples/linux-desktop-notifications/notify-desktop.sh

@@ -2,6 +2,8 @@
 # This is an example shell script showing how to consume a ntfy.sh topic using
 # a simple script. The notify-send command sends any arriving message as a desktop notification.
 
+TOPIC_URL=ntfy.sh/mytopic
+
 while read msg; do
   [ -n "$msg" ] && notify-send "$msg"
-done < <(stdbuf -i0 -o0 curl -s ntfy.sh/mytopic/raw)
+done < <(stdbuf -i0 -o0 curl -s $TOPIC_URL/raw)

examples/publish-go/main.go

@@ -0,0 +1,27 @@
+package main
+
+import (
+	"log"
+	"net/http"
+	"strings"
+)
+
+func main() {
+	// Without additional headers (priority, tags, title), it's a one liner.
+	// Check out https://ntfy.sh/mytopic in your browser after running this.
+	http.Post("https://ntfy.sh/mytopic", "text/plain", strings.NewReader("Backup successful 😀"))
+
+	// If you'd like to add title, priority, or tags, it's a little harder.
+	// Check out https://ntfy.sh/phil_alerts in your browser.
+	req, err := http.NewRequest("POST", "https://ntfy.sh/phil_alerts",
+		strings.NewReader("Remote access to phils-laptop detected. Act right away."))
+	if err != nil {
+		log.Fatal(err)
+	}
+	req.Header.Set("Title", "Unauthorized access detected")
+	req.Header.Set("Priority", "urgent")
+	req.Header.Set("Tags", "warning,skull")
+	if _, err := http.DefaultClient.Do(req); err != nil {
+		log.Fatal(err)
+	}
+}

examples/publish-php/publish.php

@@ -0,0 +1,14 @@
+<?php
+
+// Check out https://ntfy.sh/phil_alerts in your browser after running this.
+file_get_contents('https://ntfy.sh/phil_alerts', false, stream_context_create([
+    'http' => [
+        'method' => 'POST', // PUT also works
+        'header' =>
+            "Content-Type: text/plain\r\n" .
+            "Title: Unauthorized access detected\r\n" .
+            "Priority: urgent\r\n" .
+            "Tags: warning,skull",
+        'content' => 'Remote access to phils-laptop detected. Act right away.'
+    ]
+]));

examples/ssh-login-alert/ntfy-ssh-login.sh

@@ -2,6 +2,8 @@
 # This is a PAM script hook that shows how to notify you when
 # somebody logs into your server. Place at /usr/local/bin/ntfy-ssh-login.sh (with chmod +x!).
 
+TOPIC_URL=ntfy.sh/alerts
+
 if [ "${PAM_TYPE}" = "open_session" ]; then
-  echo -en "\u26A0\uFE0F SSH login to $(hostname): ${PAM_USER} from ${PAM_RHOST}" | curl -T- ntfy.sh/alerts
+  curl -H tags:warning -H prio:high -d "SSH login to $(hostname): ${PAM_USER} from ${PAM_RHOST}" "${TOPIC_URL}"
 fi

examples/subscribe-go/main.go

@@ -0,0 +1,19 @@
+package main
+
+import (
+	"bufio"
+	"log"
+	"net/http"
+)
+
+func main() {
+	resp, err := http.Get("https://ntfy.sh/phil_alerts/json")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer resp.Body.Close()
+	scanner := bufio.NewScanner(resp.Body)
+	for scanner.Scan() {
+		println(scanner.Text())
+	}
+}

examples/subscribe-php/subscribe.php

@@ -0,0 +1,12 @@
+<?php
+
+$fp = fopen('https://ntfy.sh/phil_alerts/json', 'r');
+if (!$fp) {
+    die('cannot open stream');
+}
+while (!feof($fp)) {
+    $buffer = fgets($fp, 2048);
+    echo $buffer;
+    flush();
+}
+fclose($fp);

go.mod

@@ -9,34 +9,37 @@ require (
 	github.com/BurntSushi/toml v0.4.1 // indirect
 	github.com/cpuguy83/go-md2man/v2 v2.0.1 // indirect
 	github.com/mattn/go-sqlite3 v1.14.9
+	github.com/stretchr/testify v1.7.0
 	github.com/urfave/cli/v2 v2.3.0
-	golang.org/x/oauth2 v0.0.0-20211028175245-ba495a64dcb5 // indirect
-	golang.org/x/time v0.0.0-20210723032227-1f47c861a9ac
-	google.golang.org/api v0.60.0
+	golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8 // indirect
+	golang.org/x/time v0.0.0-20211116232009-f0f3c7e86c11
+	google.golang.org/api v0.61.0
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 )
 
 require (
-	cloud.google.com/go v0.97.0 // indirect
+	cloud.google.com/go v0.99.0 // indirect
 	github.com/census-instrumentation/opencensus-proto v0.3.0 // indirect
-	github.com/cespare/xxhash v1.1.0 // indirect
 	github.com/cespare/xxhash/v2 v2.1.2 // indirect
 	github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4 // indirect
-	github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1 // indirect
-	github.com/envoyproxy/go-control-plane v0.10.0 // indirect
+	github.com/cncf/xds/go v0.0.0-20211130200136-a8f946100490 // indirect
+	github.com/davecgh/go-spew v1.1.0 // indirect
+	github.com/envoyproxy/go-control-plane v0.10.1 // indirect
 	github.com/envoyproxy/protoc-gen-validate v0.6.2 // indirect
 	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
 	github.com/golang/protobuf v1.5.2 // indirect
 	github.com/google/go-cmp v0.5.6 // indirect
 	github.com/googleapis/gax-go/v2 v2.1.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
 	go.opencensus.io v0.23.0 // indirect
 	golang.org/x/net v0.0.0-20210813160813-60bc85c4be6d // indirect
-	golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359 // indirect
+	golang.org/x/sys v0.0.0-20211124211545-fe61309f8881 // indirect
 	golang.org/x/text v0.3.7 // indirect
 	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
 	google.golang.org/appengine v1.6.7 // indirect
-	google.golang.org/genproto v0.0.0-20211101144312-62acf1d99145 // indirect
-	google.golang.org/grpc v1.41.0 // indirect
+	google.golang.org/genproto v0.0.0-20211206220100-3cb06788ce7f // indirect
+	google.golang.org/grpc v1.42.0 // indirect
 	google.golang.org/protobuf v1.27.1 // indirect
+	gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c // indirect
 )

go.sum

@@ -24,8 +24,9 @@ cloud.google.com/go v0.87.0/go.mod h1:TpDYlFy7vuLzZMMZ+B6iRiELaY7z/gJPaqbMx6mlWc
 cloud.google.com/go v0.90.0/go.mod h1:kRX0mNRHe0e2rC6oNakvwQqzyDmg57xJ+SZU1eT2aDQ=
 cloud.google.com/go v0.93.3/go.mod h1:8utlLll2EF5XMAV15woO4lSbWQlk8rer9aLOfLh7+YI=
 cloud.google.com/go v0.94.1/go.mod h1:qAlAugsXlC+JWO+Bke5vCtc9ONxjQT3drlTTnAplMW4=
-cloud.google.com/go v0.97.0 h1:3DXvAyifywvq64LfkKaMOmkWPS1CikIQdMe2lY9vxU8=
 cloud.google.com/go v0.97.0/go.mod h1:GF7l59pYBVlXQIBLx3a761cZ41F9bBH3JUlihCt2Udc=
+cloud.google.com/go v0.99.0 h1:y/cM2iqGgGi5D5DQZl6D9STN/3dR/Vx5Mp8s752oJTY=
+cloud.google.com/go v0.99.0/go.mod h1:w0Xx2nLzqWJPuozYQX+hFfCSI8WioryfRDzkoI/Y2ZA=
 cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=
 cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE=
 cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc=
@@ -34,8 +35,6 @@ cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4g
 cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ=
 cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE=
 cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk=
-cloud.google.com/go/firestore v1.6.0 h1:dMIWvm+3O0E3DM7kcZPH0FBQ94Xg/OMkdTNDaY9itbI=
-cloud.google.com/go/firestore v1.6.0/go.mod h1:afJwI0vaXwAG54kI7A//lP/lSPDkQORQuMkv56TxEPU=
 cloud.google.com/go/firestore v1.6.1 h1:8rBq3zRjnHx8UtBvaOWqBB1xq9jH6/wltfQLlTMh2Fw=
 cloud.google.com/go/firestore v1.6.1/go.mod h1:asNXNOzBdyVQmEU+ggO8UPodTkEVFW5Qx+rwHnAz+EY=
 cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=
@@ -56,10 +55,8 @@ github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03
 github.com/BurntSushi/toml v0.4.1 h1:GaI7EiDXDRfa8VshkTj7Fym7ha+y8/XxIgD2okUIjLw=
 github.com/BurntSushi/toml v0.4.1/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
-github.com/OneOfOne/xxhash v1.2.2 h1:KMrpdQIwFcEqXDklaen+P1axHaj9BSKzvpUUfnHldSE=
 github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
 github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
-github.com/census-instrumentation/opencensus-proto v0.2.1 h1:glEXhBS5PSLLv4IXzLA5yPRVX4bilULVyxxbrfOtDAk=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
 github.com/census-instrumentation/opencensus-proto v0.3.0 h1:t/LhUZLVitR1Ow2YOnduCsavhwFUklBMoGVYUCqmCqk=
 github.com/census-instrumentation/opencensus-proto v0.3.0/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
@@ -74,20 +71,20 @@ github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMn
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
 github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
 github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
-github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403 h1:cqQfy1jclcSy/FwLjemeg3SR1yaINm74aQyupQ0Bl8M=
 github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
 github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4 h1:hzAQntlaYRkVSFEfj9OTWlVV1H155FMD8BTKktLv0QI=
 github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI=
-github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed h1:OZmjad4L3H8ncOIR8rnb5MREYqG8ixi5+WbeUsquF0c=
 github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
 github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
 github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
 github.com/cncf/xds/go v0.0.0-20211001041855-01bcc9b48dfe/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
-github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1 h1:zH8ljVhhq7yC0MIeUL/IviMtY8hx2mK8cN9wEYb8ggw=
 github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
+github.com/cncf/xds/go v0.0.0-20211130200136-a8f946100490 h1:KwaoQzs/WeUxxJqiJsZ4euOly1Az/IgZXXSxlD/UBNk=
+github.com/cncf/xds/go v0.0.0-20211130200136-a8f946100490/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
 github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
 github.com/cpuguy83/go-md2man/v2 v2.0.1 h1:r/myEWzV9lfsM1tFLgDyu0atFtJ1fXn261LKYj/3DxU=
 github.com/cpuguy83/go-md2man/v2 v2.0.1/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
@@ -95,12 +92,10 @@ github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1m
 github.com/envoyproxy/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5ynNVH9qI8YYLbd1fK2po=
 github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
 github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
-github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0 h1:dulLQAYQFYtG5MTplgNGHWuV2D+OBD+Z8lmDBmbLg+s=
 github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ=
 github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0=
-github.com/envoyproxy/go-control-plane v0.10.0 h1:WVt4HEPbdRbRD/PKKPbPnIVavO6gk/h673jWyIJ016k=
-github.com/envoyproxy/go-control-plane v0.10.0/go.mod h1:AY7fTTXNdv/aJ2O5jwpxAPOWUZ7hQAEvzN5Pf27BkQQ=
-github.com/envoyproxy/protoc-gen-validate v0.1.0 h1:EQciDnbrYxy13PgWoY8AqoxGiPrpgBZ1R8UNe3ddc+A=
+github.com/envoyproxy/go-control-plane v0.10.1 h1:cgDRLG7bs59Zd+apAWuzLQL95obVYAymNJek76W3mgw=
+github.com/envoyproxy/go-control-plane v0.10.1/go.mod h1:AY7fTTXNdv/aJ2O5jwpxAPOWUZ7hQAEvzN5Pf27BkQQ=
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/envoyproxy/protoc-gen-validate v0.6.2 h1:JiO+kJTpmYGjEodY7O1Zk8oZcNz1+f30UtwtXoFUPzE=
 github.com/envoyproxy/protoc-gen-validate v0.6.2/go.mod h1:2t7qjJNvHPx8IjnBOzl9E9/baC+qXE/TeeyBRzgJDws=
@@ -111,7 +106,6 @@ github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
 github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e h1:1r7pUrabqp18hOBcwBwiTsbnFeTZHV9eER/QT5JVZxY=
 github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l8iNU+DwB5epxmsaqB+rhGL0m5jtYqE=
 github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
@@ -202,11 +196,11 @@ github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/lyft/protoc-gen-star v0.5.3/go.mod h1:V0xaHgaf5oCCqmcxYcWiDfTiKsZsRc87/1qhoTACD8w=
-github.com/mattn/go-sqlite3 v1.14.8/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU=
 github.com/mattn/go-sqlite3 v1.14.9 h1:10HX2Td0ocZpYEjhilsuo6WWtUqttj2Kb0KtD86/KYA=
 github.com/mattn/go-sqlite3 v1.14.9/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/sftp v1.10.1/go.mod h1:lYOWFsE0bwd1+KfKJaKeuokY15vzFx25BLbzYYoAxZI=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
@@ -215,7 +209,6 @@ github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQD
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
-github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72 h1:qLC7fQah7D6K1B0ujays3HV9gkFtllcxhzImRR7ArPQ=
 github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
 github.com/spf13/afero v1.3.3/go.mod h1:5KUK8ByomD5Ti5Artl0RtHeI5pTF7MIDuXL3yY520V4=
 github.com/spf13/afero v1.6.0/go.mod h1:Ai8FlHk4v/PARR026UzYexafAt9roJ7LcLMAmO6Z93I=
@@ -223,6 +216,7 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/urfave/cli/v2 v2.3.0 h1:qph92Y649prgesehzOrQjdWyxFOp/QVM+6imKHad91M=
 github.com/urfave/cli/v2 v2.3.0/go.mod h1:LJmUH05zAU44vOAcrfzZQKsZbVcdbOG8rtL3/XcUArI=
@@ -316,7 +310,6 @@ golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc=
 golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
-golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420 h1:a8jGStKg0XqKDlKqjLrXn0ioF5MH36pT7Z0BRTqLhbk=
 golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20210813160813-60bc85c4be6d h1:LO7XpTYMwTqxjLcGWPijK3vRXg1aWdlNOVOHRq45d7c=
 golang.org/x/net v0.0.0-20210813160813-60bc85c4be6d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
@@ -336,8 +329,8 @@ golang.org/x/oauth2 v0.0.0-20210628180205-a41e5a781914/go.mod h1:KelEdhl1UZF7XfJ
 golang.org/x/oauth2 v0.0.0-20210805134026-6f1e6394065a/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
 golang.org/x/oauth2 v0.0.0-20210819190943-2bc19b11175f/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
 golang.org/x/oauth2 v0.0.0-20211005180243-6b3c2da341f1/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
-golang.org/x/oauth2 v0.0.0-20211028175245-ba495a64dcb5 h1:v79phzBz03tsVCUTbvTBmmC3CUXF5mKYt7DA4ZVldpM=
-golang.org/x/oauth2 v0.0.0-20211028175245-ba495a64dcb5/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
+golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8 h1:RerP+noqYHUQ8CMRcPlC2nvTa4dcBIjegkuWdcUDuqg=
+golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -397,8 +390,8 @@ golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20210908233432-aa78b53d3365/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210917161153-d61c044b1678/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359 h1:2B5p2L5IfGiD7+b9BOoRMC6DgObAVZV+Fsp050NqXik=
-golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20211124211545-fe61309f8881 h1:TyHqChC80pFkXWraUUf6RuB5IqFdQieMLwwCJokV2pc=
+golang.org/x/sys v0.0.0-20211124211545-fe61309f8881/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
@@ -407,15 +400,14 @@ golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.6 h1:aRYxNxv6iGQlyVaZmk6ZgYEDa+Jg18DxebPSrd6bg1M=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/time v0.0.0-20210723032227-1f47c861a9ac h1:7zkz7BUtwNFFqcowJ+RIgu2MaV/MapERkDIy+mwPyjs=
-golang.org/x/time v0.0.0-20210723032227-1f47c861a9ac/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20211116232009-f0f3c7e86c11 h1:GZokNIeuVkl3aZHJchRrr13WCsols02MLUcz1U9is6M=
+golang.org/x/time v0.0.0-20211116232009-f0f3c7e86c11/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
@@ -503,8 +495,8 @@ google.golang.org/api v0.56.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqiv
 google.golang.org/api v0.57.0/go.mod h1:dVPlbZyBo2/OjBpmvNdpn2GRm6rPy75jyU7bmhdrMgI=
 google.golang.org/api v0.58.0/go.mod h1:cAbP2FsxoGVNwtgNAmmn3y5G1TWAiVYRmg4yku3lv+E=
 google.golang.org/api v0.59.0/go.mod h1:sT2boj7M9YJxZzgeZqXogmhfmRWDtPzT31xkieUbuZU=
-google.golang.org/api v0.60.0 h1:eq/zs5WPH4J9undYM9IP1O7dSr7Yh8Y0GtSCpzGzIUk=
-google.golang.org/api v0.60.0/go.mod h1:d7rl65NZAkEQ90JFzqBjcRq1TVeG5ZoGV3sSpEnnVb4=
+google.golang.org/api v0.61.0 h1:TXXKS1slM3b2bZNJwD5DV/Tp6/M2cLzLOLh9PjDhrw8=
+google.golang.org/api v0.61.0/go.mod h1:xQRti5UdCmoCEqFxcz93fTl338AVqDgyaDRuOZ3hg9I=
 google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
 google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
 google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
@@ -572,11 +564,11 @@ google.golang.org/genproto v0.0.0-20210917145530-b395a37504d4/go.mod h1:eFjDcFEc
 google.golang.org/genproto v0.0.0-20210924002016-3dee208752a0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
 google.golang.org/genproto v0.0.0-20211008145708-270636b82663/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
 google.golang.org/genproto v0.0.0-20211016002631-37fc39342514/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
-google.golang.org/genproto v0.0.0-20211021150943-2b146023228c h1:FqrtZMB5Wr+/RecOM3uPJNPfWR8Upb5hAPnt7PU6i4k=
-google.golang.org/genproto v0.0.0-20211021150943-2b146023228c/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
 google.golang.org/genproto v0.0.0-20211028162531-8db9c33dc351/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
-google.golang.org/genproto v0.0.0-20211101144312-62acf1d99145 h1:vum3nDKdleYb+aePXKFEDT2+ghuH00EgYp9B7Q7EZZE=
-google.golang.org/genproto v0.0.0-20211101144312-62acf1d99145/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
+google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
+google.golang.org/genproto v0.0.0-20211206160659-862468c7d6e0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
+google.golang.org/genproto v0.0.0-20211206220100-3cb06788ce7f h1:QH7+Ym+7e2XV1dZIHapkXoeqHyNaCzn6MNp3JBaYYUc=
+google.golang.org/genproto v0.0.0-20211206220100-3cb06788ce7f/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
 google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
 google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
@@ -601,10 +593,9 @@ google.golang.org/grpc v1.37.1/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQ
 google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM=
 google.golang.org/grpc v1.39.0/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE=
 google.golang.org/grpc v1.39.1/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE=
-google.golang.org/grpc v1.40.0 h1:AGJ0Ih4mHjSeibYkFGh1dD9KJ/eOtZ93I6hoHhukQ5Q=
 google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34=
-google.golang.org/grpc v1.41.0 h1:f+PlOh7QV4iIJkPrx5NQ7qaNGFQ3OTse67yaDHfju4E=
-google.golang.org/grpc v1.41.0/go.mod h1:U3l9uK9J0sini8mHphKoXyaqDA/8VyGnDee1zzIUK6k=
+google.golang.org/grpc v1.42.0 h1:XT2/MFpuPFsEX2fWh3YQtHkZ+WYZFQRfaUgLZYj/p6A=
+google.golang.org/grpc v1.42.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU=
 google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw=
 google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
 google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
@@ -628,6 +619,7 @@ gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=

mkdocs.yml

@@ -0,0 +1,89 @@
+site_dir: server/docs
+site_name: ntfy
+site_url: https://ntfy.sh
+site_description: simple HTTP-based pub-sub
+copyright: Made with ❤️ by Philipp C. Heckel
+repo_name: binwiederhier/ntfy
+repo_url: https://github.com/binwiederhier/ntfy
+edit_uri: edit/main/docs/
+
+theme:
+  name: material
+  language: en
+  logo: static/img/ntfy.png
+  favicon: static/img/favicon.png
+  include_search_page: false
+  search_index_only: true
+  palette:
+    - media: "(prefers-color-scheme: light)"  # Light mode
+      scheme: default
+      toggle:
+        icon: material/lightbulb-outline
+        name: Switch to dark mode
+    - media: "(prefers-color-scheme: dark)"  # Dark mode
+      scheme: slate
+      accent: indigo
+      toggle:
+        icon: material/lightbulb
+        name: Switch to light mode
+  features:
+    - search.suggest
+    - search.highlight
+    - search.share
+    - navigation.sections
+    # - navigation.instant
+    - toc.integrate
+    - content.tabs.link
+extra:
+  homepage: /
+  social:
+    - icon: fontawesome/brands/github-alt
+      link: https://github.com/binwiederhier
+extra_javascript:
+  - static/js/extra.js
+extra_css:
+  - static/css/extra.css
+
+markdown_extensions:
+  - admonition
+  - meta
+  - toc:
+      permalink: true
+  - pymdownx.tabbed:
+      alternate_style: true
+  - pymdownx.superfences
+  - pymdownx.highlight:
+      extend_pygments_lang:
+        - name: php-inline
+          lang: php
+          options:
+            startinline: true
+  - pymdownx.tasklist:
+      custom_checkbox: true
+  - attr_list
+  - md_in_html
+
+plugins:
+  - search
+  - minify:
+      minify_html: true
+
+nav:
+- "Getting started": index.md
+- "Publishing":
+  - "Sending messages": publish.md
+- "Subscribing":
+  - "From your phone": subscribe/phone.md
+  - "From the Web UI": subscribe/web.md
+  - "Using the API": subscribe/api.md
+- "Self-hosting":
+  - "Installation": install.md
+  - "Configuration": config.md
+- "Other things":
+  - "FAQs": faq.md
+  - "Examples": examples.md
+  - "Emojis 🥳 🎉": emojis.md
+  - "Development": develop.md
+  - "Privacy policy": privacy.md
+
+

requirements.txt

@@ -0,0 +1,9 @@
+# The documentation uses 'mkdocs', which is written in Python
+
+# See https://github.com/squidfunk/mkdocs-material/issues/2030
+jinja2>=2.11.1
+
+# mkdocs
+mkdocs
+mkdocs-material
+mkdocs-minify-plugin

scripts/emoji-convert.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+
+# This script reduces the size and converts the emoji.json file from https://github.com/github/gemoji/blob/master/db/emoji.json
+# to be used in the Android app (app/src/main/resources/emoji.json) and the Web UI (server/static/js/emoji.js).
+
+SCRIPTDIR="$(cd "$(dirname "$0")" && pwd)"
+ROOTDIR="$(cd "$(dirname "$0")/.." && pwd)"
+
+if [ -z "$1" ]; then
+    echo "Syntax: $0 FILE.(js|json|md)"
+    echo "Example:"
+    echo "  $0 emoji-converted.json"
+    echo "  $0 $ROOTDIR/server/static/js/emoji.js"
+    echo "  $0 $ROOTDIR/docs/emojis.md"
+    exit 1
+fi
+
+if [[ "$1" == *.js ]]; then
+  echo -n "// This file is generated by scripts/emoji-convert.sh to reduce the size
+// Original data source: https://github.com/github/gemoji/blob/master/db/emoji.json
+const rawEmojis = " > "$1"
+    cat "$SCRIPTDIR/emoji.json" | jq -rc 'map({emoji: .emoji,aliases: .aliases})' >> "$1"
+elif [[ "$1" == *.md ]]; then
+  echo "# Emoji reference
+
+<!-- This file was generated by scripts/emoji-convert.sh -->
+
+You can [tag messages](../publish/#tags-emojis) with emojis 🥳 🎉 and other relevant strings. Matching tags are automatically
+converted to emojis. This is a reference of all supported emojis. To learn more about the feature, please refer to the
+[tagging and emojis page](../publish/#tags-emojis).
+
+<table class="remove-md-box"><tr>
+" > "$1"
+
+  count="$(cat "$SCRIPTDIR/emoji.json" | jq -r '.[] | .emoji' | wc -l)"
+  percolumn=$(($count / 3)) # This will misbehave if the count is not divisible by 3
+  for col in 0 1 2; do
+    from="$(($col * $percolumn + 1))"
+    to="$(($col * $percolumn + 1 + $percolumn))"
+    echo "<td><table><thead><tr><th>Tag</th><th>Emoji</th></tr></thead><tbody>" >> "$1"
+    cat "$SCRIPTDIR/emoji.json" \
+      | jq -r '.[] | "<tr><td><code>" + .aliases[0] + "</code></td><td>" + .emoji + "</td></tr>"' \
+      | sed -n "${from},${to}p" >> "$1"
+    echo "</tbody></table></td>" >> "$1"
+  done
+  echo "</tr></table>" >> "$1"
+else
+  cat "$SCRIPTDIR/emoji.json" | jq -rc 'map({emoji: .emoji,aliases: .aliases})' > "$1"
+fi

scripts/postinst.sh

@@ -0,0 +1,35 @@
+#!/bin/sh
+set -e
+
+# Restart systemd service if it was already running. Note that "deb-systemd-invoke try-restart" will
+# only act if the service is already running. If it's not running, it's a no-op.
+#
+# TODO: This is only tested on Debian.
+#
+if [ "$1" = "configure" ] && [ -d /run/systemd/system ]; then
+  # Create ntfy user/group
+  id ntfy >/dev/null 2>&1 || useradd --system --no-create-home ntfy
+  chown ntfy.ntfy /var/cache/ntfy
+  chmod 700 /var/cache/ntfy
+
+  # Hack to change permissions on cache file
+  configfile="/etc/ntfy/config.yml"
+  if [ -f "$configfile" ]; then
+    cachefile="$(cat "$configfile" | perl -n -e'/^\s*cache-file: ["'"'"']?([^"'"'"']+)["'"'"']?/ && print $1')" # Oh my, see #47
+    if [ -n "$cachefile" ]; then
+      chown ntfy.ntfy "$cachefile" || true
+      chmod 600 "$cachefile" || true
+    fi
+  fi
+
+  # Restart service
+  systemctl --system daemon-reload >/dev/null || true
+  if systemctl is-active -q ntfy.service; then
+    echo "Restarting ntfy.service ..."
+    if [ -x /usr/bin/deb-systemd-invoke ]; then
+      deb-systemd-invoke try-restart ntfy.service >/dev/null || true
+    else
+      systemctl restart ntfy.service >/dev/null || true
+    fi
+  fi
+fi

scripts/postrm.sh

@@ -1,6 +1,10 @@
 #!/bin/sh
-set -eu
-systemctl stop ntfy >/dev/null 2>&1 || true
+set -e
+
+# Delete the config if package is purged
 if [ "$1" = "purge" ]; then
-  rm -rf /etc/ntfy
+  id ntfy >/dev/null 2>&1 && userdel ntfy
+  rm -f /etc/ntfy/config.yml
+  rmdir /etc/ntfy || true
 fi
+

scripts/prerm.sh

@@ -0,0 +1,12 @@
+#!/bin/sh
+set -e
+
+# Stop systemd service
+if [ -d /run/systemd/system ] && [ "$1" = remove ]; then
+  echo "Stopping ntfy.service ..."
+  if [ -x /usr/bin/deb-systemd-invoke ]; then
+    deb-systemd-invoke stop 'ntfy.service' >/dev/null || true
+  else
+    systemctl stop ntfy >/dev/null 2>&1 || true
+  fi
+fi

server/cache.go

@@ -1,14 +1,21 @@
 package server
 
 import (
+	"errors"
 	_ "github.com/mattn/go-sqlite3" // SQLite driver
 	"time"
 )
 
+var (
+	errUnexpectedMessageType = errors.New("unexpected message type")
+)
+
+// cache implements a cache for messages of type "message" events,
+// i.e. message structs with the Event messageEvent.
 type cache interface {
 	AddMessage(m *message) error
 	Messages(topic string, since sinceTime) ([]*message, error)
 	MessageCount(topic string) (int, error)
 	Topics() (map[string]*topic, error)
-	Prune(keep time.Duration) error
+	Prune(olderThan time.Time) error
 }

server/cache_mem.go

@@ -1,27 +1,44 @@
 package server
 
 import (
-	_ "github.com/mattn/go-sqlite3" // SQLite driver
 	"sync"
 	"time"
 )
 
 type memCache struct {
 	messages map[string][]*message
+	nop      bool
 	mu       sync.Mutex
 }
 
 var _ cache = (*memCache)(nil)
 
+// newMemCache creates an in-memory cache
 func newMemCache() *memCache {
 	return &memCache{
 		messages: make(map[string][]*message),
+		nop:      false,
+	}
+}
+
+// newNopCache creates an in-memory cache that discards all messages;
+// it is always empty and can be used if caching is entirely disabled
+func newNopCache() *memCache {
+	return &memCache{
+		messages: make(map[string][]*message),
+		nop:      true,
 	}
 }
 
 func (s *memCache) AddMessage(m *message) error {
 	s.mu.Lock()
 	defer s.mu.Unlock()
+	if s.nop {
+		return nil
+	}
+	if m.Event != messageEvent {
+		return errUnexpectedMessageType
+	}
 	if _, ok := s.messages[m.Topic]; !ok {
 		s.messages[m.Topic] = make([]*message, 0)
 	}
@@ -32,7 +49,7 @@ func (s *memCache) AddMessage(m *message) error {
 func (s *memCache) Messages(topic string, since sinceTime) ([]*message, error) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
-	if _, ok := s.messages[topic]; !ok {
+	if _, ok := s.messages[topic]; !ok || since.IsNone() {
 		return make([]*message, 0), nil
 	}
 	messages := make([]*message, 0) // copy!
@@ -55,26 +72,30 @@ func (s *memCache) MessageCount(topic string) (int, error) {
 }
 
 func (s *memCache) Topics() (map[string]*topic, error) {
-	// Hack since we know when this is called there are no messages!
-	return make(map[string]*topic), nil
-}
-
-func (s *memCache) Prune(keep time.Duration) error {
 	s.mu.Lock()
 	defer s.mu.Unlock()
-	for topic, _ := range s.messages {
-		s.pruneTopic(topic, keep)
+	topics := make(map[string]*topic)
+	for topic := range s.messages {
+		topics[topic] = newTopic(topic)
+	}
+	return topics, nil
+}
+
+func (s *memCache) Prune(olderThan time.Time) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	for topic := range s.messages {
+		s.pruneTopic(topic, olderThan)
 	}
 	return nil
 }
 
-func (s *memCache) pruneTopic(topic string, keep time.Duration) {
-	for i, m := range s.messages[topic] {
-		msgTime := time.Unix(m.Time, 0)
-		if time.Since(msgTime) < keep {
-			s.messages[topic] = s.messages[topic][i:]
-			return
+func (s *memCache) pruneTopic(topic string, olderThan time.Time) {
+	messages := make([]*message, 0)
+	for _, m := range s.messages[topic] {
+		if m.Time >= olderThan.Unix() {
+			messages = append(messages, m)
 		}
 	}
-	s.messages[topic] = make([]*message, 0) // all messages expired
+	s.messages[topic] = messages
 }

server/cache_mem_test.go

@@ -0,0 +1,35 @@
+package server
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestMemCache_Messages(t *testing.T) {
+	testCacheMessages(t, newMemCache())
+}
+
+func TestMemCache_Topics(t *testing.T) {
+	testCacheTopics(t, newMemCache())
+}
+
+func TestMemCache_MessagesTagsPrioAndTitle(t *testing.T) {
+	testCacheMessagesTagsPrioAndTitle(t, newMemCache())
+}
+
+func TestMemCache_Prune(t *testing.T) {
+	testCachePrune(t, newMemCache())
+}
+
+func TestMemCache_NopCache(t *testing.T) {
+	c := newNopCache()
+	assert.Nil(t, c.AddMessage(newDefaultMessage("mytopic", "my message")))
+
+	messages, err := c.Messages("mytopic", sinceAllMessages)
+	assert.Nil(t, err)
+	assert.Empty(t, messages)
+
+	topics, err := c.Topics()
+	assert.Nil(t, err)
+	assert.Empty(t, topics)
+}

server/cache_sqlite.go

@@ -3,32 +3,62 @@ package server
 import (
 	"database/sql"
 	"errors"
+	"fmt"
 	_ "github.com/mattn/go-sqlite3" // SQLite driver
+	"log"
+	"strings"
 	"time"
 )
 
+// Messages cache
 const (
-	createTableQuery = `
+	createMessagesTableQuery = `
 		BEGIN;
 		CREATE TABLE IF NOT EXISTS messages (
 			id VARCHAR(20) PRIMARY KEY,
 			time INT NOT NULL,
 			topic VARCHAR(64) NOT NULL,
-			message VARCHAR(1024) NOT NULL
+			message VARCHAR(512) NOT NULL,
+			title VARCHAR(256) NOT NULL,
+			priority INT NOT NULL,
+			tags VARCHAR(256) NOT NULL
 		);
 		CREATE INDEX IF NOT EXISTS idx_topic ON messages (topic);
 		COMMIT;
 	`
-	insertMessageQuery           = `INSERT INTO messages (id, time, topic, message) VALUES (?, ?, ?, ?)`
+	insertMessageQuery           = `INSERT INTO messages (id, time, topic, message, title, priority, tags) VALUES (?, ?, ?, ?, ?, ?, ?)`
 	pruneMessagesQuery           = `DELETE FROM messages WHERE time < ?`
 	selectMessagesSinceTimeQuery = `
-		SELECT id, time, message 
+		SELECT id, time, message, title, priority, tags
 		FROM messages 
 		WHERE topic = ? AND time >= ?
 		ORDER BY time ASC
 	`
-	selectMessageCountQuery = `SELECT count(*) FROM messages WHERE topic = ?`
-	selectTopicsQuery       = `SELECT topic, MAX(time) FROM messages GROUP BY TOPIC`
+	selectMessagesCountQuery        = `SELECT COUNT(*) FROM messages`
+	selectMessageCountForTopicQuery = `SELECT COUNT(*) FROM messages WHERE topic = ?`
+	selectTopicsQuery               = `SELECT topic FROM messages GROUP BY topic`
+)
+
+// Schema management queries
+const (
+	currentSchemaVersion          = 1
+	createSchemaVersionTableQuery = `
+		CREATE TABLE IF NOT EXISTS schemaVersion (
+			id INT PRIMARY KEY,
+			version INT NOT NULL
+		);
+	`
+	insertSchemaVersion      = `INSERT INTO schemaVersion VALUES (1, ?)`
+	selectSchemaVersionQuery = `SELECT version FROM schemaVersion WHERE id = 1`
+
+	// 0 -> 1
+	migrate0To1AlterMessagesTableQuery = `
+		BEGIN;
+		ALTER TABLE messages ADD COLUMN title VARCHAR(256) NOT NULL DEFAULT('');
+		ALTER TABLE messages ADD COLUMN priority INT NOT NULL DEFAULT(0);
+		ALTER TABLE messages ADD COLUMN tags VARCHAR(256) NOT NULL DEFAULT('');
+		COMMIT;
+	`
 )
 
 type sqliteCache struct {
@@ -42,7 +72,7 @@ func newSqliteCache(filename string) (*sqliteCache, error) {
 	if err != nil {
 		return nil, err
 	}
-	if _, err := db.Exec(createTableQuery); err != nil {
+	if err := setupDB(db); err != nil {
 		return nil, err
 	}
 	return &sqliteCache{
@@ -51,11 +81,17 @@ func newSqliteCache(filename string) (*sqliteCache, error) {
 }
 
 func (c *sqliteCache) AddMessage(m *message) error {
-	_, err := c.db.Exec(insertMessageQuery, m.ID, m.Time, m.Topic, m.Message)
+	if m.Event != messageEvent {
+		return errUnexpectedMessageType
+	}
+	_, err := c.db.Exec(insertMessageQuery, m.ID, m.Time, m.Topic, m.Message, m.Title, m.Priority, strings.Join(m.Tags, ","))
 	return err
 }
 
 func (c *sqliteCache) Messages(topic string, since sinceTime) ([]*message, error) {
+	if since.IsNone() {
+		return make([]*message, 0), nil
+	}
 	rows, err := c.db.Query(selectMessagesSinceTimeQuery, topic, since.Time().Unix())
 	if err != nil {
 		return nil, err
@@ -64,19 +100,24 @@ func (c *sqliteCache) Messages(topic string, since sinceTime) ([]*message, error
 	messages := make([]*message, 0)
 	for rows.Next() {
 		var timestamp int64
-		var id, msg string
-		if err := rows.Scan(&id, &timestamp, &msg); err != nil {
+		var priority int
+		var id, msg, title, tagsStr string
+		if err := rows.Scan(&id, &timestamp, &msg, &title, &priority, &tagsStr); err != nil {
 			return nil, err
 		}
-		if msg == "" {
-			msg = " " // Hack: never return empty messages; this should not happen
+		var tags []string
+		if tagsStr != "" {
+			tags = strings.Split(tagsStr, ",")
 		}
 		messages = append(messages, &message{
-			ID:      id,
-			Time:    timestamp,
-			Event:   messageEvent,
-			Topic:   topic,
-			Message: msg,
+			ID:       id,
+			Time:     timestamp,
+			Event:    messageEvent,
+			Topic:    topic,
+			Message:  msg,
+			Title:    title,
+			Priority: priority,
+			Tags:     tags,
 		})
 	}
 	if err := rows.Err(); err != nil {
@@ -86,7 +127,7 @@ func (c *sqliteCache) Messages(topic string, since sinceTime) ([]*message, error
 }
 
 func (c *sqliteCache) MessageCount(topic string) (int, error) {
-	rows, err := c.db.Query(selectMessageCountQuery, topic)
+	rows, err := c.db.Query(selectMessageCountForTopicQuery, topic)
 	if err != nil {
 		return 0, err
 	}
@@ -103,20 +144,19 @@ func (c *sqliteCache) MessageCount(topic string) (int, error) {
 	return count, nil
 }
 
-func (s *sqliteCache) Topics() (map[string]*topic, error) {
-	rows, err := s.db.Query(selectTopicsQuery)
+func (c *sqliteCache) Topics() (map[string]*topic, error) {
+	rows, err := c.db.Query(selectTopicsQuery)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-	topics := make(map[string]*topic, 0)
+	topics := make(map[string]*topic)
 	for rows.Next() {
 		var id string
-		var last int64
-		if err := rows.Scan(&id, &last); err != nil {
+		if err := rows.Scan(&id); err != nil {
 			return nil, err
 		}
-		topics[id] = newTopic(id, time.Unix(last, 0))
+		topics[id] = newTopic(id)
 	}
 	if err := rows.Err(); err != nil {
 		return nil, err
@@ -124,7 +164,64 @@ func (s *sqliteCache) Topics() (map[string]*topic, error) {
 	return topics, nil
 }
 
-func (c *sqliteCache) Prune(keep time.Duration) error {
-	_, err := c.db.Exec(pruneMessagesQuery, time.Now().Add(-1*keep).Unix())
+func (c *sqliteCache) Prune(olderThan time.Time) error {
+	_, err := c.db.Exec(pruneMessagesQuery, olderThan.Unix())
 	return err
 }
+
+func setupDB(db *sql.DB) error {
+	// If 'messages' table does not exist, this must be a new database
+	rowsMC, err := db.Query(selectMessagesCountQuery)
+	if err != nil {
+		return setupNewDB(db)
+	}
+	defer rowsMC.Close()
+
+	// If 'messages' table exists, check 'schemaVersion' table
+	schemaVersion := 0
+	rowsSV, err := db.Query(selectSchemaVersionQuery)
+	if err == nil {
+		defer rowsSV.Close()
+		if !rowsSV.Next() {
+			return errors.New("cannot determine schema version: cache file may be corrupt")
+		}
+		if err := rowsSV.Scan(&schemaVersion); err != nil {
+			return err
+		}
+	}
+
+	// Do migrations
+	if schemaVersion == currentSchemaVersion {
+		return nil
+	} else if schemaVersion == 0 {
+		return migrateFrom0To1(db)
+	}
+	return fmt.Errorf("unexpected schema version found: %d", schemaVersion)
+}
+
+func setupNewDB(db *sql.DB) error {
+	if _, err := db.Exec(createMessagesTableQuery); err != nil {
+		return err
+	}
+	if _, err := db.Exec(createSchemaVersionTableQuery); err != nil {
+		return err
+	}
+	if _, err := db.Exec(insertSchemaVersion, currentSchemaVersion); err != nil {
+		return err
+	}
+	return nil
+}
+
+func migrateFrom0To1(db *sql.DB) error {
+	log.Print("Migrating cache database schema: from 0 to 1")
+	if _, err := db.Exec(migrate0To1AlterMessagesTableQuery); err != nil {
+		return err
+	}
+	if _, err := db.Exec(createSchemaVersionTableQuery); err != nil {
+		return err
+	}
+	if _, err := db.Exec(insertSchemaVersion, 1); err != nil {
+		return err
+	}
+	return nil
+}

server/cache_sqlite_test.go

@@ -0,0 +1,91 @@
+package server
+
+import (
+	"database/sql"
+	"fmt"
+	"github.com/stretchr/testify/assert"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+func TestSqliteCache_AddMessage(t *testing.T) {
+	testCacheMessages(t, newSqliteTestCache(t))
+}
+
+func TestSqliteCache_Topics(t *testing.T) {
+	testCacheTopics(t, newSqliteTestCache(t))
+}
+
+func TestSqliteCache_MessagesTagsPrioAndTitle(t *testing.T) {
+	testCacheMessagesTagsPrioAndTitle(t, newSqliteTestCache(t))
+}
+
+func TestSqliteCache_Prune(t *testing.T) {
+	testCachePrune(t, newSqliteTestCache(t))
+}
+
+func TestSqliteCache_Migration_0to1(t *testing.T) {
+	filename := newSqliteTestCacheFile(t)
+	db, err := sql.Open("sqlite3", filename)
+	assert.Nil(t, err)
+
+	// Create "version 0" schema
+	_, err = db.Exec(`
+		BEGIN;
+		CREATE TABLE IF NOT EXISTS messages (
+			id VARCHAR(20) PRIMARY KEY,
+			time INT NOT NULL,
+			topic VARCHAR(64) NOT NULL,
+			message VARCHAR(1024) NOT NULL
+		);
+		CREATE INDEX IF NOT EXISTS idx_topic ON messages (topic);
+		COMMIT;
+	`)
+	assert.Nil(t, err)
+
+	// Insert a bunch of messages
+	for i := 0; i < 10; i++ {
+		_, err = db.Exec(`INSERT INTO messages (id, time, topic, message) VALUES (?, ?, ?, ?)`,
+			fmt.Sprintf("abcd%d", i), time.Now().Unix(), "mytopic", fmt.Sprintf("some message %d", i))
+		assert.Nil(t, err)
+	}
+
+	// Create cache to trigger migration
+	c := newSqliteTestCacheFromFile(t, filename)
+	messages, err := c.Messages("mytopic", sinceAllMessages)
+	assert.Nil(t, err)
+	assert.Equal(t, 10, len(messages))
+	assert.Equal(t, "some message 5", messages[5].Message)
+	assert.Equal(t, "", messages[5].Title)
+	assert.Nil(t, messages[5].Tags)
+	assert.Equal(t, 0, messages[5].Priority)
+
+	rows, err := c.db.Query(`SELECT version  FROM schemaVersion`)
+	assert.Nil(t, err)
+	assert.True(t, rows.Next())
+
+	var schemaVersion int
+	assert.Nil(t, rows.Scan(&schemaVersion))
+	assert.Equal(t, 1, schemaVersion)
+}
+
+func newSqliteTestCache(t *testing.T) *sqliteCache {
+	c, err := newSqliteCache(newSqliteTestCacheFile(t))
+	if err != nil {
+		t.Fatal(err)
+	}
+	return c
+}
+
+func newSqliteTestCacheFile(t *testing.T) string {
+	return filepath.Join(t.TempDir(), "cache.db")
+}
+
+func newSqliteTestCacheFromFile(t *testing.T, filename string) *sqliteCache {
+	c, err := newSqliteCache(filename)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return c
+}

server/cache_test.go

@@ -0,0 +1,123 @@
+package server
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+	"time"
+)
+
+func testCacheMessages(t *testing.T, c cache) {
+	m1 := newDefaultMessage("mytopic", "my message")
+	m1.Time = 1
+
+	m2 := newDefaultMessage("mytopic", "my other message")
+	m2.Time = 2
+
+	assert.Nil(t, c.AddMessage(m1))
+	assert.Nil(t, c.AddMessage(newDefaultMessage("example", "my example message")))
+	assert.Nil(t, c.AddMessage(m2))
+
+	// Adding invalid
+	assert.Equal(t, errUnexpectedMessageType, c.AddMessage(newKeepaliveMessage("mytopic"))) // These should not be added!
+	assert.Equal(t, errUnexpectedMessageType, c.AddMessage(newOpenMessage("example")))      // These should not be added!
+
+	// mytopic: count
+	count, err := c.MessageCount("mytopic")
+	assert.Nil(t, err)
+	assert.Equal(t, 2, count)
+
+	// mytopic: since all
+	messages, _ := c.Messages("mytopic", sinceAllMessages)
+	assert.Equal(t, 2, len(messages))
+	assert.Equal(t, "my message", messages[0].Message)
+	assert.Equal(t, "mytopic", messages[0].Topic)
+	assert.Equal(t, messageEvent, messages[0].Event)
+	assert.Equal(t, "", messages[0].Title)
+	assert.Equal(t, 0, messages[0].Priority)
+	assert.Nil(t, messages[0].Tags)
+	assert.Equal(t, "my other message", messages[1].Message)
+
+	// mytopic: since none
+	messages, _ = c.Messages("mytopic", sinceNoMessages)
+	assert.Empty(t, messages)
+
+	// mytopic: since 2
+	messages, _ = c.Messages("mytopic", sinceTime(time.Unix(2, 0)))
+	assert.Equal(t, 1, len(messages))
+	assert.Equal(t, "my other message", messages[0].Message)
+
+	// example: count
+	count, err = c.MessageCount("example")
+	assert.Nil(t, err)
+	assert.Equal(t, 1, count)
+
+	// example: since all
+	messages, _ = c.Messages("example", sinceAllMessages)
+	assert.Equal(t, "my example message", messages[0].Message)
+
+	// non-existing: count
+	count, err = c.MessageCount("doesnotexist")
+	assert.Nil(t, err)
+	assert.Equal(t, 0, count)
+
+	// non-existing: since all
+	messages, _ = c.Messages("doesnotexist", sinceAllMessages)
+	assert.Empty(t, messages)
+}
+
+func testCacheTopics(t *testing.T, c cache) {
+	assert.Nil(t, c.AddMessage(newDefaultMessage("topic1", "my example message")))
+	assert.Nil(t, c.AddMessage(newDefaultMessage("topic2", "message 1")))
+	assert.Nil(t, c.AddMessage(newDefaultMessage("topic2", "message 2")))
+	assert.Nil(t, c.AddMessage(newDefaultMessage("topic2", "message 3")))
+
+	topics, err := c.Topics()
+	if err != nil {
+		t.Fatal(err)
+	}
+	assert.Equal(t, 2, len(topics))
+	assert.Equal(t, "topic1", topics["topic1"].ID)
+	assert.Equal(t, "topic2", topics["topic2"].ID)
+}
+
+func testCachePrune(t *testing.T, c cache) {
+	m1 := newDefaultMessage("mytopic", "my message")
+	m1.Time = 1
+
+	m2 := newDefaultMessage("mytopic", "my other message")
+	m2.Time = 2
+
+	m3 := newDefaultMessage("another_topic", "and another one")
+	m3.Time = 1
+
+	assert.Nil(t, c.AddMessage(m1))
+	assert.Nil(t, c.AddMessage(m2))
+	assert.Nil(t, c.AddMessage(m3))
+	assert.Nil(t, c.Prune(time.Unix(2, 0)))
+
+	count, err := c.MessageCount("mytopic")
+	assert.Nil(t, err)
+	assert.Equal(t, 1, count)
+
+	count, err = c.MessageCount("another_topic")
+	assert.Nil(t, err)
+	assert.Equal(t, 0, count)
+
+	messages, err := c.Messages("mytopic", sinceAllMessages)
+	assert.Nil(t, err)
+	assert.Equal(t, 1, len(messages))
+	assert.Equal(t, "my other message", messages[0].Message)
+}
+
+func testCacheMessagesTagsPrioAndTitle(t *testing.T, c cache) {
+	m := newDefaultMessage("mytopic", "some message")
+	m.Tags = []string{"tag1", "tag2"}
+	m.Priority = 5
+	m.Title = "some title"
+	assert.Nil(t, c.AddMessage(m))
+
+	messages, _ := c.Messages("mytopic", sinceAllMessages)
+	assert.Equal(t, []string{"tag1", "tag2"}, messages[0].Tags)
+	assert.Equal(t, 5, messages[0].Priority)
+	assert.Equal(t, "some title", messages[0].Title)
+}

server/index.gohtml

@@ -4,7 +4,7 @@
 <head>
     <meta charset="UTF-8">
 
-    <title>ntfy.sh | simple HTTP-based pub-sub</title>
+    <title>ntfy.sh | Send push notifications to your phone via PUT/POST</title>
     <link rel="stylesheet" href="static/css/app.css" type="text/css">
 
     <!-- Mobile view -->
@@ -24,7 +24,7 @@
     <meta property="og:type" content="website" />
     <meta property="og:locale" content="en_US" />
     <meta property="og:site_name" content="ntfy.sh" />
-    <meta property="og:title" content="ntfy.sh | simple HTTP-based pub-sub" />
+    <meta property="og:title" content="ntfy.sh | Send push notifications to your phone or desktop via PUT/POST" />
     <meta property="og:description" content="ntfy is a simple HTTP-based pub-sub notification service. It allows you to send desktop notifications via scripts from any computer, entirely without signup or cost. Made with ❤ by Philipp C. Heckel, Apache License 2.0, source at https://heckel.io/ntfy." />
     <meta property="og:image" content="/static/img/ntfy.png" />
     <meta property="og:url" content="https://ntfy.sh" />
@@ -34,14 +34,27 @@
 {{end}}
 </head>
 <body>
-<div id="main"{{if .Topic}} style="display: none"{{end}}>
-    <h1><img src="static/img/ntfy.png" alt="ntfy"/><br/>ntfy.sh | simple HTTP-based pub-sub</h1>
-    <p>
-        <b>Ntfy</b> (pronounce: <i>notify</i>) is a simple HTTP-based <a href="https://en.wikipedia.org/wiki/Publish%E2%80%93subscribe_pattern">pub-sub</a> notification service.
-        It allows you to send notifications <a href="#subscribe-phone">to your phone</a> or desktop via scripts from any computer,
-        entirely <b>without signup or cost</b>. It's also <a href="https://github.com/binwiederhier/ntfy">open source</a> if you want to run your own.
-    </p>
 
+<nav id="header">
+    <div id="headerBox">
+        <img id="logo" src="static/img/ntfy.png" alt="logo"/>
+        <div id="name">ntfy</div>
+        <ol>
+            <li><a href="docs/">Getting started</a></li>
+            <li><a href="docs/subscribe/phone/">Android/iOS</a></li>
+            <li><a href="docs/publish/">API</a></li>
+            <li><a href="docs/install/">Self-hosting</a></li>
+            <li><a href="https://github.com/binwiederhier/ntfy">GitHub</a></li>
+        </ol>
+    </div>
+</nav>
+<div id="main"{{if .Topic}} style="display: none"{{end}}>
+    <h1>Send push notifications to your phone or desktop via PUT/POST</h1>
+    <p>
+        <b>ntfy</b> (pronounce: <i>notify</i>) is a simple HTTP-based <a href="https://en.wikipedia.org/wiki/Publish%E2%80%93subscribe_pattern">pub-sub</a> notification service.
+        It allows you to send notifications to your phone or desktop via scripts from any computer,
+        entirely <b>without signup, cost or setup</b>. It's also <a href="https://github.com/binwiederhier/ntfy">open source</a> if you want to run your own.
+    </p>
     <div id="screenshots">
         <a href="static/img/screenshot-curl.png"><img src="static/img/screenshot-curl.png"/></a>
         <a href="static/img/screenshot-web-detail.png"><img src="static/img/screenshot-web-detail.png"/></a>
@@ -52,51 +65,69 @@
         </span>
     </div>
 
-    <p>
-        There are many ways to use Ntfy. You can send yourself messages for all sorts of things: When a long process finishes or fails,
-        or to notify yourself when somebody logs into your server(s). Or you may want to use it in your own app to distribute messages to subscribed clients.
-        Endless possibilities 😀. Be sure to check out the <a href="#examples">examples below</a>.
-    </p>
-
     <h2 id="publish" class="anchor">Publishing messages</h2>
     <p>
-        Publishing messages can be done via PUT or POST. Topics are created on the fly by subscribing or publishing to them.
+        <a href="docs/publish/">Publishing messages</a> can be done via PUT or POST. Topics are created on the fly by subscribing or publishing to them.
         Because there is no sign-up, <b>the topic is essentially a password</b>, so pick something that's not easily guessable.
     </p>
     <p class="smallMarginBottom">
-        Here's an example showing how to publish a message using <tt>curl</tt> (via POST):
+        Here's an example showing how to publish a message using a POST request (via <tt>curl -d</tt>):
     </p>
     <code>
         curl -d "Backup successful 😀" <span class="ntfyUrl">ntfy.sh</span>/mytopic
     </code>
     <p class="smallMarginBottom">
-        And another one using PUT:
+        There are <a href="docs/publish/">more features</a> related to publishing messages: You can set a
+        <a href="docs/publish/#message-priority">notification priority</a>, a <a href="docs/publish/#message-title">title</a>,
+        and <a href="docs/publish/#tags-emojis">tag messages</a>.
+        Here's an example using some of them together:
     </p>
     <code>
-        echo -en "\u26A0\uFE0F Unauthorized login" | curl -sT- <span class="ntfyUrl">ntfy.sh</span>/mytopic
+        curl \<br/>
+        &nbsp;&nbsp;-H "Title: Unauthorized access detected" \<br/>
+        &nbsp;&nbsp;-H "Priority: urgent" \<br/>
+        &nbsp;&nbsp;-H "Tags: warning,skull" \<br/>
+        &nbsp;&nbsp;-d "Remote access to $(hostname) detected. Act right away." \<br/>
+        &nbsp;&nbsp;<span class="ntfyUrl">ntfy.sh</span>/mytopic
     </code>
-    <p class="smallMarginBottom">
-        Here's an example in JS with <tt>fetch()</tt> (see <a href="https://github.com/binwiederhier/ntfy/tree/main/examples">full example</a>):
+    <p>
+        Here's what that looks like in the <a href="docs/subscribe/phone/">Android app</a>:
     </p>
-    <code>
-        fetch('https://<span class="ntfyUrl">ntfy.sh</span>/mytopic', {<br/>
-        &nbsp;&nbsp;method: 'POST', // PUT works too<br/>
-        &nbsp;&nbsp;body: 'Hello from the other side.'<br/>
-        })
-    </code>
+    <figure>
+        <img src="static/img/priority-notification.png" style="max-height: 200px"/>
+        <figcaption>Urgent notification with pop-over</figcaption>
+    </figure>
 
     <h2 id="subscribe" class="anchor">Subscribe to a topic</h2>
     <p>
-        You can create and subscribe to a topic either in this web UI, or in your own app by subscribing to an
-        <a href="https://developer.mozilla.org/en-US/docs/Web/API/EventSource">EventSource</a>, a JSON feed, or raw feed.
+        You can create and subscribe to a topic either <a href="docs/subscribe/phone/">using your phone</a>,
+        in <a href="docs/subscribe/web/">this web UI</a>, or in your own app by <a href="docs/subscribe/api/">subscribing via the API</a>.
     </p>
 
+    <h3 id="subscribe-phone" class="anchor">Subscribe from your phone</h3>
+    <p>
+        Simply get the app and start <a href="docs/publish/">publishing messages</a>. To learn more about the app,
+        <a href="docs/subscribe/phone/">check out the documentation</a>.
+    </p>
+    <p>
+        <a href="https://play.google.com/store/apps/details?id=io.heckel.ntfy"><img src="static/img/badge-googleplay.png"></a>
+        <a href="https://f-droid.org/en/packages/io.heckel.ntfy/"><img src="static/img/badge-fdroid.png"></a>
+        <a href="https://github.com/binwiederhier/ntfy/issues/4"><img src="static/img/badge-appstore.png"></a>
+    </p>
+    <p>
+        Here's a video showing the app in action:
+    </p>
+    <figure>
+        <video controls muted autoplay loop src="static/img/android-video-overview.mp4" style="max-width: 650px"></video>
+        <figcaption>Sending push notifications to your Android phone</figcaption>
+    </figure>
+
     <div id="subscribeBox">
         <h3 id="subscribe-web" class="anchor">Subscribe in this Web UI</h3>
         <p id="error"></p>
         <p>
             Subscribe to topics here and receive messages as <b>desktop notification</b>. Topics are not password-protected,
-            so choose a name that's not easy to guess. Once subscribed, you can publish messages via PUT/POST.
+            so choose a name that's not easy to guess.
         </p>
         <form id="subscribeForm">
             <p>
@@ -110,224 +141,57 @@
         <audio id="notifySound" src="static/sound/mixkit-message-pop-alert-2354.mp3"></audio>
     </div>
 
-    <h3 id="subscribe-phone" class="anchor">Subscribe from your phone</h3>
+    <h3 id="subscribe-api" class="anchor">Subscribe using the API</h3>
     <p>
-        You can use the <a href="https://play.google.com/store/apps/details?id=io.heckel.ntfy">Ntfy Android App</a>
-        to receive notifications directly on your phone. Just like the server, this app is also <a href="https://github.com/binwiederhier/ntfy-android">open source</a>.
-        Since I don't have an iPhone or a Mac, I didn't make an iOS app yet. I'd be awesome if <a href="https://github.com/binwiederhier/ntfy/issues/4">someone else could help out</a>.
+        There's a super simple API that you can use to integrate your own app. You can consume
+        a <a href="docs/subscribe/api/#subscribe-as-json-stream">JSON stream</a>,
+        an <a href="docs/subscribe/api/#subscribe-as-sse-stream">SSE/EventSource stream</a> (useful for web apps),
+        as well as a <a href="docs/subscribe/api/#subscribe-as-raw-stream">plain text stream</a>.
     </p>
-    <p>
-        <a href="https://play.google.com/store/apps/details?id=io.heckel.ntfy"><img src="static/img/badge-googleplay.png"></a>
-        <a href="https://github.com/binwiederhier/ntfy/issues/4"><img src="static/img/badge-appstore.png"></a>
-    </p>
-
-    <h3 id="subscribe-api" class="anchor">Subscribe via your app, or via the CLI</h3>
     <p class="smallMarginBottom">
-        Using <a href="https://developer.mozilla.org/en-US/docs/Web/API/EventSource">EventSource</a> in JS, you can consume
-        notifications like this (see <a href="example.html">live example</a>):
-    </p>
-    <code>
-        const eventSource = new EventSource('<span class="ntfyProtocol">https://</span><span class="ntfyUrl">ntfy.sh</span>/mytopic/sse');<br/>
-        eventSource.onmessage = (e) => {<br/>
-        &nbsp;&nbsp;// Do something with e.data<br/>
-        };
-    </code>
-    <p class="smallMarginBottom">
-        You can also use the same <tt>/sse</tt> endpoint via <tt>curl</tt> or any other HTTP library:
-    </p>
-    <code>
-        $ curl -s <span class="ntfyUrl">ntfy.sh</span>/mytopic/sse<br/>
-        event: open<br/>
-        data: {"id":"weSj9RtNkj","time":1635528898,"event":"open","topic":"mytopic"}<br/><br/>
-
-        data: {"id":"p0M5y6gcCY","time":1635528909,"event":"message","topic":"mytopic","message":"Hi!"}<br/><br/>
-
-        event: keepalive<br/>
-        data: {"id":"VNxNIg5fpt","time":1635528928,"event":"keepalive","topic":"test"}
-    </code>
-    <p class="smallMarginBottom">
-        To consume JSON instead, use the <tt>/json</tt> endpoint, which prints one message per line:
+        Here's an example for JSON. The <b>connection stays open</b>, so you can retrieve messages as they come in:
     </p>
     <code>
         $ curl -s <span class="ntfyUrl">ntfy.sh</span>/mytopic/json<br/>
         {"id":"SLiKI64DOt","time":1635528757,"event":"open","topic":"mytopic"}<br/>
         {"id":"hwQ2YpKdmg","time":1635528741,"event":"message","topic":"mytopic","message":"Hi!"}<br/>
-        {"id":"DGUDShMCsc","time":1635528787,"event":"keepalive","topic":"mytopic"}
+        {"id":"DGUDShMCsc","time":1635528787,"event":"keepalive","topic":"mytopic"}<br/>
+        ...
     </code>
-    <p class="smallMarginBottom">
-        Or use the <tt>/raw</tt> endpoint if you need something super simple (empty lines are keepalive messages):
-    </p>
-    <code>
-        $ curl -s <span class="ntfyUrl">ntfy.sh</span>/mytopic/raw<br/>
-        <br/>
-        This is a notification<br/>
-        And another one with a smiley face 😀
-    </code>
-
-    <h2 id="other-features" class="anchor">Other features</h2>
-    <h3 id="fetching-cached-messages" class="anchor">Fetching cached messages (<tt>since=</tt>)</h3>
-    <p class="smallMarginBottom">
-        Messages are cached on disk for {{.CacheDuration}} to account for network interruptions of subscribers.
-        You can read back what you missed by using the <tt>since=</tt> query parameter. It takes either a
-        duration (e.g. <tt>10m</tt> or <tt>30s</tt>), a Unix timestamp (e.g. <tt>1635528757</tt>) or <tt>all</tt> (all
-        cached messages).
-    </p>
-    <code>
-        curl -s "<span class="ntfyUrl">ntfy.sh</span>/mytopic/json?since=10m"
-    </code>
-
-    <h3 id="polling" class="anchor">Polling (<tt>poll=1</tt>)</h3>
-    <p class="smallMarginBottom">
-        You can also just poll for messages if you don't like the long-standing connection using the <tt>poll=1</tt>
-        query parameter. The connection will end after all available messages have been read. This parameter can be
-        combined with <tt>since=</tt> (defaults to <tt>since=all</tt>).
-    </p>
-    <code>
-        curl -s "<span class="ntfyUrl">ntfy.sh</span>/mytopic/json?poll=1"
-    </code>
-
-    <h3 id="multiple-topics" class="anchor">Subscribing to multiple topics (<tt>topic1,topic2,...</tt>)</h3>
-    <p class="smallMarginBottom">
-        It's possible to subscribe to multiple topics in one HTTP call by providing a
-        comma-separated list of topics in the URL. This allows you to reduce the number of connections you have to maintain:
-    </p>
-    <code>
-        $ curl -s <span class="ntfyUrl">ntfy.sh</span>/mytopic1,mytopic2/json<br/>
-        {"id":"0OkXIryH3H","time":1637182619,"event":"open","topic":"mytopic1,mytopic2,mytopic3"}<br/>
-        {"id":"dzJJm7BCWs","time":1637182634,"event":"message","topic":"mytopic1","message":"for topic 1"}<br/>
-        {"id":"Cm02DsxUHb","time":1637182643,"event":"message","topic":"mytopic2","message":"for topic 2"}
-    </code>
-
-    <h2 id="examples" class="anchor">Examples</h2>
     <p>
-        There are a million ways to use Ntfy, but here are some inspirations. I try to collect
-        <a href="https://github.com/binwiederhier/ntfy/tree/main/examples">examples on GitHub</a>, so be sure to check
-        those out, too.
+        Here's a short video demonstrating it in action:
     </p>
+    <figure>
+        <video controls muted autoplay loop src="static/img/android-video-subscribe-api.mp4" style="max-width: 650px"></video>
+        <figcaption>Subscribing to the JSON stream with <tt>curl</tt></figcaption>
+    </figure>
 
-    <h3 id="example-alerts" class="anchor">Example: A long process is done: backups, copying data, pipelines, ...</h3>
-    <p class="smallMarginBottom">
-        I started adding notifications pretty much all of my scripts. Typically, I just chain the <tt>curl</tt> call
-        directly to the command I'm running. The following example will either send <i>Laptop backup succeeded</i>
-        or ⚠️ <i>Laptop backup failed</i> directly to my phone:
+    <h3 id="docs" class="anchor">Check out the docs!</h3>
+    <p>
+        ntfy has so many more features and you can learn about all of them <a href="docs/">in the documentation</a>
+        (I tried my very best to make it the best docs ever 😉, not sure if I succeeded, hehe).
     </p>
-    <code>
-        rsync -a root@laptop /backups/laptop \<br/>
-        &nbsp;&nbsp;&& zfs snapshot ... \<br/>
-        &nbsp;&nbsp;&& curl -d "Laptop backup succeeded" <span class="ntfyUrl">ntfy.sh</span>/backups \<br/>
-        &nbsp;&nbsp;|| echo -en "\u26A0\uFE0F Laptop backup failed" | curl -sT- <span class="ntfyUrl">ntfy.sh</span>/backups
-    </code>
+    <figure>
+        <a href="docs/"><img width="100%" src="static/img/screenshot-docs.png"/></a>
+        <figcaption>Check out the documentation</figcaption>
+    </figure>
 
-    <h3 id="example-web" class="anchor">Example: Server-sent messages in your web app</h3>
+    <h3 id="free-software" class="anchor">100% open source &amp; forever free</h3>
     <p>
-        Just as you can <a href="#subscribe-web">subscribe to topics in this Web UI</a>, you can use Ntfy in your own
-        web application. Check out the <a href="example.html">live example</a> or just look the source of this page.
-    </p>
-
-    <h3 id="example-notify-ssh" class="anchor">Example: Notify on SSH login</h3>
-    <p>
-        Years ago my home server was broken into. That shook me hard, so every time someone logs into any machine that I
-        own, I now message myself. Here's an example of how to use <a href="https://en.wikipedia.org/wiki/Linux_PAM">PAM</a>
-        to notify yourself on SSH login.
-    </p>
-    <p class="smallMarginBottom">
-        <b>/etc/pam.d/sshd</b> (at the end of the file):
-    </p>
-    <code>
-        session optional pam_exec.so /usr/local/bin/ntfy-ssh-login.sh
-    </code>
-    <p class="smallMarginBottom">
-        <b>/usr/local/bin/ntfy-ssh-login.sh</b>:
-    </p>
-    <code>
-        #!/bin/bash<br/>
-        if [ "${PAM_TYPE}" = "open_session" ]; then<br/>
-        &nbsp;&nbsp;echo -en "\u26A0\uFE0F SSH login: ${PAM_USER} from ${PAM_RHOST}" | curl -T- <span class="ntfyUrl">ntfy.sh</span>/alerts<br/>
-        fi
-    </code>
-
-    <h3 id="example-collect-data" class="anchor">Example: Collect data from multiple machines</h3>
-    <p>
-        The other day I was running tasks on 20 servers and I wanted to collect the interim results
-        as a CSV in one place. Here's the script I wrote:
-    </p>
-    <code>
-        while read result; do<br/>
-        &nbsp;&nbsp;[ -n "$result" ] && echo "$result" >> results.csv<br/>
-        done < <(stdbuf -i0 -o0 curl -s <span class="ntfyUrl">ntfy.sh</span>/results/raw)
-    </code>
-
-    <h2 id="faq" class="anchor">FAQ</h2>
-    <p>
-        <b id="isnt-this-like" class="anchor">Isn't this like ...?</b><br/>
-        Who knows. I didn't do a lot of research before making this. It was fun making it.
-    </p>
-
-    <p>
-        <b id="is-it-free" class="anchor">Can I use this in my app? Will it stay free?</b><br/>
-        Yes. As long as you don't abuse it, it'll be available and free of charge. I do not plan on monetizing
-        the service.
-    </p>
-
-    <p>
-        <b id="uptime-guarantees" class="anchor">What are the uptime guarantees?</b><br/>
-        Best effort.
-    </p>
-
-    <p>
-        <b id="multiple-subscribers" class="anchor">What happens if there are multiple subscribers to the same topic?</b><br/>
-        As per usual with pub-sub, all subscribers receive notifications if they are
-        subscribed to a topic.
-    </p>
-
-    <p>
-        <b id="can-you-spy-on-me" class="anchor">Will you know what topics exist, can you spy on me?</b><br/>
-        If you don't trust me or your messages are sensitive, run your own server. It's <a href="https://github.com/binwiederhier/ntfy">open source</a>.
-        That said, the logs do not contain any topic names or other details about you.
-        Messages are cached for {{.CacheDuration}} to facilitate service restarts, message polling and to overcome
-        client network disruptions.
-    </p>
-
-    <p>
-        <b id="selfhosted" class="anchor">Can I self-host it?</b><br/>
-        Yes. The server (including this Web UI) can be self-hosted, and the Android app supports adding topics from
-        your own server as well. There are <a href="https://github.com/binwiederhier/ntfy#installation">install instructions</a>
-        on GitHub.
-    </p>
-
-    <p>
-        <b id="why-firebase" class="anchor">Why is Firebase used?</b><br/>
-        In addition to caching messages locally and delivering them to long-polling subscribers, all messages are also
-        published to Firebase Cloud Messaging (FCM) (if <tt>FirebaseKeyFile</tt> is set, which it is on ntfy.sh). This
-        is to facilitate instant notifications on Android.
-    </p>
-
-    <p>
-        <b id="why-no-ios" class="anchor">Why is there no iOS app (yet)?</b><br/>
-        I don't have an iPhone or a Mac, so I didn't make an iOS app yet. I'd be awesome if
-        <a href="https://github.com/binwiederhier/ntfy/issues/4">someone else could help out</a>.
-    </p>
-
-    <h2 id="privacy" class="anchor">Privacy policy</h2>
-    <p>
-        Neither the server nor the app record any personal information, or share any of the messages and topics with
-        any outside service. All data is exclusively used to make the service function properly. The one exception
-        is the Firebase Cloud Messaging (FCM) service, which is required to provide instant Android notifications (see
-        FAQ for details).
-    </p>
-    <p>
-        The web server does not log or otherwise store request paths, remote IP addresses or even topics or messages,
-        aside from a short on-disk cache (for {{.CacheDuration}}) to support service restarts.
+        I love free software, and I'm doing this because it's fun. I have no bad intentions, and I will
+        never monetize or sell your information. This service will always stay
+        <a href="https://github.com/binwiederhier/ntfy">free and open</a>.
+        You can read more in the <a href="docs/faq/">FAQs</a> and in the <a href="docs/privacy/">privacy policy</a>.
     </p>
 
     <center id="ironicCenterTagDontFreakOut"><i>Made with ❤️ by <a href="https://heckel.io">Philipp C. Heckel</a></i></center>
 </div>
 <div id="detail"{{if not .Topic}} style="display: none"{{end}}>
     <div id="detailMain">
-        <button id="detailCloseButton"><img src="static/img/close_black_24dp.svg"/></button>
-        <h1><img src="static/img/ntfy.png" alt="ntfy"/><br/><span id="detailTitle"></span></h1>
+        <button id="detailCloseButton"><img src="static/img/close.svg"/></button>
+        <h1><span id="detailTitle"></span></h1>
         <p class="smallMarginBottom">
-            <b>Ntfy</b> is a simple HTTP-based pub-sub notification service. This is a Ntfy topic.
+            <b>ntfy</b> is a simple HTTP-based pub-sub notification service. This is a ntfy topic.
             To send notifications to it, simply PUT or POST to the topic URL. Here's an example using <tt>curl</tt>:
         </p>
         <code>
@@ -339,7 +203,7 @@
             Click the link to do so.
         </p>
         <p class="smallMarginBottom">
-            <b>Recent notifications</b> (cached for {{.CacheDuration}}):
+            <b>Recent notifications</b> ({{if .CacheDuration}}cached for {{.CacheDuration | durationToHuman}}{{else}}caching is disabled{{end}}):
         </p>
         <p id="detailNoNotifications">
             <i>You haven't received any notifications for this topic yet.</i>
@@ -348,6 +212,7 @@
     </div>
 </div>
 <div id="lightbox" class="lightbox"></div>
+<script src="static/js/emoji.js"></script>
 <script src="static/js/app.js"></script>
 </body>
 </html>

server/message.go

@@ -18,11 +18,14 @@ const (
 
 // message represents a message published to a topic
 type message struct {
-	ID      string `json:"id"`    // Random message ID
-	Time    int64  `json:"time"`  // Unix time in seconds
-	Event   string `json:"event"` // One of the above
-	Topic   string `json:"topic"`
-	Message string `json:"message,omitempty"`
+	ID       string   `json:"id"`    // Random message ID
+	Time     int64    `json:"time"`  // Unix time in seconds
+	Event    string   `json:"event"` // One of the above
+	Topic    string   `json:"topic"`
+	Priority int      `json:"priority,omitempty"`
+	Tags     []string `json:"tags,omitempty"`
+	Title    string   `json:"title,omitempty"`
+	Message  string   `json:"message,omitempty"`
 }
 
 // messageEncoder is a function that knows how to encode a message
@@ -31,11 +34,14 @@ type messageEncoder func(msg *message) (string, error)
 // newMessage creates a new message with the current timestamp
 func newMessage(event, topic, msg string) *message {
 	return &message{
-		ID:      util.RandomString(messageIDLength),
-		Time:    time.Now().Unix(),
-		Event:   event,
-		Topic:   topic,
-		Message: msg,
+		ID:       util.RandomString(messageIDLength),
+		Time:     time.Now().Unix(),
+		Event:    event,
+		Topic:    topic,
+		Priority: 0,
+		Tags:     nil,
+		Title:    "",
+		Message:  msg,
 	}
 }
 

server/server.go

@@ -3,8 +3,7 @@ package server
 import (
 	"bytes"
 	"context"
-	"embed"
-	_ "embed" // required for go:embed
+	"embed" // required for go:embed
 	"encoding/json"
 	firebase "firebase.google.com/go"
 	"firebase.google.com/go/messaging"
@@ -27,7 +26,7 @@ import (
 // TODO add "max messages in a topic" limit
 // TODO implement "since=<ID>"
 
-// Server is the main server
+// Server is the main server, providing the UI and API for ntfy
 type Server struct {
 	config   *config.Config
 	topics   map[string]*topic
@@ -50,7 +49,7 @@ func (e errHTTP) Error() string {
 
 type indexPage struct {
 	Topic         string
-	CacheDuration string
+	CacheDuration time.Duration
 }
 
 type sinceTime time.Time
@@ -82,23 +81,36 @@ var (
 	sseRegex   = regexp.MustCompile(`^/[-_A-Za-z0-9]{1,64}(,[-_A-Za-z0-9]{1,64})*/sse$`)
 	rawRegex   = regexp.MustCompile(`^/[-_A-Za-z0-9]{1,64}(,[-_A-Za-z0-9]{1,64})*/raw$`)
 
-	staticRegex = regexp.MustCompile(`^/static/.+`)
+	staticRegex      = regexp.MustCompile(`^/static/.+`)
+	docsRegex        = regexp.MustCompile(`^/docs(|/.*)$`)
+	disallowedTopics = []string{"docs", "static"}
+
+	templateFnMap = template.FuncMap{
+		"durationToHuman": util.DurationToHuman,
+	}
 
 	//go:embed "index.gohtml"
 	indexSource   string
-	indexTemplate = template.Must(template.New("index").Parse(indexSource))
+	indexTemplate = template.Must(template.New("index").Funcs(templateFnMap).Parse(indexSource))
 
 	//go:embed "example.html"
-	exampleSource   string
+	exampleSource string
 
 	//go:embed static
-	webStaticFs embed.FS
+	webStaticFs       embed.FS
+	webStaticFsCached = &util.CachingEmbedFS{ModTime: time.Now(), FS: webStaticFs}
+
+	//go:embed docs
+	docsStaticFs     embed.FS
+	docsStaticCached = &util.CachingEmbedFS{ModTime: time.Now(), FS: docsStaticFs}
 
 	errHTTPBadRequest      = &errHTTP{http.StatusBadRequest, http.StatusText(http.StatusBadRequest)}
 	errHTTPNotFound        = &errHTTP{http.StatusNotFound, http.StatusText(http.StatusNotFound)}
 	errHTTPTooManyRequests = &errHTTP{http.StatusTooManyRequests, http.StatusText(http.StatusTooManyRequests)}
 )
 
+// New instantiates a new Server. It creates the cache and adds a Firebase
+// subscriber (if configured).
 func New(conf *config.Config) (*Server, error) {
 	var firebaseSubscriber subscriber
 	if conf.FirebaseKeyFile != "" {
@@ -116,11 +128,6 @@ func New(conf *config.Config) (*Server, error) {
 	if err != nil {
 		return nil, err
 	}
-	for _, t := range topics {
-		if firebaseSubscriber != nil {
-			t.Subscribe(firebaseSubscriber)
-		}
-	}
 	return &Server{
 		config:   conf,
 		cache:    cache,
@@ -131,7 +138,9 @@ func New(conf *config.Config) (*Server, error) {
 }
 
 func createCache(conf *config.Config) (cache, error) {
-	if conf.CacheFile != "" {
+	if conf.CacheDuration == 0 {
+		return newNopCache(), nil
+	} else if conf.CacheFile != "" {
 		return newSqliteCache(conf.CacheFile)
 	}
 	return newMemCache(), nil
@@ -150,17 +159,22 @@ func createFirebaseSubscriber(conf *config.Config) (subscriber, error) {
 		_, err := msg.Send(context.Background(), &messaging.Message{
 			Topic: m.Topic,
 			Data: map[string]string{
-				"id":      m.ID,
-				"time":    fmt.Sprintf("%d", m.Time),
-				"event":   m.Event,
-				"topic":   m.Topic,
-				"message": m.Message,
+				"id":       m.ID,
+				"time":     fmt.Sprintf("%d", m.Time),
+				"event":    m.Event,
+				"topic":    m.Topic,
+				"priority": fmt.Sprintf("%d", m.Priority),
+				"tags":     strings.Join(m.Tags, ","),
+				"title":    m.Title,
+				"message":  m.Message,
 			},
 		})
 		return err
 	}, nil
 }
 
+// Run executes the main server. It listens on HTTP (+ HTTPS, if configured), and starts
+// a manager go routine to print stats and prune messages.
 func (s *Server) Run() error {
 	go func() {
 		ticker := time.NewTicker(s.config.ManagerInterval)
@@ -169,13 +183,23 @@ func (s *Server) Run() error {
 			s.updateStatsAndExpire()
 		}
 	}()
-	return s.listenAndServe()
-}
+	listenStr := fmt.Sprintf("%s/http", s.config.ListenHTTP)
+	if s.config.ListenHTTPS != "" {
+		listenStr += fmt.Sprintf(" %s/https", s.config.ListenHTTPS)
+	}
+	log.Printf("Listening on %s", listenStr)
 
-func (s *Server) listenAndServe() error {
-	log.Printf("Listening on %s", s.config.ListenHTTP)
 	http.HandleFunc("/", s.handle)
-	return http.ListenAndServe(s.config.ListenHTTP, nil)
+	errChan := make(chan error)
+	go func() {
+		errChan <- http.ListenAndServe(s.config.ListenHTTP, nil)
+	}()
+	if s.config.ListenHTTPS != "" {
+		go func() {
+			errChan <- http.ListenAndServeTLS(s.config.ListenHTTPS, s.config.CertFile, s.config.KeyFile, nil)
+		}()
+	}
+	return <-errChan
 }
 
 func (s *Server) handle(w http.ResponseWriter, r *http.Request) {
@@ -189,7 +213,7 @@ func (s *Server) handle(w http.ResponseWriter, r *http.Request) {
 }
 
 func (s *Server) handleInternal(w http.ResponseWriter, r *http.Request) error {
-	if r.Method == http.MethodGet && (r.URL.Path == "/" || topicRegex.MatchString(r.URL.Path)) {
+	if r.Method == http.MethodGet && r.URL.Path == "/" {
 		return s.handleHome(w, r)
 	} else if r.Method == http.MethodGet && r.URL.Path == "/example.html" {
 		return s.handleExample(w, r)
@@ -197,8 +221,12 @@ func (s *Server) handleInternal(w http.ResponseWriter, r *http.Request) error {
 		return s.handleEmpty(w, r)
 	} else if r.Method == http.MethodGet && staticRegex.MatchString(r.URL.Path) {
 		return s.handleStatic(w, r)
+	} else if r.Method == http.MethodGet && docsRegex.MatchString(r.URL.Path) {
+		return s.handleDocs(w, r)
 	} else if r.Method == http.MethodOptions {
 		return s.handleOptions(w, r)
+	} else if r.Method == http.MethodGet && topicRegex.MatchString(r.URL.Path) {
+		return s.handleHome(w, r)
 	} else if (r.Method == http.MethodPut || r.Method == http.MethodPost) && topicRegex.MatchString(r.URL.Path) {
 		return s.withRateLimit(w, r, s.handlePublish)
 	} else if r.Method == http.MethodGet && jsonRegex.MatchString(r.URL.Path) {
@@ -214,25 +242,30 @@ func (s *Server) handleInternal(w http.ResponseWriter, r *http.Request) error {
 func (s *Server) handleHome(w http.ResponseWriter, r *http.Request) error {
 	return indexTemplate.Execute(w, &indexPage{
 		Topic:         r.URL.Path[1:],
-		CacheDuration: util.DurationToHuman(s.config.CacheDuration),
+		CacheDuration: s.config.CacheDuration,
 	})
 }
 
-func (s *Server) handleEmpty(w http.ResponseWriter, r *http.Request) error {
+func (s *Server) handleEmpty(_ http.ResponseWriter, _ *http.Request) error {
 	return nil
 }
 
-func (s *Server) handleExample(w http.ResponseWriter, r *http.Request) error {
+func (s *Server) handleExample(w http.ResponseWriter, _ *http.Request) error {
 	_, err := io.WriteString(w, exampleSource)
 	return err
 }
 
 func (s *Server) handleStatic(w http.ResponseWriter, r *http.Request) error {
-	http.FileServer(http.FS(webStaticFs)).ServeHTTP(w, r)
+	http.FileServer(http.FS(webStaticFsCached)).ServeHTTP(w, r)
 	return nil
 }
 
-func (s *Server) handlePublish(w http.ResponseWriter, r *http.Request, v *visitor) error {
+func (s *Server) handleDocs(w http.ResponseWriter, r *http.Request) error {
+	http.FileServer(http.FS(docsStaticCached)).ServeHTTP(w, r)
+	return nil
+}
+
+func (s *Server) handlePublish(w http.ResponseWriter, r *http.Request, _ *visitor) error {
 	t, err := s.topicFromID(r.URL.Path[1:])
 	if err != nil {
 		return err
@@ -242,15 +275,28 @@ func (s *Server) handlePublish(w http.ResponseWriter, r *http.Request, v *visito
 	if err != nil {
 		return err
 	}
-	m := newDefaultMessage(t.id, string(b))
+	m := newDefaultMessage(t.ID, string(b))
 	if m.Message == "" {
 		return errHTTPBadRequest
 	}
+	title, priority, tags, cache, firebase := parseHeaders(r.Header)
+	m.Title = title
+	m.Priority = priority
+	m.Tags = tags
 	if err := t.Publish(m); err != nil {
 		return err
 	}
-	if err := s.cache.AddMessage(m); err != nil {
-		return err
+	if s.firebase != nil && firebase {
+		go func() {
+			if err := s.firebase(m); err != nil {
+				log.Printf("Unable to publish to Firebase: %v", err.Error())
+			}
+		}()
+	}
+	if cache {
+		if err := s.cache.AddMessage(m); err != nil {
+			return err
+		}
 	}
 	w.Header().Set("Access-Control-Allow-Origin", "*") // CORS, allow cross-origin requests
 	if err := json.NewEncoder(w).Encode(m); err != nil {
@@ -262,6 +308,47 @@ func (s *Server) handlePublish(w http.ResponseWriter, r *http.Request, v *visito
 	return nil
 }
 
+func parseHeaders(header http.Header) (title string, priority int, tags []string, cache bool, firebase bool) {
+	title = readHeader(header, "x-title", "title", "ti", "t")
+	priorityStr := readHeader(header, "x-priority", "priority", "prio", "p")
+	if priorityStr != "" {
+		switch strings.ToLower(priorityStr) {
+		case "1", "min":
+			priority = 1
+		case "2", "low":
+			priority = 2
+		case "3", "default":
+			priority = 3
+		case "4", "high":
+			priority = 4
+		case "5", "max", "urgent":
+			priority = 5
+		default:
+			priority = 0
+		}
+	}
+	tagsStr := readHeader(header, "x-tags", "tag", "tags", "ta")
+	if tagsStr != "" {
+		tags = make([]string, 0)
+		for _, s := range strings.Split(tagsStr, ",") {
+			tags = append(tags, strings.TrimSpace(s))
+		}
+	}
+	cache = readHeader(header, "x-cache", "cache") != "no"
+	firebase = readHeader(header, "x-firebase", "firebase") != "no"
+	return title, priority, tags, cache, firebase
+}
+
+func readHeader(header http.Header, names ...string) string {
+	for _, name := range names {
+		value := header.Get(name)
+		if value != "" {
+			return strings.TrimSpace(value)
+		}
+	}
+	return ""
+}
+
 func (s *Server) handleSubscribeJSON(w http.ResponseWriter, r *http.Request, v *visitor) error {
 	encoder := func(msg *message) (string, error) {
 		var buf bytes.Buffer
@@ -312,8 +399,11 @@ func (s *Server) handleSubscribe(w http.ResponseWriter, r *http.Request, v *visi
 	if err != nil {
 		return err
 	}
+	var wlock sync.Mutex
 	poll := r.URL.Query().Has("poll")
 	sub := func(msg *message) error {
+		wlock.Lock()
+		defer wlock.Unlock()
 		m, err := encoder(msg)
 		if err != nil {
 			return err
@@ -364,7 +454,7 @@ func (s *Server) sendOldMessages(topics []*topic, since sinceTime, sub subscribe
 		return nil
 	}
 	for _, t := range topics {
-		messages, err := s.cache.Messages(t.id, since)
+		messages, err := s.cache.Messages(t.ID, since)
 		if err != nil {
 			return err
 		}
@@ -390,17 +480,15 @@ func parseSince(r *http.Request) (sinceTime, error) {
 	}
 	if r.URL.Query().Get("since") == "all" {
 		return sinceAllMessages, nil
-	}
-	if s, err := strconv.ParseInt(r.URL.Query().Get("since"), 10, 64); err == nil {
+	} else if s, err := strconv.ParseInt(r.URL.Query().Get("since"), 10, 64); err == nil {
 		return sinceTime(time.Unix(s, 0)), nil
-	}
-	if d, err := time.ParseDuration(r.URL.Query().Get("since")); err == nil {
+	} else if d, err := time.ParseDuration(r.URL.Query().Get("since")); err == nil {
 		return sinceTime(time.Now().Add(-1 * d)), nil
 	}
 	return sinceNoMessages, errHTTPBadRequest
 }
 
-func (s *Server) handleOptions(w http.ResponseWriter, r *http.Request) error {
+func (s *Server) handleOptions(w http.ResponseWriter, _ *http.Request) error {
 	w.Header().Set("Access-Control-Allow-Origin", "*") // CORS, allow cross-origin requests
 	w.Header().Set("Access-Control-Allow-Methods", "GET, PUT, POST")
 	return nil
@@ -414,19 +502,19 @@ func (s *Server) topicFromID(id string) (*topic, error) {
 	return topics[0], nil
 }
 
-func (s *Server) topicsFromIDs(ids... string) ([]*topic, error) {
+func (s *Server) topicsFromIDs(ids ...string) ([]*topic, error) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	topics := make([]*topic, 0)
-	for  _, id := range ids {
+	for _, id := range ids {
+		if util.InStringList(disallowedTopics, id) {
+			return nil, errHTTPBadRequest
+		}
 		if _, ok := s.topics[id]; !ok {
 			if len(s.topics) >= s.config.GlobalTopicLimit {
 				return nil, errHTTPTooManyRequests
 			}
-			s.topics[id] = newTopic(id, time.Now())
-			if s.firebase != nil {
-				s.topics[id].Subscribe(s.firebase)
-			}
+			s.topics[id] = newTopic(id)
 		}
 		topics = append(topics, s.topics[id])
 	}
@@ -445,7 +533,8 @@ func (s *Server) updateStatsAndExpire() {
 	}
 
 	// Prune cache
-	if err := s.cache.Prune(s.config.CacheDuration); err != nil {
+	olderThan := time.Now().Add(-1 * s.config.CacheDuration)
+	if err := s.cache.Prune(olderThan); err != nil {
 		log.Printf("error pruning cache: %s", err.Error())
 	}
 
@@ -453,13 +542,13 @@ func (s *Server) updateStatsAndExpire() {
 	var subscribers, messages int
 	for _, t := range s.topics {
 		subs := t.Subscribers()
-		msgs, err := s.cache.MessageCount(t.id)
+		msgs, err := s.cache.MessageCount(t.ID)
 		if err != nil {
-			log.Printf("cannot get stats for topic %s: %s", t.id, err.Error())
+			log.Printf("cannot get stats for topic %s: %s", t.ID, err.Error())
 			continue
 		}
-		if msgs == 0 && (subs == 0 || (s.firebase != nil && subs == 1)) { // Firebase is a subscriber!
-			delete(s.topics, t.id)
+		if msgs == 0 && subs == 0 {
+			delete(s.topics, t.ID)
 			continue
 		}
 		subscribers += subs
@@ -504,5 +593,5 @@ func (s *Server) visitor(r *http.Request) *visitor {
 func (s *Server) fail(w http.ResponseWriter, r *http.Request, code int, err error) {
 	log.Printf("[%s] %s - %d - %s", r.RemoteAddr, r.Method, code, err.Error())
 	w.WriteHeader(code)
-	io.WriteString(w, fmt.Sprintf("%s\n", http.StatusText(code)))
+	_, _ = io.WriteString(w, fmt.Sprintf("%s\n", http.StatusText(code)))
 }

server/server_test.go

@@ -0,0 +1,283 @@
+package server
+
+import (
+	"bufio"
+	"context"
+	"encoding/json"
+	"github.com/stretchr/testify/assert"
+	"heckel.io/ntfy/config"
+	"net/http"
+	"net/http/httptest"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestServer_PublishAndPoll(t *testing.T) {
+	s := newTestServer(t, newTestConfig(t))
+
+	response1 := request(t, s, "PUT", "/mytopic", "my first message", nil)
+	msg1 := toMessage(t, response1.Body.String())
+	assert.NotEmpty(t, msg1.ID)
+	assert.Equal(t, "my first message", msg1.Message)
+
+	response2 := request(t, s, "PUT", "/mytopic", "my second\n\nmessage", nil)
+	msg2 := toMessage(t, response2.Body.String())
+	assert.NotEqual(t, msg1.ID, msg2.ID)
+	assert.NotEmpty(t, msg2.ID)
+	assert.Equal(t, "my second\n\nmessage", msg2.Message)
+
+	response := request(t, s, "GET", "/mytopic/json?poll=1", "", nil)
+	messages := toMessages(t, response.Body.String())
+	assert.Equal(t, 2, len(messages))
+	assert.Equal(t, "my first message", messages[0].Message)
+	assert.Equal(t, "my second\n\nmessage", messages[1].Message)
+
+	response = request(t, s, "GET", "/mytopic/sse?poll=1", "", nil)
+	lines := strings.Split(strings.TrimSpace(response.Body.String()), "\n")
+	assert.Equal(t, 3, len(lines))
+	assert.Equal(t, "my first message", toMessage(t, strings.TrimPrefix(lines[0], "data: ")).Message)
+	assert.Equal(t, "", lines[1])
+	assert.Equal(t, "my second\n\nmessage", toMessage(t, strings.TrimPrefix(lines[2], "data: ")).Message)
+
+	response = request(t, s, "GET", "/mytopic/raw?poll=1", "", nil)
+	lines = strings.Split(strings.TrimSpace(response.Body.String()), "\n")
+	assert.Equal(t, 2, len(lines))
+	assert.Equal(t, "my first message", lines[0])
+	assert.Equal(t, "my second  message", lines[1]) // \n -> " "
+}
+
+func TestServer_SubscribeOpenAndKeepalive(t *testing.T) {
+	c := newTestConfig(t)
+	c.KeepaliveInterval = time.Second
+	s := newTestServer(t, c)
+
+	rr := httptest.NewRecorder()
+	ctx, cancel := context.WithCancel(context.Background())
+	req, err := http.NewRequestWithContext(ctx, "GET", "/mytopic/json", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	doneChan := make(chan bool)
+	go func() {
+		s.handle(rr, req)
+		doneChan <- true
+	}()
+	time.Sleep(1300 * time.Millisecond)
+	cancel()
+	<-doneChan
+
+	messages := toMessages(t, rr.Body.String())
+	assert.Equal(t, 2, len(messages))
+
+	assert.Equal(t, openEvent, messages[0].Event)
+	assert.Equal(t, "mytopic", messages[0].Topic)
+	assert.Equal(t, "", messages[0].Message)
+	assert.Equal(t, "", messages[0].Title)
+	assert.Equal(t, 0, messages[0].Priority)
+	assert.Nil(t, messages[0].Tags)
+
+	assert.Equal(t, keepaliveEvent, messages[1].Event)
+	assert.Equal(t, "mytopic", messages[1].Topic)
+	assert.Equal(t, "", messages[1].Message)
+	assert.Equal(t, "", messages[1].Title)
+	assert.Equal(t, 0, messages[1].Priority)
+	assert.Nil(t, messages[1].Tags)
+}
+
+func TestServer_PublishAndSubscribe(t *testing.T) {
+	s := newTestServer(t, newTestConfig(t))
+
+	subscribeRR := httptest.NewRecorder()
+	subscribeCancel := subscribe(t, s, "/mytopic/json", subscribeRR)
+
+	publishFirstRR := request(t, s, "PUT", "/mytopic", "my first message", nil)
+	assert.Equal(t, 200, publishFirstRR.Code)
+
+	publishSecondRR := request(t, s, "PUT", "/mytopic", "my other message", map[string]string{
+		"Title":  " This is a title ",
+		"X-Tags": "tag1,tag 2, tag3",
+		"p":      "1",
+	})
+	assert.Equal(t, 200, publishSecondRR.Code)
+
+	subscribeCancel()
+	messages := toMessages(t, subscribeRR.Body.String())
+	assert.Equal(t, 3, len(messages))
+	assert.Equal(t, openEvent, messages[0].Event)
+
+	assert.Equal(t, messageEvent, messages[1].Event)
+	assert.Equal(t, "mytopic", messages[1].Topic)
+	assert.Equal(t, "my first message", messages[1].Message)
+	assert.Equal(t, "", messages[1].Title)
+	assert.Equal(t, 0, messages[1].Priority)
+	assert.Nil(t, messages[1].Tags)
+
+	assert.Equal(t, messageEvent, messages[2].Event)
+	assert.Equal(t, "mytopic", messages[2].Topic)
+	assert.Equal(t, "my other message", messages[2].Message)
+	assert.Equal(t, "This is a title", messages[2].Title)
+	assert.Equal(t, 1, messages[2].Priority)
+	assert.Equal(t, []string{"tag1", "tag 2", "tag3"}, messages[2].Tags)
+}
+
+func TestServer_StaticSites(t *testing.T) {
+	s := newTestServer(t, newTestConfig(t))
+
+	rr := request(t, s, "GET", "/", "", nil)
+	assert.Equal(t, 200, rr.Code)
+	assert.Contains(t, rr.Body.String(), "</html>")
+
+	rr = request(t, s, "HEAD", "/", "", nil)
+	assert.Equal(t, 200, rr.Code)
+
+	rr = request(t, s, "GET", "/does-not-exist.txt", "", nil)
+	assert.Equal(t, 404, rr.Code)
+
+	rr = request(t, s, "GET", "/mytopic", "", nil)
+	assert.Equal(t, 200, rr.Code)
+	assert.Contains(t, rr.Body.String(), `<meta name="robots" content="noindex, nofollow" />`)
+
+	rr = request(t, s, "GET", "/static/css/app.css", "", nil)
+	assert.Equal(t, 200, rr.Code)
+	assert.Contains(t, rr.Body.String(), `html, body {`)
+
+	rr = request(t, s, "GET", "/docs", "", nil)
+	assert.Equal(t, 301, rr.Code)
+
+	rr = request(t, s, "GET", "/docs/", "", nil)
+	assert.Equal(t, 200, rr.Code)
+	assert.Contains(t, rr.Body.String(), `Made with ❤️ by Philipp C. Heckel`)
+	assert.Contains(t, rr.Body.String(), `<script src=static/js/extra.js></script>`)
+}
+
+func TestServer_PublishNoCache(t *testing.T) {
+	s := newTestServer(t, newTestConfig(t))
+
+	response := request(t, s, "PUT", "/mytopic", "this message is not cached", map[string]string{
+		"Cache": "no",
+	})
+	msg := toMessage(t, response.Body.String())
+	assert.NotEmpty(t, msg.ID)
+	assert.Equal(t, "this message is not cached", msg.Message)
+
+	response = request(t, s, "GET", "/mytopic/json?poll=1", "", nil)
+	messages := toMessages(t, response.Body.String())
+	assert.Empty(t, messages)
+}
+
+func TestServer_PublishAndMultiPoll(t *testing.T) {
+	s := newTestServer(t, newTestConfig(t))
+
+	response := request(t, s, "PUT", "/mytopic1", "message 1", nil)
+	msg := toMessage(t, response.Body.String())
+	assert.NotEmpty(t, msg.ID)
+	assert.Equal(t, "mytopic1", msg.Topic)
+	assert.Equal(t, "message 1", msg.Message)
+
+	response = request(t, s, "PUT", "/mytopic2", "message 2", nil)
+	msg = toMessage(t, response.Body.String())
+	assert.NotEmpty(t, msg.ID)
+	assert.Equal(t, "mytopic2", msg.Topic)
+	assert.Equal(t, "message 2", msg.Message)
+
+	response = request(t, s, "GET", "/mytopic1/json?poll=1", "", nil)
+	messages := toMessages(t, response.Body.String())
+	assert.Equal(t, 1, len(messages))
+	assert.Equal(t, "mytopic1", messages[0].Topic)
+	assert.Equal(t, "message 1", messages[0].Message)
+
+	response = request(t, s, "GET", "/mytopic1,mytopic2/json?poll=1", "", nil)
+	messages = toMessages(t, response.Body.String())
+	assert.Equal(t, 2, len(messages))
+	assert.Equal(t, "mytopic1", messages[0].Topic)
+	assert.Equal(t, "message 1", messages[0].Message)
+	assert.Equal(t, "mytopic2", messages[1].Topic)
+	assert.Equal(t, "message 2", messages[1].Message)
+}
+
+func TestServer_PublishWithNopCache(t *testing.T) {
+	c := newTestConfig(t)
+	c.CacheDuration = 0
+	s := newTestServer(t, c)
+
+	subscribeRR := httptest.NewRecorder()
+	subscribeCancel := subscribe(t, s, "/mytopic/json", subscribeRR)
+
+	publishRR := request(t, s, "PUT", "/mytopic", "my first message", nil)
+	assert.Equal(t, 200, publishRR.Code)
+
+	subscribeCancel()
+	messages := toMessages(t, subscribeRR.Body.String())
+	assert.Equal(t, 2, len(messages))
+	assert.Equal(t, openEvent, messages[0].Event)
+	assert.Equal(t, messageEvent, messages[1].Event)
+	assert.Equal(t, "my first message", messages[1].Message)
+
+	response := request(t, s, "GET", "/mytopic/json?poll=1", "", nil)
+	messages = toMessages(t, response.Body.String())
+	assert.Empty(t, messages)
+}
+
+func newTestConfig(t *testing.T) *config.Config {
+	conf := config.New(":80")
+	conf.CacheFile = filepath.Join(t.TempDir(), "cache.db")
+	return conf
+}
+
+func newTestServer(t *testing.T, config *config.Config) *Server {
+	server, err := New(config)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return server
+}
+
+func request(t *testing.T, s *Server, method, url, body string, headers map[string]string) *httptest.ResponseRecorder {
+	rr := httptest.NewRecorder()
+	req, err := http.NewRequest(method, url, strings.NewReader(body))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for k, v := range headers {
+		req.Header.Set(k, v)
+	}
+	s.handle(rr, req)
+	return rr
+}
+
+func subscribe(t *testing.T, s *Server, url string, rr *httptest.ResponseRecorder) context.CancelFunc {
+	ctx, cancel := context.WithCancel(context.Background())
+	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	done := make(chan bool)
+	go func() {
+		s.handle(rr, req)
+		done <- true
+	}()
+	cancelAndWaitForDone := func() {
+		time.Sleep(100 * time.Millisecond)
+		cancel()
+		<-done
+	}
+	time.Sleep(100 * time.Millisecond)
+	return cancelAndWaitForDone
+}
+
+func toMessages(t *testing.T, s string) []*message {
+	messages := make([]*message, 0)
+	scanner := bufio.NewScanner(strings.NewReader(s))
+	for scanner.Scan() {
+		messages = append(messages, toMessage(t, scanner.Text()))
+	}
+	return messages
+}
+
+func toMessage(t *testing.T, s string) *message {
+	var m message
+	assert.Nil(t, json.NewDecoder(strings.NewReader(s)).Decode(&m))
+	return &m
+}

server/static/css/app.css

@@ -1,9 +1,12 @@
 /* general styling */
 
 html, body {
-    font-family: 'Lato', sans-serif;
-    color: #333;
+    font-family: 'Roboto', sans-serif;
+    font-weight: 400;
     font-size: 1.1em;
+    color: #444;
+    margin: 0;
+    padding: 0;
 }
 
 html {
@@ -22,34 +25,46 @@ a:hover {
 }
 
 h1 {
-    margin-top: 25px;
-    margin-bottom: 18px;
+    margin-top: 35px;
+    margin-bottom: 30px;
     font-size: 2.5em;
+    word-wrap: break-word; /* For very long topics */
+    padding-right: 40px; /* For the X on the detail page */
+    font-weight: 300;
+    color: #666;
 }
 
 h2 {
     margin-top: 30px;
     margin-bottom: 5px;
     font-size: 1.8em;
+    font-weight: 300;
+    color: #333;
 }
 
 h3 {
     margin-top: 25px;
     margin-bottom: 5px;
     font-size: 1.3em;
+    font-weight: 300;
+    color: #333;
 }
 
 p {
     margin-top: 10px;
     margin-bottom: 20px;
-    font-size: 1.1em;
-    line-height: 140%;
+    line-height: 160%;
+    font-weight: 400;
 }
 
 p.smallMarginBottom {
     margin-bottom: 10px;
 }
 
+b {
+    font-weight: 500;
+}
+
 tt {
     background: #eee;
     padding: 2px 7px;
@@ -65,18 +80,39 @@ code {
     margin-top: 10px;
     margin-bottom: 20px;
     overflow-x: auto;
+    white-space: nowrap;
 }
 
-/* Lato font (OFL), https://fonts.google.com/specimen/Lato#about,
-   embedded with the help of https://google-webfonts-helper.herokuapp.com/fonts/lato?subsets=latin */
+/* Roboto font, embedded with the help of https://google-webfonts-helper.herokuapp.com/fonts/roboto?subsets=latin */
 
+/* roboto-300 - latin */
 @font-face {
-    font-family: 'Lato';
+    font-family: 'Roboto';
+    font-style: normal;
+    font-weight: 300;
+    src: local(''),
+    url('../font/roboto-v29-latin-300.woff2') format('woff2'), /* Chrome 26+, Opera 23+, Firefox 39+ */
+    url('../font/roboto-v29-latin-300.woff') format('woff'); /* Chrome 6+, Firefox 3.6+, IE 9+, Safari 5.1+ */
+}
+
+/* roboto-regular - latin */
+@font-face {
+    font-family: 'Roboto';
     font-style: normal;
     font-weight: 400;
     src: local(''),
-    url('../font/lato-v17-latin-ext_latin-regular.woff2') format('woff2'), /* Chrome 26+, Opera 23+, Firefox 39+ */
-    url('../font/lato-v17-latin-ext_latin-regular.woff') format('woff'); /* Chrome 6+, Firefox 3.6+, IE 9+, Safari 5.1+ */
+    url('../font/roboto-v29-latin-regular.woff2') format('woff2'), /* Chrome 26+, Opera 23+, Firefox 39+ */
+    url('../font/roboto-v29-latin-regular.woff') format('woff'); /* Chrome 6+, Firefox 3.6+, IE 9+, Safari 5.1+ */
+}
+
+/* roboto-500 - latin */
+@font-face {
+    font-family: 'Roboto';
+    font-style: normal;
+    font-weight: 500;
+    src: local(''),
+    url('../font/roboto-v29-latin-500.woff2') format('woff2'), /* Chrome 26+, Opera 23+, Firefox 39+ */
+    url('../font/roboto-v29-latin-500.woff') format('woff'); /* Chrome 6+, Firefox 3.6+, IE 9+, Safari 5.1+ */
 }
 
 /* Main page */
@@ -84,6 +120,7 @@ code {
 #main {
     max-width: 900px;
     margin: 0 auto 50px auto;
+    padding: 0 10px;
 }
 
 #error {
@@ -113,6 +150,29 @@ code {
     visibility: visible;
 }
 
+/* Figures */
+
+figure {
+    text-align: center;
+}
+
+figure img, figure video {
+    filter: drop-shadow(3px 3px 3px #ccc);
+    border-radius: 7px;
+    max-width: 100%;
+}
+
+figure video {
+    width: 100%;
+    max-height: 450px;
+}
+
+figcaption {
+    text-align: center;
+    font-style: italic;
+    padding-top: 10px;
+}
+
 /* Screenshots */
 
 #screenshots {
@@ -190,6 +250,53 @@ code {
     background-color: #fff;
 }
 
+/* Header */
+
+#header {
+    background: #3a9784;
+    height: 130px;
+}
+
+#header #headerBox {
+    max-width: 900px;
+    margin: 0 auto;
+    padding: 0 10px;
+}
+
+#header #logo {
+    margin-top: 23px;
+    float: left;
+}
+
+#header #name {
+    float: left;
+    color: white;
+    font-size: 2.6em;
+    font-weight: 300;
+    margin: 35px 0 0 20px;
+}
+
+#header ol {
+    list-style-type: none;
+    float: right;
+    margin-top: 80px;
+}
+
+#header ol li {
+    display: inline-block;
+    margin: 0 10px;
+    font-weight: 400;
+}
+
+#header ol li a, nav ol li a:visited {
+    color: white;
+    text-decoration: none;
+}
+
+#header ol li a:hover {
+    text-decoration: underline;
+}
+
 /* Subscribe box */
 
 button {
@@ -219,6 +326,14 @@ li {
     font-size: 0.9em;
 }
 
+
+/* Hide top menu SMALL SCREEN */
+@media only screen and (max-width: 780px) {
+    #header ol {
+        display: none;
+    }
+}
+
 /* Subscribe box SMALL SCREEN */
 @media only screen and (max-width: 1599px) {
     #subscribeBox #subscribeForm {
@@ -350,32 +465,39 @@ li {
 }
 
 /** Detail view */
-#detail {
-    display: none;
-    position: absolute;
-    z-index: 1;
-    left: 8px;
-    right: 8px;
-    top: 0;
-    bottom: 0;
-    background: white;
+
+#detail .detailEntry {
+    margin-bottom: 20px;
 }
 
 #detail .detailDate {
+    margin-bottom: 2px;
+}
+
+#detail .detailDate, #detail .detailTags {
     color: #888;
     font-size: 0.9em;
 }
 
-#detail .detailMessage {
-    margin-bottom: 20px;
-    font-size: 1.1em;
+#detail .detailTags {
+    margin-top: 2px;
+}
+
+#detail .detailDate img {
+    width: 20px;
+    height: 20px;
+    vertical-align: bottom;
+}
+
+#detail .detailTitle {
+    font-weight: bold;
 }
 
 #detail #detailMain {
     max-width: 900px;
     margin: 0 auto;
     position: relative; /* required for close button's "position: absolute" */
-    padding-bottom: 50px; /* Chrome and Firefox behave differently regarding bottom margin */
+    padding: 0 10px 50px 10px; /* Chrome and Firefox behave differently regarding bottom margin */
 }
 
 #detail #detailCloseButton {
@@ -384,7 +506,7 @@ li {
     border: none;
     padding: 5px;
     position: absolute;
-    right: 0;
+    right: 10px;
     top: 10px;
     display: block;
 }