fix(beacon): beskeden skubber i stedet for at dække

Den lå som en rude i hjørnet, oven på arbejdet, og dækkede knapperne i
notens fod og i delepanelet — seks e2e-prøver klikkede forgæves på noget,
der lå under den.

Det var ikke kun et prøveproblem. En besked, der er i vejen, bliver
klikket væk uden at blive læst, og så er den uopfordrede oplysning en
formalitet frem for noget, nogen har set. Nu står den øverst i indholdet
og skubber siden ned, indtil den bliver besvaret.

Og e2e beviser den nu frem for at klikke den væk: den første konto skal
møde beskeden, og der skal stå et instance_id og en version i den.

Co-Authored-By: Claude Opus 5 <[email protected]>

docs/openapi.yaml

@@ -1564,7 +1564,15 @@ paths:
               schema:
                 type: object
                 properties:
-                  installs: { type: integer }
+                  installs:
+                    type: [integer, "null"]
+                    description: |
+                      Null below the collector's floor (`publish_min`, 25 by
+                      default). A number that *falls* cannot be published as a
+                      fact — a bad release, a DNS change that quietly stops the
+                      pings, or lost rows all look like "fewer people use this
+                      now" — and a small number mostly says how little it takes
+                      to move it.
                   window_days: { type: integer }
         "404":
           description: Not a collector, or not published.
@@ -1590,7 +1598,19 @@ paths:
                   version: { type: string }
                   is_collector: { type: boolean }
                   publish_count: { type: boolean }
+                  publish_min:
+                    type: integer
+                    description: The floor under the published count.
                   last_ping_at: { type: string, format: date-time }
+                  last_error:
+                    type: string
+                    description: |
+                      Why the last attempt did not arrive; absent when the last
+                      one did. Shown rather than only logged: a beacon that
+                      cannot reach its collector otherwise fails in complete
+                      silence, and the only trace is a "last sent" date that
+                      quietly gets older.
+                  last_error_at: { type: string, format: date-time }
     put:
       tags: [auth]
       summary: Turn the beacon off, or point it somewhere else. Administrators only.
@@ -1610,12 +1630,74 @@ paths:
                     make the server reach inside its own network.
                 is_collector: { type: boolean }
                 publish_count: { type: boolean }
+                publish_min: { type: integer, minimum: 0 }
       responses:
         "200":
           description: The configuration as it now stands.
         "422":
           description: The collector address is not an http or https URL.
 
+  /api/v1/beacon/notice:
+    get:
+      tags: [auth]
+      summary: Whether the disclosure is still owed, and what it says. Administrators only.
+      description: |
+        The beacon is on by default, and that is only defensible if it is said
+        unprompted. A settings page where it is stated fully is not the same as
+        saying it: that page is opened by people who already suspect there is
+        something to read.
+
+        The three values are in the response — the real id, the real version, the
+        real collector address — so the notice can show what is sent rather than
+        say "anonymous data" and ask to be believed.
+      responses:
+        "200":
+          description: OK
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  pending:
+                    type: boolean
+                    description: False once anybody has answered, panel-wide.
+                  enabled: { type: boolean }
+                  instance_id: { type: string }
+                  version: { type: string }
+                  collector_url: { type: string }
+    post:
+      tags: [auth]
+      summary: Answer the notice. Administrators only.
+      description: |
+        One call for both answers — "keep it on" and "turn it off" are the same
+        act, somebody deciding, and two endpoints would mean one of them could
+        forget to record that a decision was made.
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              required: [keep]
+              properties:
+                keep:
+                  type: boolean
+                  description: |
+                    Required, and rejected when absent. An empty body must not be
+                    able to mean "turn it off": an opt-out nobody chose is as much
+                    a broken promise as an opt-in nobody chose.
+      responses:
+        "200":
+          description: Recorded.
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  enabled: { type: boolean }
+        "422":
+          description: No answer was given.
+
   /api/v1/panel/restart:
     post:
       tags: [auth]
@@ -2718,6 +2800,25 @@ paths:
       responses:
         "200": { $ref: "#/components/responses/MailAddress" }
 
+  /api/v1/hook-url:
+    get:
+      tags: [integrations]
+      summary: Your personal address for pushing a task in from somewhere else.
+      description: >
+        Minted on first ask. Its own token rather than the mail one: the two are
+        the same kind of secret, but they leak separately — a URL that has been
+        sitting in a shortcut on a lost phone has to be replaceable without
+        changing the address other people have in their address books.
+      responses:
+        "200": { $ref: "#/components/responses/HookURL" }
+
+  /api/v1/hook-url/rotate:
+    post:
+      tags: [integrations]
+      summary: Issue a new push address, retiring the old one at once.
+      responses:
+        "200": { $ref: "#/components/responses/HookURL" }
+
   /api/v1/notifications:
     get:
       tags: [integrations]
@@ -3752,6 +3853,69 @@ paths:
                   task_id: { type: string }
         "404": { description: "No such address. Identical to a malformed one, deliberately." }
 
+  /inbound/hook/{token}:
+    post:
+      tags: [integrations]
+      summary: Push a task into somebody's inbox from another program.
+      description: |
+        The token in the path is the whole credential — the caller is a shortcut on
+        a phone or a script, and neither can sign in. A token here can do one
+        thing: create a task in that person's inbox. An API token can do everything,
+        which is why this is not one.
+
+        The body is read three ways, because those are the three you meet: JSON from
+        a service, a form field from a webhook form, and plain text from a shortcut
+        that just sends what was selected. The first line becomes the task and the
+        rest sits underneath it, and the line goes through the quick-add parser — so
+        "Ring til Anders i morgen p1 #Firma" means here what it means in the box at
+        the top of the app.
+
+        POST only. A GET would be easier to call, and that is exactly the problem:
+        a browser prefetch, a link check in a chat, and a revisited history entry
+        would all create tasks nobody asked for.
+      security: []
+      parameters:
+        - name: token
+          in: path
+          required: true
+          schema: { type: string }
+      requestBody:
+        required: true
+        content:
+          text/plain:
+            schema:
+              type: string
+              description: First line the task, the rest its description.
+          application/json:
+            schema:
+              type: object
+              properties:
+                text: { type: string }
+                title: { description: Same as text. }
+                content: { description: Same as text. }
+                note: { type: string }
+                body: { description: Same as note. }
+                description: { description: Same as note. }
+          application/x-www-form-urlencoded:
+            schema:
+              type: object
+              properties:
+                text: { type: string }
+                note: { type: string }
+      responses:
+        "201":
+          description: Created
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  task_id: { type: string }
+                  content: { type: string }
+        "404": { description: "No such address. Identical to a malformed one, deliberately." }
+        "422": { $ref: "#/components/responses/Validation" }
+        "429": { description: Too many pushes; the address is rate limited. }
+
   /oauth/gmail/callback:
     get:
       tags: [integrations]
@@ -4018,6 +4182,15 @@ components:
                 type: array
                 items: { type: string }
 
+    HookURL:
+      description: The address another program pushes to.
+      content:
+        application/json:
+          schema:
+            type: object
+            properties:
+              url: { type: string }
+
   schemas:
     Calendar:
       type: object

internal/httpapi/beacon_handlers.go

@@ -20,6 +20,11 @@ import (
 
 const beaconScope = "beacon"
 
+// defaultPublishMin er, hvor mange installationer der skal være, før tallet
+// offentliggøres. Selve tallet er et skøn; det, gulvet køber, er det ikke: under
+// det fortæller et offentligt tal mest om, hvor lidt der skal til at flytte det.
+const defaultPublishMin = 25
+
 // beaconConfig is what this instance has been told to do. The zero value is what
 // a fresh installation gets, which is why Enabled defaults to true elsewhere and
 // not here — a zero struct must never mean "silently on".
@@ -30,6 +35,33 @@ type beaconConfig struct {
 	IsCollector  bool   `json:"is_collector"`
 	PublishCount bool   `json:"publish_count"`
 	LastPingAt   int64  `json:"last_ping_at,omitempty"`
+	// LastVersion er den version, der sidst nåede frem. Gemt, fordi en
+	// installation, der opdaterer sig selv om natten, ellers står som gårsdagens
+	// version i op til et døgn — og en tælling efter version, der er en dag bagud,
+	// kan man ikke se en udrulning i.
+	LastVersion string `json:"last_version,omitempty"`
+	// LastError er grunden til, at det sidste forsøg ikke nåede frem.
+	//
+	// Skrevet ned, fordi alternativet er tavshed: et beacon, der ikke kan nå sin
+	// collector, prøver igen i morgen og siger ingenting, og det opdages først ved
+	// at tælle installationer i den anden ende og savne en. Det er ikke en fejl,
+	// der skal afbryde nogen — det er en linje på en side, der ellers påstår, at
+	// alt er sendt.
+	LastError   string `json:"last_error,omitempty"`
+	LastErrorAt int64  `json:"last_error_at,omitempty"`
+	// NoticeAck er sat, når nogen har set beskeden om, hvad der bliver sendt.
+	//
+	// Slået til som udgangspunkt kan kun forsvares, hvis det bliver sagt
+	// uopfordret — ikke på en indstillingsside, ingen åbner af sig selv. Feltet er
+	// det, der husker, at det er blevet sagt.
+	NoticeAck bool `json:"notice_ack"`
+	// PublishMin er gulvet under det offentliggjorte tal.
+	//
+	// Et tal, der *falder*, kan ikke offentliggøres som en kendsgerning: en dårlig
+	// udrulning, en DNS-ændring, der stille stopper meldingerne, eller rækker, der
+	// er væk, ser alle sammen ud som "færre bruger det nu". Under gulvet svares
+	// der ingenting frem for et lille tal, ingen kan tolke.
+	PublishMin int `json:"publish_min"`
 }
 
 // beaconSettings reads the configuration, filling in the defaults and minting the
@@ -40,7 +72,9 @@ type beaconConfig struct {
 // also be a value the collector could compare against a guess — which is the
 // difference between anonymous and pseudonymous, and it is the whole point.
 func (s *Server) beaconSettings(ctx context.Context) (beaconConfig, error) {
-	cfg := beaconConfig{Enabled: true, Collector: beacon.DefaultCollector}
+	cfg := beaconConfig{
+		Enabled: true, Collector: beacon.DefaultCollector, PublishMin: defaultPublishMin,
+	}
 
 	stored, err := s.db.InstanceSettings(ctx, beaconScope)
 	if err != nil {
@@ -65,6 +99,21 @@ func (s *Server) beaconSettings(ctx context.Context) (beaconConfig, error) {
 	if v, ok := stored["last_ping_at"].(float64); ok {
 		cfg.LastPingAt = int64(v)
 	}
+	if v, ok := stored["last_version"].(string); ok {
+		cfg.LastVersion = v
+	}
+	if v, ok := stored["last_error"].(string); ok {
+		cfg.LastError = v
+	}
+	if v, ok := stored["last_error_at"].(float64); ok {
+		cfg.LastErrorAt = int64(v)
+	}
+	if v, ok := stored["notice_ack"].(bool); ok {
+		cfg.NoticeAck = v
+	}
+	if v, ok := stored["publish_min"].(float64); ok && v >= 0 {
+		cfg.PublishMin = int(v)
+	}
 
 	if cfg.InstanceID == "" {
 		cfg.InstanceID = store.NewID()
@@ -83,20 +132,31 @@ func (s *Server) saveBeaconSettings(ctx context.Context, cfg beaconConfig) error
 		"is_collector":  cfg.IsCollector,
 		"publish_count": cfg.PublishCount,
 		"last_ping_at":  cfg.LastPingAt,
+		"last_version":  cfg.LastVersion,
+		"last_error":    cfg.LastError,
+		"last_error_at": cfg.LastErrorAt,
+		"notice_ack":    cfg.NoticeAck,
+		"publish_min":   cfg.PublishMin,
 	})
 }
 
 // --- what the settings page shows ------------------------------------------------
 
 type beaconStatusJSON struct {
-	Enabled      bool               `json:"enabled"`
-	Collector    string             `json:"collector_url"`
-	InstanceID   string             `json:"instance_id"`
-	Version      string             `json:"version"`
-	IsCollector  bool               `json:"is_collector"`
-	PublishCount bool               `json:"publish_count"`
-	LastPingAt   string             `json:"last_ping_at,omitempty"`
-	Stats        *store.BeaconStats `json:"stats,omitempty"`
+	Enabled      bool   `json:"enabled"`
+	Collector    string `json:"collector_url"`
+	InstanceID   string `json:"instance_id"`
+	Version      string `json:"version"`
+	IsCollector  bool   `json:"is_collector"`
+	PublishCount bool   `json:"publish_count"`
+	PublishMin   int    `json:"publish_min"`
+	LastPingAt   string `json:"last_ping_at,omitempty"`
+	// Sidste forsøg, der ikke nåede frem — tomt, når det sidste gik godt. Vist
+	// frem for talt: en dato under "sidst sendt", der bliver ældre og ældre, er
+	// det eneste spor, et tavst beacon ellers efterlader.
+	LastError   string             `json:"last_error,omitempty"`
+	LastErrorAt string             `json:"last_error_at,omitempty"`
+	Stats       *store.BeaconStats `json:"stats,omitempty"`
 }
 
 func (s *Server) handleBeaconStatus(w http.ResponseWriter, r *http.Request) {
@@ -109,10 +169,15 @@ func (s *Server) handleBeaconStatus(w http.ResponseWriter, r *http.Request) {
 	out := beaconStatusJSON{
 		Enabled: cfg.Enabled, Collector: cfg.Collector, InstanceID: cfg.InstanceID,
 		Version: Version, IsCollector: cfg.IsCollector, PublishCount: cfg.PublishCount,
+		PublishMin: cfg.PublishMin,
 	}
 	if cfg.LastPingAt > 0 {
 		out.LastPingAt = time.Unix(cfg.LastPingAt, 0).Format(time.RFC3339)
 	}
+	if cfg.LastError != "" {
+		out.LastError = cfg.LastError
+		out.LastErrorAt = time.Unix(cfg.LastErrorAt, 0).Format(time.RFC3339)
+	}
 	if cfg.IsCollector {
 		stats, err := s.db.BeaconSummary(r.Context())
 		if err != nil {
@@ -129,6 +194,7 @@ type beaconRequest struct {
 	Collector    *string `json:"collector_url"`
 	IsCollector  *bool   `json:"is_collector"`
 	PublishCount *bool   `json:"publish_count"`
+	PublishMin   *int    `json:"publish_min"`
 }
 
 func (s *Server) handleSetBeacon(w http.ResponseWriter, r *http.Request) {
@@ -151,6 +217,13 @@ func (s *Server) handleSetBeacon(w http.ResponseWriter, r *http.Request) {
 	if req.PublishCount != nil {
 		cfg.PublishCount = *req.PublishCount
 	}
+	if req.PublishMin != nil {
+		if *req.PublishMin < 0 {
+			writeFieldErrors(w, map[string]string{"publish_min": "must not be negative"})
+			return
+		}
+		cfg.PublishMin = *req.PublishMin
+	}
 	if req.Collector != nil {
 		url := strings.TrimSpace(*req.Collector)
 		if url == "" {
@@ -237,6 +310,16 @@ func (s *Server) handleBeaconCount(w http.ResponseWriter, r *http.Request) {
 	}
 
 	n, err := s.db.BeaconCount(r.Context(), 30*24*time.Hour)
+	if err == nil && n < cfg.PublishMin {
+		// Ingenting frem for et lille tal. Et tal under gulvet fortæller mest om,
+		// hvor lidt der skal til at flytte det — og et, der falder, ville blive
+		// læst som "færre bruger det nu", også når det i virkeligheden var en
+		// udrulning, der gik galt, eller en adresse, der stille holdt op med at
+		// blive ramt.
+		w.Header().Set("Cache-Control", "public, max-age=60")
+		writeJSON(w, http.StatusOK, map[string]any{"installs": nil, "window_days": 30})
+		return
+	}
 	if err != nil {
 		s.internal(w, r, "beacon count", err)
 		return
@@ -269,11 +352,15 @@ func (s *Server) SendBeacon(ctx context.Context) error {
 		if err := s.db.RecordBeacon(ctx, cfg.InstanceID, Version); err != nil {
 			return err
 		}
-		cfg.LastPingAt = time.Now().Unix()
-		return s.saveBeaconSettings(ctx, cfg)
+		return s.beaconSent(ctx, cfg)
 	}
 
-	if time.Since(time.Unix(cfg.LastPingAt, 0)) < 24*time.Hour {
+	// Undtagelsen fra døgnet er en version, der er skiftet. En installation, der
+	// opdaterer sig selv om natten og først melder ind igen et døgn senere, står
+	// som gårsdagens version hele dagen — og så kan man ikke se en udrulning i
+	// tallene. Målt hos Yggdrasil: to paneler rapporterede den forrige version i
+	// et døgn efter at være opdateret.
+	if time.Since(time.Unix(cfg.LastPingAt, 0)) < 24*time.Hour && cfg.LastVersion == Version {
 		return nil
 	}
 
@@ -289,9 +376,100 @@ func (s *Server) SendBeacon(ctx context.Context) error {
 		// installation's problem and must never look like one — it is somebody
 		// else's server, and the only consequence is a number being one lower.
 		s.log.Info("beacon not delivered", "err", err)
-		return nil
+		// Men skrevet ned. Uden det her fejler et beacon, der ikke kan nå sin
+		// collector, i fuldstændig tavshed: det prøver igen i morgen, siden siger
+		// "sidst sendt" med en dato, der bare bliver ældre, og ingen opdager det.
+		// Fundet hos Yggdrasil ved at tælle installationer i den anden ende og
+		// savne en.
+		cfg.LastError, cfg.LastErrorAt = err.Error(), time.Now().Unix()
+		return s.saveBeaconSettings(ctx, cfg)
 	}
 
+	return s.beaconSent(ctx, cfg)
+}
+
+// beaconSent skriver, at det lykkedes: tidspunktet, versionen der nåede frem, og
+// en fejl, der ikke længere gælder. Ét sted, fordi de fire felter skal skrives
+// sammen — en gemning, der glemte at rydde fejlen, ville lade en linje stå på
+// siden om noget, der virker.
+func (s *Server) beaconSent(ctx context.Context, cfg beaconConfig) error {
 	cfg.LastPingAt = time.Now().Unix()
+	cfg.LastVersion = Version
+	cfg.LastError, cfg.LastErrorAt = "", 0
 	return s.saveBeaconSettings(ctx, cfg)
 }
+
+// --- beskeden, der bliver sagt uopfordret ------------------------------------------
+
+// handleBeaconNotice says whether the disclosure is still owed, and what it would
+// say.
+//
+// Slået til som udgangspunkt kan kun forsvares, hvis det bliver sagt uopfordret.
+// En indstillingsside, hvor det står rigtigt og fyldestgørende, er ikke det samme
+// som at sige det: den bliver åbnet af dem, der i forvejen har en mistanke om, at
+// der er noget at læse. Uden beskeden her er "du kan slå den fra" et tilbud til
+// dem, der ved, at der er noget at slå fra.
+//
+// De tre værdier står i svaret — det rigtige id, den rigtige version, den rigtige
+// adresse — så beskeden kan vise, hvad der bliver sendt, frem for at sige
+// "anonyme data" og bede om at blive troet på. Det er den eneste version af det
+// løfte, der er noget værd: en, læseren selv kan kontrollere.
+//
+// Panelbredt frem for pr. bruger: det er installationen, der melder ind, ikke
+// personen, og en besked pr. konto ville stille det samme spørgsmål til folk, der
+// ikke kan svare på det.
+func (s *Server) handleBeaconNotice(w http.ResponseWriter, r *http.Request) {
+	cfg, err := s.beaconSettings(r.Context())
+	if err != nil {
+		s.internal(w, r, "beacon settings", err)
+		return
+	}
+	writeJSON(w, http.StatusOK, map[string]any{
+		"pending":       !cfg.NoticeAck,
+		"enabled":       cfg.Enabled,
+		"instance_id":   cfg.InstanceID,
+		"version":       Version,
+		"collector_url": cfg.Collector,
+	})
+}
+
+type beaconNoticeRequest struct {
+	// Keep er en peger og ikke en bool, og det er hele pointen.
+	//
+	// En tom krop ville ellers betyde "slå det fra", og det er den vej, en fejl
+	// aldrig må falde: et fravalg, ingen har truffet, er lige så meget et brudt
+	// løfte som et tilvalg, ingen har truffet. Yggdrasil har den fejl i sin
+	// tilsvarende ende og er blevet bidt af den.
+	Keep *bool `json:"keep"`
+}
+
+// handleAckBeaconNotice records that the notice has been seen, and turns the
+// beacon off if that was the answer.
+//
+// Ét kald til begge svar. "Behold den" og "slå den fra" er den samme handling —
+// nogen har taget stilling — og to endpoints ville betyde, at det ene kunne
+// glemme at skrive, at der var taget stilling, og beskeden dermed komme igen.
+func (s *Server) handleAckBeaconNotice(w http.ResponseWriter, r *http.Request) {
+	var req beaconNoticeRequest
+	if err := decodeJSON(w, r, &req); err != nil {
+		return
+	}
+	if req.Keep == nil {
+		writeFieldErrors(w, map[string]string{"keep": "required"})
+		return
+	}
+
+	cfg, err := s.beaconSettings(r.Context())
+	if err != nil {
+		s.internal(w, r, "beacon settings", err)
+		return
+	}
+	cfg.NoticeAck = true
+	cfg.Enabled = *req.Keep
+	if err := s.saveBeaconSettings(r.Context(), cfg); err != nil {
+		s.internal(w, r, "save beacon settings", err)
+		return
+	}
+	s.log.Info("beacon notice answered", "keep", *req.Keep, "user", userFrom(r.Context()).ID)
+	writeJSON(w, http.StatusOK, map[string]any{"enabled": cfg.Enabled})
+}

internal/httpapi/beacon_notice_test.go

@@ -0,0 +1,132 @@
+package httpapi
+
+import (
+	"net/http"
+	"testing"
+)
+
+// Beaconet er slået til som udgangspunkt, og det kan kun forsvares, hvis det
+// bliver sagt uopfordret. Beskeden venter, indtil nogen har taget stilling — og
+// den viser de rigtige værdier, så løftet kan efterprøves frem for tros på.
+func TestTheBeaconSaysWhatItSendsBeforeAnybodyAsks(t *testing.T) {
+	ts := newTestServer(t)
+	ts.bootstrap(t)
+
+	resp, notice := ts.do(t, "GET", "/api/v1/beacon/notice", nil)
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("hent besked: %d", resp.StatusCode)
+	}
+	if notice["pending"] != true {
+		t.Fatalf("beskeden er ikke i vente på en frisk installation: %v", notice)
+	}
+	if notice["enabled"] != true {
+		t.Errorf("beaconet er ikke slået til som udgangspunkt: %v", notice)
+	}
+	// De tre værdier, beskeden viser frem, er de rigtige — ikke et eksempel.
+	settings := beaconSettingsOf(t, ts)
+	if notice["instance_id"] != settings["instance_id"] {
+		t.Errorf("id i beskeden = %v, i indstillingerne = %v",
+			notice["instance_id"], settings["instance_id"])
+	}
+	if notice["collector_url"] != settings["collector_url"] {
+		t.Errorf("adressen i beskeden = %v, i indstillingerne = %v",
+			notice["collector_url"], settings["collector_url"])
+	}
+	if notice["version"] == "" || notice["version"] == nil {
+		t.Error("beskeden siger ikke, hvilken version der bliver sendt")
+	}
+}
+
+// "Behold den" er et svar, og det svar skal huskes: beskeden må ikke komme igen
+// ved næste login.
+func TestKeepingTheBeaconAnswersTheNoticeForGood(t *testing.T) {
+	ts := newTestServer(t)
+	ts.bootstrap(t)
+
+	resp, out := ts.do(t, "POST", "/api/v1/beacon/notice", map[string]any{"keep": true})
+	if resp.StatusCode != http.StatusOK || out["enabled"] != true {
+		t.Fatalf("behold: %d %v", resp.StatusCode, out)
+	}
+	if _, notice := ts.do(t, "GET", "/api/v1/beacon/notice", nil); notice["pending"] != false {
+		t.Errorf("beskeden kommer igen efter et svar: %v", notice)
+	}
+	if s := beaconSettingsOf(t, ts); s["enabled"] != true {
+		t.Errorf("beaconet blev slået fra af et ja: %v", s["enabled"])
+	}
+}
+
+// Og "slå den fra" slår den fra — ét kald, både svaret og virkningen.
+func TestTurningTheBeaconOffFromTheNoticeStopsIt(t *testing.T) {
+	ts := newTestServer(t)
+	ts.bootstrap(t)
+
+	resp, out := ts.do(t, "POST", "/api/v1/beacon/notice", map[string]any{"keep": false})
+	if resp.StatusCode != http.StatusOK || out["enabled"] != false {
+		t.Fatalf("slå fra: %d %v", resp.StatusCode, out)
+	}
+	s := beaconSettingsOf(t, ts)
+	if s["enabled"] != false {
+		t.Errorf("beaconet kører stadig efter et nej: %v", s["enabled"])
+	}
+	if _, notice := ts.do(t, "GET", "/api/v1/beacon/notice", nil); notice["pending"] != false {
+		t.Errorf("beskeden kommer igen efter et nej: %v", notice)
+	}
+}
+
+// En tom krop må ikke kunne betyde "slå det fra". Et fravalg, ingen har truffet,
+// er lige så meget et brudt løfte som et tilvalg, ingen har truffet.
+func TestAnEmptyAnswerToTheNoticeIsRefused(t *testing.T) {
+	ts := newTestServer(t)
+	ts.bootstrap(t)
+
+	resp, _ := ts.do(t, "POST", "/api/v1/beacon/notice", map[string]any{})
+	if resp.StatusCode != http.StatusUnprocessableEntity {
+		t.Fatalf("tom krop gav %d, want 422", resp.StatusCode)
+	}
+	if s := beaconSettingsOf(t, ts); s["enabled"] != true {
+		t.Errorf("en tom krop slog beaconet fra: %v", s["enabled"])
+	}
+	if _, notice := ts.do(t, "GET", "/api/v1/beacon/notice", nil); notice["pending"] != true {
+		t.Errorf("en tom krop talte som et svar: %v", notice)
+	}
+}
+
+// Et tal, der falder, kan ikke offentliggøres som en kendsgerning. Under gulvet
+// svares der ingenting frem for et lille tal, ingen kan tolke.
+func TestThePublishedCountHasAFloorUnderIt(t *testing.T) {
+	ts := newTestServer(t)
+	ts.bootstrap(t)
+
+	if resp, _ := ts.do(t, "PUT", "/api/v1/beacon/settings", map[string]any{
+		"is_collector": true, "publish_count": true,
+	}); resp.StatusCode != http.StatusOK {
+		t.Fatal("bliv collector")
+	}
+
+	// Instansen tæller sig selv, så der er én. Gulvet er højere.
+	resp, out := ts.do(t, "GET", "/api/v1/beacon/count", nil)
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("tælling: %d", resp.StatusCode)
+	}
+	if out["installs"] != nil {
+		t.Errorf("et tal under gulvet blev offentliggjort: %v", out["installs"])
+	}
+
+	// Sættes gulvet ned, står tallet der.
+	if resp, _ := ts.do(t, "PUT", "/api/v1/beacon/settings",
+		map[string]any{"publish_min": 0}); resp.StatusCode != http.StatusOK {
+		t.Fatal("sænk gulvet")
+	}
+	if _, out := ts.do(t, "GET", "/api/v1/beacon/count", nil); out["installs"] == nil {
+		t.Errorf("tallet blev holdt tilbage uden et gulv: %v", out)
+	}
+}
+
+func beaconSettingsOf(t *testing.T, ts *testServer) map[string]any {
+	t.Helper()
+	resp, out := ts.do(t, "GET", "/api/v1/beacon/settings", nil)
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("hent beacon-indstillinger: %d", resp.StatusCode)
+	}
+	return out
+}

internal/httpapi/inbound_hook_test.go

@@ -0,0 +1,194 @@
+package httpapi
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"strings"
+	"testing"
+)
+
+// doRaw sender en krop, der ikke er JSON — en genvej på en telefon sender ren
+// tekst, og en webhook-formular sender felter. Det er halvdelen af det, der
+// prøves her.
+func (ts *testServer) doRaw(t *testing.T, method, path, contentType, body string) (*http.Response, map[string]any) {
+	t.Helper()
+	req, err := http.NewRequest(method, ts.URL+path, strings.NewReader(body))
+	if err != nil {
+		t.Fatalf("build request: %v", err)
+	}
+	req.Header.Set("Content-Type", contentType)
+	resp, err := ts.client.Do(req)
+	if err != nil {
+		t.Fatalf("%s %s: %v", method, path, err)
+	}
+	t.Cleanup(func() { resp.Body.Close() })
+
+	var decoded map[string]any
+	raw, _ := io.ReadAll(resp.Body)
+	if len(raw) > 0 {
+		_ = json.Unmarshal(raw, &decoded)
+	}
+	return resp, decoded
+}
+
+// hookURL henter personens egen krog-adresse, som fladen viser den.
+func (ts *testServer) hookURL(t *testing.T) string {
+	t.Helper()
+	resp, out := ts.do(t, "GET", "/api/v1/hook-url", nil)
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("hent krog-URL: %d", resp.StatusCode)
+	}
+	url, _ := out["url"].(string)
+	if !strings.Contains(url, "/inbound/hook/") {
+		t.Fatalf("url = %q", url)
+	}
+	return url
+}
+
+// hookPath er stien, testserveren kan kaldes på — URL'en er absolut, fordi den
+// skal kunne kopieres ind i en genvej på en telefon.
+func hookPath(url string) string {
+	return url[strings.Index(url, "/inbound/hook/"):]
+}
+
+// En linje ren tekst, skubbet ind udefra, bliver til en opgave i indbakken — og
+// betyder det samme, som den ville betyde i feltet øverst i fladen.
+func TestAPushFromAnotherAppLandsInTheInbox(t *testing.T) {
+	ts := newTestServer(t)
+	ts.bootstrap(t)
+	path := hookPath(ts.hookURL(t))
+
+	anon := newSignedOut(t, ts)
+	resp, out := anon.doRaw(t, "POST", path, "text/plain",
+		"Ring til Anders p1\nhan ringede i går")
+	if resp.StatusCode != http.StatusCreated {
+		t.Fatalf("skub: %d, %v", resp.StatusCode, out)
+	}
+
+	_, list := ts.do(t, "GET", "/api/v1/tasks", nil)
+	tasks, _ := list["tasks"].([]any)
+	var found map[string]any
+	for _, raw := range tasks {
+		task := raw.(map[string]any)
+		if task["content"] == "Ring til Anders" {
+			found = task
+		}
+	}
+	if found == nil {
+		t.Fatalf("opgaven kom ikke i indbakken: %v", tasks)
+	}
+	// Parseren er den samme som fladens: p1 er en prioritet og ikke en del af
+	// teksten, og resten af kroppen står under opgaven.
+	if found["priority"] != float64(1) {
+		t.Errorf("prioritet = %v, want 1", found["priority"])
+	}
+	if found["description"] != "han ringede i går" {
+		t.Errorf("beskrivelse = %v", found["description"])
+	}
+}
+
+// JSON fra en tjeneste, med de feltnavne folk faktisk sender.
+func TestTheHookReadsJSON(t *testing.T) {
+	ts := newTestServer(t)
+	ts.bootstrap(t)
+	path := hookPath(ts.hookURL(t))
+	anon := newSignedOut(t, ts)
+
+	for _, body := range []string{
+		`{"text": "Køb mælk"}`,
+		`{"title": "Køb mælk"}`,
+		`{"content": "Køb mælk"}`,
+	} {
+		resp, out := anon.doRaw(t, "POST", path, "application/json", body)
+		if resp.StatusCode != http.StatusCreated {
+			t.Fatalf("%s: %d, %v", body, resp.StatusCode, out)
+		}
+		if out["content"] != "Køb mælk" {
+			t.Errorf("%s gav %v", body, out["content"])
+		}
+	}
+
+	// En krop, der siger JSON og ikke er det, læses ikke som tekst bagefter: en
+	// opgave, der hedder `{"txt": …}`, er en dårligere fejlmeddelelse end et 422.
+	resp, _ := anon.doRaw(t, "POST", path, "application/json", `{"txt": "skrevet forkert"}`)
+	if resp.StatusCode != http.StatusUnprocessableEntity {
+		t.Errorf("forkert JSON gav %d, want 422", resp.StatusCode)
+	}
+}
+
+// Et token, der ikke findes, er det samme svar som et, der aldrig har eksisteret.
+// Alt andet er en maskine til at gætte tokens med.
+func TestAnUnknownHookTokenIsNotFound(t *testing.T) {
+	ts := newTestServer(t)
+	ts.bootstrap(t)
+	anon := newSignedOut(t, ts)
+
+	resp, _ := anon.doRaw(t, "POST", "/inbound/hook/deteringentingogsaaslet", "text/plain", "hej")
+	if resp.StatusCode != http.StatusNotFound {
+		t.Fatalf("ukendt token gav %d, want 404", resp.StatusCode)
+	}
+}
+
+// Den gamle URL holder op med at virke, når man skifter den. Det er den eneste vej
+// tilbage: adressen står i en genvej på en telefon eller i et script.
+func TestRotatingTheHookRetiresTheOldURL(t *testing.T) {
+	ts := newTestServer(t)
+	ts.bootstrap(t)
+	old := hookPath(ts.hookURL(t))
+
+	resp, out := ts.do(t, "POST", "/api/v1/hook-url/rotate", nil)
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("skift: %d", resp.StatusCode)
+	}
+	fresh := hookPath(out["url"].(string))
+	if fresh == old {
+		t.Fatal("den nye URL er den gamle")
+	}
+
+	anon := newSignedOut(t, ts)
+	if resp, _ := anon.doRaw(t, "POST", old, "text/plain", "gammel"); resp.StatusCode != http.StatusNotFound {
+		t.Errorf("den gamle URL virker stadig: %d", resp.StatusCode)
+	}
+	if resp, _ := anon.doRaw(t, "POST", fresh, "text/plain", "ny"); resp.StatusCode != http.StatusCreated {
+		t.Errorf("den nye URL virker ikke: %d", resp.StatusCode)
+	}
+}
+
+// Ingen tekst er ikke en opgave. En tom opgave i indbakken er værre end en fejl,
+// fordi den ser ud som om integrationen virker.
+func TestAnEmptyPushIsRefused(t *testing.T) {
+	ts := newTestServer(t)
+	ts.bootstrap(t)
+	path := hookPath(ts.hookURL(t))
+	anon := newSignedOut(t, ts)
+
+	resp, _ := anon.doRaw(t, "POST", path, "text/plain", "   \n  ")
+	if resp.StatusCode != http.StatusUnprocessableEntity {
+		t.Fatalf("tom tekst gav %d, want 422", resp.StatusCode)
+	}
+}
+
+// Et token kan én ting. Det ligger i et script på en anden maskine, og hvad der
+// ellers kan nås med det, er hvad der er sluppet ud sammen med det.
+func TestTheHookTokenIsNotAnAPIToken(t *testing.T) {
+	ts := newTestServer(t)
+	ts.bootstrap(t)
+	url := ts.hookURL(t)
+	token := url[strings.LastIndex(url, "/")+1:]
+
+	anon := newSignedOut(t, ts)
+	req, err := http.NewRequest("GET", anon.URL+"/api/v1/tasks", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	req.Header.Set("Authorization", "Bearer "+token)
+	resp, err := anon.client.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode == http.StatusOK {
+		t.Fatal("krog-tokenet gav adgang til API'et")
+	}
+}

internal/httpapi/integrations_handlers.go

@@ -2,7 +2,9 @@ package httpapi
 
 import (
 	"encoding/json"
+	"io"
 	"net/http"
+	"net/url"
 	"strings"
 	"time"
 
@@ -155,6 +157,191 @@ func (s *Server) handleInboundMail(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, http.StatusCreated, map[string]string{"task_id": task.ID})
 }
 
+// --- en krog ind i indbakken --------------------------------------------------------
+
+type hookURLResponse struct {
+	URL string `json:"url"`
+}
+
+// handleGetHookURL returns the personal address another program can push a task
+// to, minting the token on first ask.
+//
+// Der var to veje ind i forvejen, og ingen af dem passer til "gem den her, mens
+// jeg står med telefonen i hånden". API-tokenet giver adgang til alt og skal have
+// en JSON-krop skrevet rigtigt; mailadressen virker først, når nogen har sat en
+// mailserver op. Det, der manglede, var en URL, man kan smide en linje tekst efter
+// — fra en genvej på telefonen, et script, en anden tjeneste.
+func (s *Server) handleGetHookURL(w http.ResponseWriter, r *http.Request) {
+	token, err := s.db.EnsureHookToken(r.Context(), userFrom(r.Context()).ID)
+	if err != nil {
+		s.internal(w, r, "hook token", err)
+		return
+	}
+	writeJSON(w, http.StatusOK, hookURLResponse{URL: s.hookURL(token)})
+}
+
+// handleRotateHookURL mints a new one and retires the old.
+//
+// Den eneste vej tilbage, når en URL er sluppet ud: den står i en genvej på en
+// telefon eller i et script på en anden maskine, og der er ikke andet at trække
+// tilbage end tokenet selv.
+func (s *Server) handleRotateHookURL(w http.ResponseWriter, r *http.Request) {
+	token, err := auth.NewToken()
+	if err != nil {
+		s.internal(w, r, "generate hook token", err)
+		return
+	}
+	if err := s.db.SetHookToken(r.Context(), userFrom(r.Context()).ID, token); err != nil {
+		s.internal(w, r, "set hook token", err)
+		return
+	}
+	writeJSON(w, http.StatusOK, hookURLResponse{URL: s.hookURL(token)})
+}
+
+func (s *Server) hookURL(token string) string {
+	return strings.TrimSuffix(s.cfg.BaseURL, "/") + "/inbound/hook/" + token
+}
+
+type hookRequest struct {
+	// Text er linjen, der bliver til opgaven. `title` og `content` tages med som
+	// de samme, fordi det er dem, andre tjenester i forvejen kalder feltet — og en
+	// integration, der fejler på et feltnavn, fejler tavst hos den, der satte den
+	// op.
+	Text    string `json:"text"`
+	Title   string `json:"title"`
+	Content string `json:"content"`
+	// Note er det, der står under opgaven. `body` og `description` ligeså.
+	Note        string `json:"note"`
+	Body        string `json:"body"`
+	Description string `json:"description"`
+}
+
+func (h hookRequest) line() string {
+	for _, v := range []string{h.Text, h.Title, h.Content} {
+		if strings.TrimSpace(v) != "" {
+			return v
+		}
+	}
+	return ""
+}
+
+func (h hookRequest) note() string {
+	for _, v := range []string{h.Note, h.Body, h.Description} {
+		if strings.TrimSpace(v) != "" {
+			return v
+		}
+	}
+	return ""
+}
+
+// handleInboundHook turns a POST from somewhere else into a task in the inbox.
+//
+// Tokenet i stien er hele legitimationen, som i kalenderfeedet og den indgående
+// post: den, der kalder, er et script eller en genvej på en telefon, og hverken
+// kan logge ind. Derfor kan et token herfra også kun én ting — lave en opgave i
+// den ene persons indbakke — hvor et API-token kan alt.
+//
+// Kroppen læses på tre måder, fordi de tre er dem, man møder: JSON fra en
+// tjeneste, et formularfelt fra en webhook-formular, og ren tekst fra en genvej,
+// der bare sender det, man har markeret. Første linje bliver til opgaven, resten
+// til noten under den — det er sådan, en tekst, man har delt, ser ud.
+//
+// Linjen læses med quick-add-parseren, så "Ring til Anders i morgen p1 #Firma"
+// betyder det samme her som i feltet øverst i fladen. Det er hele pointen med at
+// have én parser: den vej, teksten kom ind ad, ændrer ikke, hvad den betyder.
+func (s *Server) handleInboundHook(w http.ResponseWriter, r *http.Request) {
+	user, err := s.db.UserByHookToken(r.Context(), chi.URLParam(r, "token"))
+	if err != nil {
+		// Samme svar som en adresse, der aldrig har eksisteret: et endpoint, der
+		// kender forskel, er en maskine til at gætte tokens med.
+		writeError(w, http.StatusNotFound, CodeNotFound, "no such address")
+		return
+	}
+
+	line, note := s.readHookBody(r)
+	if strings.TrimSpace(line) == "" {
+		writeFieldErrors(w, map[string]string{"text": "required"})
+		return
+	}
+
+	parsed := quickadd.Parse(line, time.Now().In(userLocation(user.Timezone)), user.Locale)
+	content := parsed.Content
+	if strings.TrimSpace(content) == "" {
+		content = line
+	}
+
+	projectID := ""
+	if parsed.Project != "" {
+		if id, err := s.db.ProjectByName(r.Context(), user.ID, parsed.Project); err == nil {
+			projectID = id
+		}
+	}
+	if projectID == "" {
+		if projectID, err = s.db.InboxID(r.Context(), user.ID); err != nil {
+			s.internal(w, r, "inbox", err)
+			return
+		}
+	}
+
+	task := &store.Task{
+		ProjectID: projectID, Content: content, Priority: parsed.Priority,
+		Description: strings.TrimSpace(note), DueDate: parsed.DueDate,
+		RecurrenceRule: parsed.Recurrence, CreatedBy: user.ID,
+	}
+	if err := s.db.CreateTask(r.Context(), task, parsed.Labels); err != nil {
+		s.internal(w, r, "create task from hook", err)
+		return
+	}
+
+	s.publish(projectID, "task.created", toTaskJSON(*task))
+	s.log.Info("task created from hook", "user", user.ID)
+	writeJSON(w, http.StatusCreated, map[string]string{"task_id": task.ID, "content": task.Content})
+}
+
+// readHookBody er de tre måder, en linje tekst kommer ind ad.
+//
+// Rækkefølgen er efter, hvor sikkert man ved, hvad man har: en erklæret
+// Content-Type tros, og ellers falder det tilbage på ren tekst — som er det, en
+// genvej på en telefon sender, når den ikke er blevet bedt om andet.
+//
+// En krop, der siger JSON, men ikke er det, læses ikke som tekst bagefter. Den,
+// der satte integrationen op, har skrevet noget forkert, og en opgave, der hedder
+// `{"txt": "køb mælk"}`, er en dårligere måde at finde ud af det på end et 422.
+func (s *Server) readHookBody(r *http.Request) (line, note string) {
+	const maxBody = 64 << 10
+	body, err := io.ReadAll(io.LimitReader(r.Body, maxBody))
+	if err != nil {
+		return "", ""
+	}
+	kind := r.Header.Get("Content-Type")
+
+	switch {
+	case strings.Contains(kind, "application/json"):
+		var req hookRequest
+		if err := json.Unmarshal(body, &req); err != nil {
+			return "", ""
+		}
+		return req.line(), req.note()
+
+	case strings.Contains(kind, "application/x-www-form-urlencoded"):
+		values, err := url.ParseQuery(string(body))
+		if err != nil {
+			return "", ""
+		}
+		req := hookRequest{
+			Text: values.Get("text"), Title: values.Get("title"), Content: values.Get("content"),
+			Note: values.Get("note"), Body: values.Get("body"), Description: values.Get("description"),
+		}
+		return req.line(), req.note()
+	}
+
+	// Ren tekst: første linje er opgaven, resten står under den. Sådan ser en tekst,
+	// man har delt fra en anden app, ud — en overskrift og noget under.
+	text := strings.TrimSpace(string(body))
+	first, rest, _ := strings.Cut(text, "\n")
+	return first, strings.TrimSpace(rest)
+}
+
 // mailToken reads the token out of "Name <todo+TOKEN@domain>".
 func mailToken(address string) string {
 	if i := strings.LastIndex(address, "<"); i >= 0 {

internal/httpapi/notifications_handlers.go

@@ -237,7 +237,16 @@ func (s *Server) pushToUser(userID, title, body, projectID string) pushOutcome {
 	if projectID == "" {
 		target = "/"
 	}
-	payload := push.Payload{Title: title, Body: body, URL: target}
+	// Mærket på ikonet følger med beskeden. Talt her frem for i service-workeren,
+	// som ikke har nogen hukommelse mellem to opvågninger og derfor kun kunne lægge
+	// én til noget, den ikke kender — et mærke, der tæller sig selv op og aldrig
+	// ned. Fejler tællingen, sendes beskeden alligevel: en besked uden et tal er
+	// stadig en besked.
+	unread, err := s.db.UnreadNotificationCount(ctx, userID)
+	if err != nil {
+		s.log.Warn("unread count for push", "err", err)
+	}
+	payload := push.Payload{Title: title, Body: body, URL: target, Unread: unread}
 	subject := s.vapidSubject()
 	for _, sub := range subs {
 		err := push.Send(ctx, push.Subscription{

internal/httpapi/server.go

@@ -66,6 +66,7 @@ type Server struct {
 	// Sat kun af prøver; se icsClient().
 	icsFetch     *http.Client
 	mailLimiter  *limiter
+	hookLimiter  *limiter
 	resetLimiter *limiter
 	// Second factors are counted against the *account*, not the address. An
 	// address bucket is defeated by anybody with more than one address, which is
@@ -93,6 +94,7 @@ func New(cfg *config.Config, db *store.DB, log *slog.Logger, web fs.FS) *Server
 		// day. Sixty a minute never touches real delivery and still puts a ceiling
 		// on the one public write path that has none.
 		mailLimiter:  newLimiter(60, time.Minute),
+		hookLimiter:  newLimiter(60, time.Minute),
 		resetLimiter: newLimiter(5, time.Hour),
 		// Tighter than the password bucket, and for a whole hour. Somebody typing
 		// their own code gets it right on the first or second try; ten in an hour is
@@ -143,6 +145,20 @@ func New(cfg *config.Config, db *store.DB, log *slog.Logger, web fs.FS) *Server
 	r.Method(http.MethodPost, "/inbound/mail",
 		s.rateLimit(s.mailLimiter, http.HandlerFunc(s.handleInboundMail)))
 
+	// En krog ind i indbakken: en URL, et andet program kan skubbe en linje tekst
+	// til. Uden for /api/v1 og uden for sessionen af samme grund som feedet og
+	// posten ovenfor — den, der kalder, er en genvej på en telefon eller et script,
+	// og kan ikke logge ind, så tokenet i stien er hele legitimationen.
+	//
+	// Kun POST. En GET ville være nemmere at kalde, og det er præcis problemet:
+	// forudindlæsning i en browser, en linkkontrol i en chat og en historik, der
+	// bliver besøgt igen, ville alle lave opgaver, ingen har bedt om.
+	//
+	// Sin egen kvote frem for postens: en travl integration skal ikke kunne lukke
+	// for den indgående post, og omvendt.
+	r.Method(http.MethodPost, "/inbound/hook/{token}",
+		s.rateLimit(s.hookLimiter, http.HandlerFunc(s.handleInboundHook)))
+
 	// MCP with the token in the query string, for clients that cannot send a
 	// header. Claude's custom-connector dialog takes a URL and nothing else, so
 	// /api/v1/mcp — which wants Authorization: Bearer — cannot be configured from
@@ -319,6 +335,9 @@ func New(cfg *config.Config, db *store.DB, log *slog.Logger, web fs.FS) *Server
 			r.Get("/mail-address", s.handleGetMailAddress)
 			r.Post("/mail-address/rotate", s.handleRotateMailAddress)
 
+			r.Get("/hook-url", s.handleGetHookURL)
+			r.Post("/hook-url/rotate", s.handleRotateHookURL)
+
 			// Personal API tokens. Behind requireSession rather than the ambient
 			// auth: a token must not be able to mint or revoke another.
 			r.Route("/tokens", func(r chi.Router) {
@@ -493,6 +512,12 @@ func New(cfg *config.Config, db *store.DB, log *slog.Logger, web fs.FS) *Server
 				// installation and it either phones home or it does not.
 				r.Get("/beacon/settings", s.handleBeaconStatus)
 				r.Put("/beacon/settings", s.handleSetBeacon)
+				// Beskeden om, hvad der bliver sendt, og svaret på den. I samme
+				// gruppe som resten: den, der kan slå beaconet fra, er den, der
+				// skal have beskeden, og at spørge alle andre ville være at
+				// stille et spørgsmål, de ikke kan svare på.
+				r.Get("/beacon/notice", s.handleBeaconNotice)
+				r.Post("/beacon/notice", s.handleAckBeaconNotice)
 				// A backup file is a complete copy of the database, so this whole
 				// group is sessions-only as well as administrators-only: a leaked
 				// token must not be able to download everybody's data.

internal/push/push.go

@@ -56,6 +56,13 @@ type Payload struct {
 	Body  string `json:"body,omitempty"`
 	URL   string `json:"url,omitempty"`
 	Tag   string `json:"tag,omitempty"`
+	// Unread er tallet, mærket på appens ikon skal stå på, når beskeden lander.
+	//
+	// Sendt med frem for talt i service-workeren. Den har ingen hukommelse mellem
+	// to opvågninger, så den kan kun lægge én til noget, den ikke ved hvad er — og
+	// et mærke, der tæller sig selv op, kommer aldrig ned igen af sig selv. Tallet
+	// er serverens, og serveren ved det i forvejen.
+	Unread int `json:"unread,omitempty"`
 }
 
 var b64 = base64.RawURLEncoding

internal/push/push_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"crypto/ecdh"
 	"crypto/rand"
+	"encoding/json"
 	"net/http"
 	"net/http/httptest"
 	"strings"
@@ -64,3 +65,25 @@ func testVAPID(t *testing.T) VAPID {
 	}
 	return VAPID{Public: pub, Private: priv, Subject: "mailto:[email protected]"}
 }
+
+// Tallet til mærket på ikonet skal med i beskeden — og skal blive væk, når der
+// ikke er noget at sige. Service-workeren læser netop det: er `unread` ikke et
+// tal, står mærket, som det stod, frem for at blive nulstillet af en tælling, der
+// ikke lykkedes.
+func TestPayloadCarriesTheUnreadCount(t *testing.T) {
+	with, err := json.Marshal(Payload{Title: "hej", Unread: 3})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(with), `"unread":3`) {
+		t.Errorf("payload = %s, want the unread count in it", with)
+	}
+
+	without, err := json.Marshal(Payload{Title: "hej"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(string(without), "unread") {
+		t.Errorf("payload = %s, want no count when there is none to send", without)
+	}
+}

internal/store/migrations/0035_en_krog_ind_i_indbakken.sql

@@ -0,0 +1,21 @@
+-- En personlig adresse, andre programmer kan skubbe en opgave ind ad.
+--
+-- Der var to veje ind i forvejen, og ingen af dem passer til "gem den her, mens
+-- jeg står med telefonen i hånden". API-tokenet giver adgang til alt og skal have
+-- en JSON-krop skrevet rigtigt; mailadressen virker først, når nogen har sat en
+-- mailserver op, og går gennem en indbakke, der kan være minutter om det. Det, der
+-- manglede, var en URL, man kan smide en linje tekst efter.
+--
+-- Sit eget token frem for at låne mailens. De to er den samme slags hemmelighed,
+-- men de bliver kompromitteret hver for sig: en URL, der har ligget i en genvej på
+-- en telefon, der blev væk, skal kunne skiftes uden at mailadressen — som står i
+-- andres adressebøger — skifter med. Og omvendt.
+--
+-- Ikke et API-token. Et token herfra kan én ting: lave en opgave i den persons
+-- indbakke. Det er hele forskellen på en hemmelighed, man kan lægge i et script på
+-- en anden maskine, og en, man ikke kan.
+ALTER TABLE users ADD COLUMN hook_token TEXT;
+
+-- Opslaget er "hvem er det her token", og det er også dét, der skal være entydigt:
+-- to konti med det samme token er to konti, en opgave kan lande i.
+CREATE UNIQUE INDEX idx_users_hook_token ON users (hook_token) WHERE hook_token IS NOT NULL;

internal/store/notifications.go

@@ -330,6 +330,52 @@ func (db *DB) SetMailToken(ctx context.Context, userID, token string) error {
 	return err
 }
 
+// --- krogen ind i indbakken ------------------------------------------------------
+
+// EnsureHookToken returns the token in the person's webhook URL, minting one the
+// first time it is asked for.
+//
+// Sit eget token frem for mailens. De to er den samme slags hemmelighed, men de
+// slipper ud hver for sig: en URL, der har ligget i en genvej på en telefon, der
+// blev væk, skal kunne skiftes uden at mailadressen — som står i andres
+// adressebøger — skifter med.
+func (db *DB) EnsureHookToken(ctx context.Context, userID string) (string, error) {
+	var token sql.NullString
+	err := db.QueryRowContext(ctx, `SELECT hook_token FROM users WHERE id = ?`, userID).Scan(&token)
+	if err != nil {
+		return "", err
+	}
+	if token.Valid && token.String != "" {
+		return token.String, nil
+	}
+
+	fresh, err := auth.NewToken()
+	if err != nil {
+		return "", err
+	}
+	if err := db.SetHookToken(ctx, userID, fresh); err != nil {
+		return "", err
+	}
+	return fresh, nil
+}
+
+func (db *DB) SetHookToken(ctx context.Context, userID, token string) error {
+	_, err := db.ExecContext(ctx,
+		`UPDATE users SET hook_token = ?, updated_at = ? WHERE id = ?`,
+		token, time.Now().Unix(), userID)
+	return err
+}
+
+// UserByHookToken is who a webhook call is on behalf of. Tokenet er hele
+// legitimationen, så et tomt et er et nej med det samme frem for et opslag, der
+// kunne ramme en række, hvor søjlen aldrig er sat.
+func (db *DB) UserByHookToken(ctx context.Context, token string) (*User, error) {
+	if token == "" {
+		return nil, ErrNotFound
+	}
+	return db.scanUser(ctx, `SELECT `+userColumns+` FROM users WHERE hook_token = ?`, token)
+}
+
 func (db *DB) UserByMailToken(ctx context.Context, token string) (*User, error) {
 	if token == "" {
 		return nil, ErrNotFound

web/e2e/auth.setup.js

@@ -28,5 +28,20 @@ setup('opret den første konto og log ind', async ({ page }) => {
 	await expect(page.getByRole('navigation', { name: 'Hovedmenu' })).toBeVisible();
 	await expect(page.getByRole('heading', { name: 'I dag' })).toBeVisible();
 
+	// Beaconet er slået til som udgangspunkt, og det bliver sagt uopfordret her —
+	// det er hele grunden til, at et default-on er til at forsvare. Prøvet her,
+	// fordi det er det eneste sted, en helt frisk installation bliver logget ind
+	// på for første gang, og fordi beskeden ellers ville stå i vejen for hver
+	// eneste prøve nedenfor og skulle klikkes væk uden at nogen havde set efter,
+	// om den overhovedet sagde det rigtige.
+	const notice = page.getByRole('region', { name: /melder, at den findes/ });
+	await expect(notice).toBeVisible();
+	// Værdierne står i beskeden, ikke ordet "anonymt": et løfte om telemetri er
+	// præcis så meget værd som læserens mulighed for at efterprøve det.
+	await expect(notice.getByText('instance_id')).toBeVisible();
+	await expect(notice.getByText('version')).toBeVisible();
+	await notice.getByRole('button', { name: 'Behold den' }).click();
+	await expect(notice).toBeHidden();
+
 	await page.context().storageState({ path: AUTH_FILE });
 });

web/src/lib/api.js

@@ -280,6 +280,11 @@ export const api = {
 
 	beacon: () => get('/beacon/settings'),
 	setBeacon: (body) => put('/beacon/settings', body),
+	// Beskeden om, hvad installationen melder ind, og svaret på den. `keep` sendes
+	// altid — en tom krop måtte ikke kunne betyde "slå det fra", og serveren
+	// afviser den derfor.
+	beaconNotice: () => get('/beacon/notice'),
+	answerBeaconNotice: (keep) => post('/beacon/notice', { keep }),
 
 	listBackups: () => get('/backups'),
 	runBackup: () => post('/backups'),
@@ -418,6 +423,11 @@ export const api = {
 	getMailAddress: () => get('/mail-address'),
 	rotateMailAddress: () => post('/mail-address/rotate'),
 
+	// Krogen ind i indbakken. Selve skubbet sker ikke herfra — det er et andet
+	// program, der gør det — så der er kun adressen at hente og at skifte.
+	getHookURL: () => get('/hook-url'),
+	rotateHookURL: () => post('/hook-url/rotate'),
+
 	getGmail: () => get('/gmail'),
 	setGmail: (data) => put('/gmail', data),
 	disconnectGmail: () => del('/gmail'),

web/src/lib/badge.js

@@ -0,0 +1,46 @@
+/**
+ * Mærket på appens ikon — tallet i Dock'en på en Mac, på proceslinjen på en pc.
+ *
+ * Klokken i hovedet siger det samme, men kun til den, der kigger på fanen. Det
+ * halve af pointen med at få besked er at få den, mens man laver noget andet, og
+ * det eneste sted, appen kan sige noget dér, er på sit eget ikon.
+ *
+ * Sat to steder, fordi der er to tilstande: her, mens appen er åben og selv ved
+ * hvor mange ulæste der er, og i service-workeren, når den ikke er — se `push`-
+ * lytteren i service-worker.js, som får tallet med i beskeden.
+ *
+ * Ét tal, ikke en optælling. Mærket sættes til hvad der *er*, aldrig til hvad der
+ * lige er kommet, så det kommer ned igen af sig selv, når beskederne bliver læst.
+ */
+
+/**
+ * Kan browseren mærke sit ikon? Safari og Chrome kan, når appen er lagt i Dock'en
+ * eller installeret; en almindelig fane har intet ikon at mærke, og kaldet gør
+ * ingenting. Firefox kan ikke endnu.
+ */
+export function supported() {
+	return typeof navigator !== 'undefined' && 'setAppBadge' in navigator;
+}
+
+/**
+ * Sætter mærket til `n`, eller fjerner det ved nul.
+ *
+ * Tavs, når det ikke kan lade sig gøre. Et mærke er en venlighed oven på klokken,
+ * der allerede står i fladen — ikke noget at afbryde nogen med, hvis browseren
+ * siger nej.
+ */
+export function setBadge(n) {
+	if (!supported()) return;
+	const count = Number(n) || 0;
+	try {
+		const done = count > 0 ? navigator.setAppBadge(count) : navigator.clearAppBadge();
+		done?.catch?.(() => {});
+	} catch {
+		// Nogle browsere kaster i stedet for at afvise. Det er det samme svar.
+	}
+}
+
+/** Fjerner mærket helt. Brugt ved log ud: den næste, der lander her, er en anden. */
+export function clearBadge() {
+	setBadge(0);
+}

web/src/lib/components/BeaconNotice.svelte

@@ -0,0 +1,142 @@
+<script>
+	/**
+	 * Beskeden om, at denne installation melder ind — sagt uopfordret, første gang
+	 * en administrator er logget ind.
+	 *
+	 * Beaconet er slået til som udgangspunkt, og det kan kun forsvares, hvis det
+	 * bliver sagt af sig selv. Siden under Indstillinger → Data siger det rigtigt
+	 * og fyldestgørende, og den bliver åbnet af dem, der i forvejen har en
+	 * mistanke om, at der er noget at læse; for alle andre er "du kan slå den fra"
+	 * et tilbud til nogen, der ikke ved, der er noget at slå fra.
+	 *
+	 * De tre værdier står i beskeden — det rigtige id, den rigtige version, den
+	 * rigtige adresse — frem for ordene "anonyme data". Et løfte om telemetri er
+	 * præcis så meget værd som læserens mulighed for at efterprøve det.
+	 *
+	 * Kun til administratorer, og hentet på `app.user` frem for i onMount: en
+	 * indlæsning, der kører, mens login-siden står, kører aldrig for den, der lige
+	 * er logget ind — og så er beskeden aldrig sagt til dem, den er skrevet til.
+	 */
+	import { app } from '$lib/stores.svelte.js';
+	import { api } from '$lib/api.js';
+	import { t } from '$lib/i18n.svelte.js';
+	import { humanMessage } from '$lib/api.js';
+
+	let notice = $state(null);
+	let busy = $state(false);
+
+	$effect(() => {
+		const me = app.user;
+		if (!me?.is_admin) {
+			notice = null;
+			return;
+		}
+		let alive = true;
+		api
+			.beaconNotice()
+			.then((r) => {
+				if (alive && r?.pending) notice = r;
+			})
+			.catch(() => {
+				// En besked, der ikke kunne hentes, må ikke stå i vejen for appen.
+				// Den er stadig ubesvaret næste gang, og bliver stillet igen.
+			});
+		return () => {
+			alive = false;
+		};
+	});
+
+	async function answer(keep) {
+		if (busy) return;
+		busy = true;
+		try {
+			await api.answerBeaconNotice(keep);
+			notice = null;
+			app.toast(keep ? t('beacon.noticeKept') : t('beacon.noticeStopped'));
+		} catch (e) {
+			app.toast(humanMessage(e));
+		} finally {
+			busy = false;
+		}
+	}
+</script>
+
+{#if notice}
+	<aside class="notice" role="region" aria-label={t('beacon.noticeTitle')}>
+		<h2>{t('beacon.noticeTitle')}</h2>
+		<p>{t('beacon.noticeBody')}</p>
+
+		<!-- Det, der bliver sendt, med de rigtige værdier i. Ikke et eksempel: det
+		     er selve meldingen, og den kan sammenholdes med indstillingssiden. -->
+		<pre>{JSON.stringify(
+				{ instance_id: notice.instance_id, version: notice.version },
+				null,
+				2
+			)}</pre>
+		<p class="to">{t('beacon.noticeTo', { url: notice.collector_url })}</p>
+
+		<div class="row">
+			<button class="button" disabled={busy} onclick={() => answer(true)}>
+				{t('beacon.noticeKeep')}
+			</button>
+			<button class="secondary" disabled={busy} onclick={() => answer(false)}>
+				{t('beacon.noticeStop')}
+			</button>
+			<a href="/indstillinger/data">{t('beacon.noticeMore')}</a>
+		</div>
+	</aside>
+{/if}
+
+<style>
+	/* Øverst i indholdet, i flowet — ikke svævende over det. En rude, der ligger
+	   oven på arbejdet, dækker knapper, og en besked, der er i vejen, bliver
+	   klikket væk uden at blive læst. Den her skubber i stedet, står til den
+	   bliver besvaret, og forsvinder så for altid. */
+	.notice {
+		margin: 0 0 var(--s3);
+		max-width: 44rem;
+		padding: var(--s3);
+		border: 1px solid var(--line);
+		border-radius: var(--radius-lg, var(--radius));
+		background: var(--surface-raised, var(--surface));
+		box-shadow: var(--shadow-lg, 0 10px 30px rgb(0 0 0 / 0.25));
+		font-size: var(--text-sm);
+	}
+
+	.notice h2 {
+		margin: 0 0 var(--s1);
+		font-size: var(--text-sm);
+	}
+
+	.notice p {
+		margin: 0 0 var(--s2);
+		color: var(--ink-muted);
+		line-height: 1.5;
+	}
+
+	.notice pre {
+		margin: 0 0 var(--s1);
+		padding: var(--s2);
+		border-radius: var(--radius);
+		background: var(--surface-sunken, var(--surface));
+		font-size: var(--text-xs);
+		overflow-x: auto;
+	}
+
+	.notice .to {
+		font-size: var(--text-xs);
+		word-break: break-all;
+	}
+
+	.row {
+		display: flex;
+		align-items: center;
+		gap: var(--s2);
+		flex-wrap: wrap;
+	}
+
+	.row a {
+		font-size: var(--text-xs);
+		color: var(--ink-muted);
+	}
+</style>

web/src/lib/components/Sidebar.svelte

@@ -1,6 +1,7 @@
 <script>
 	import { app, sidebar, projectName } from '$lib/stores.svelte.js';
 	import { api } from '$lib/api.js';
+	import { clearBadge } from '$lib/badge.js';
 	import { TASK, PROJECT, GROUP, NOTE, startDrag, carries, dragged, accept } from '$lib/dnd.js';
 	import { COLORS, colorVar } from '$lib/colors.js';
 	import { focusOnMount } from '$lib/focus.js';
@@ -31,6 +32,9 @@
 
 	async function signOut() {
 		await api.logout();
+		// Mærket på ikonet er den forriges ulæste. Det står i Dock'en, også når
+		// ingen er logget ind, så det skal væk sammen med resten af dem.
+		clearBadge();
 		// Empty the offline data cache before leaving: the service worker keeps the
 		// last-seen task and note lists so a network drop does not blank the app, and
 		// the next person to sign in on this browser must not find them.

web/src/lib/locales/da.js

@@ -90,6 +90,22 @@ export const da = {
 	'beacon.active7': 'Aktive 7 dage',
 	'beacon.active30': 'Aktive 30 dage',
 	'beacon.byVersion': 'Efter version (30 dage):',
+	// Beskeden, der bliver sagt uopfordret første gang. Værdierne står i den, ikke
+	// ordet 'anonymt': et løfte om telemetri er præcis så meget værd som
+	// læserens mulighed for at efterprøve det.
+	'beacon.noticeTitle': 'Denne installation melder, at den findes',
+	'beacon.noticeBody':
+		'Én gang i døgnet sender Verdande to værdier til projektet, så det kan ses, hvor mange installationer der er. Præcis de her to — intet andet, ingen IP bliver gemt, intet om hvad du bruger det til:',
+	'beacon.noticeTo': 'Sendes til {url}',
+	'beacon.noticeKeep': 'Behold den',
+	'beacon.noticeStop': 'Slå den fra',
+	'beacon.noticeMore': 'Læs mere',
+	'beacon.noticeKept': 'Tak. Du kan altid slå den fra under Indstillinger → Data.',
+	'beacon.noticeStopped': 'Meldingen er slået fra. Der bliver ikke sendt noget.',
+	'beacon.lastError': 'Sidste forsøg nåede ikke frem ({when}): {why}',
+	'beacon.publishMin': 'Offentliggør først fra',
+	'beacon.publishMinHint':
+		'Under det tal svares der ingenting. Et lille tal fortæller mest om, hvor lidt der skal til at flytte det — og et, der falder, ville blive læst som “færre bruger det nu”, også når det var en udrulning, der gik galt.',
 	'beacon.publish': 'Offentliggør tallet på /api/v1/beacon/count',
 	'beacon.publishHint': 'Uden login, mellemlagret et minut. Viser installationer set de seneste 30 dage — ikke et løbende total, som kun ville stige.',
 	'notes.newHere': 'Ny note',
@@ -751,6 +767,17 @@ export const da = {
 		'Der er ingen mailserver sat op på denne server, så adressen herunder kan ikke modtage noget endnu. Sæt VERDANDE_SMTP_HOST og de øvrige SMTP-indstillinger, og få mailserveren til at aflevere post til todo+* videre til /inbound/mail.',
 	'int.yourAddress': 'Din adresse',
 	'int.newAddress': 'Ny adresse',
+	// Krogen ind i indbakken: en URL, et andet program kan skubbe en opgave til.
+	'int.hookToTask': 'Skub fra andre programmer',
+	'int.hookHint':
+		'En adresse, andre programmer kan sende en opgave til — en genvej på telefonen, et script, en tjeneste, der kan kalde en URL. Linjen læses som i feltet øverst i fladen, så “i morgen”, “p1” og “#Projekt” betyder det samme her.',
+	'int.yourHook': 'Din adresse',
+	'int.hookHow':
+		'Send en POST med teksten som krop — ren tekst, JSON med et {text}-felt, eller et formularfelt. Første linje bliver opgaven, resten står under den. Adressen er en nøgle: den, der har den, kan lægge opgaver i din indbakke og ikke andet.',
+	'int.hookExample': 'Sådan ser det ud',
+	'int.newHook': 'Ny adresse',
+	'int.newHookQuestion':
+		'Vil du have en ny adresse? Den gamle holder op med at virke med det samme, og alt, der bruger den, skal rettes.',
 	'int.caldav': 'CalDAV',
 	'int.caldavHint':
 		'Tovejs, i modsætning til feedet ovenfor: Apple Påmindelser og Thunderbird kan også skrive tilbage.',

web/src/lib/locales/en.js

@@ -87,6 +87,22 @@ export const en = {
 	'beacon.active7': 'Active 7 days',
 	'beacon.active30': 'Active 30 days',
 	'beacon.byVersion': 'By version (30 days):',
+	// The notice said unprompted the first time. The values are in it rather than
+	// the word 'anonymous': a promise about telemetry is worth exactly as much as
+	// the reader's ability to check it.
+	'beacon.noticeTitle': 'This installation reports that it exists',
+	'beacon.noticeBody':
+		'Once a day Verdande sends two values to the project, so it can see how many installations there are. Exactly these two — nothing else, no IP is stored, nothing about what you use it for:',
+	'beacon.noticeTo': 'Sent to {url}',
+	'beacon.noticeKeep': 'Keep it on',
+	'beacon.noticeStop': 'Turn it off',
+	'beacon.noticeMore': 'Read more',
+	'beacon.noticeKept': 'Thank you. You can always turn it off under Settings → Data.',
+	'beacon.noticeStopped': 'Reporting is off. Nothing is being sent.',
+	'beacon.lastError': 'The last attempt did not arrive ({when}): {why}',
+	'beacon.publishMin': 'Publish only from',
+	'beacon.publishMinHint':
+		'Below that number nothing is answered. A small number mostly says how little it takes to move it — and one that falls would read as “fewer people use this now”, even when it was a release that went wrong.',
 	'beacon.publish': 'Publish the count at /api/v1/beacon/count',
 	'beacon.publishHint': 'No login, cached for a minute. Reports installations seen in the last 30 days — not a running total, which would only ever climb.',
 	'notes.newHere': 'New note',
@@ -748,6 +764,17 @@ export const en = {
 		'No mail server is configured on this server, so the address below cannot receive anything yet. Set VERDANDE_SMTP_HOST and the other SMTP settings, and have the mail server deliver post for todo+* to /inbound/mail.',
 	'int.yourAddress': 'Your address',
 	'int.newAddress': 'New address',
+	// The hook into the inbox: a URL another program can push a task to.
+	'int.hookToTask': 'Push from other programs',
+	'int.hookHint':
+		'An address other programs can send a task to — a shortcut on your phone, a script, any service that can call a URL. The line is read the way the box at the top of the app reads it, so “tomorrow”, “p1” and “#Project” mean the same here.',
+	'int.yourHook': 'Your address',
+	'int.hookHow':
+		'Send a POST with the text as the body — plain text, JSON with a {text} field, or a form field. The first line becomes the task and the rest sits underneath it. The address is a key: whoever has it can put tasks in your inbox, and nothing else.',
+	'int.hookExample': 'What it looks like',
+	'int.newHook': 'New address',
+	'int.newHookQuestion':
+		'Do you want a new address? The old one stops working immediately, and anything using it has to be changed.',
 	'int.caldav': 'CalDAV',
 	'int.caldavHint':
 		'Two-way, unlike the feed above: Apple Reminders and Thunderbird can write back as well.',

web/src/routes/+layout.svelte

@@ -10,6 +10,8 @@
 	import SignIn from '$lib/components/SignIn.svelte';
 	import TaskDetail from '$lib/components/TaskDetail.svelte';
 	import { t } from '$lib/i18n.svelte.js';
+	import { setBadge } from '$lib/badge.js';
+	import BeaconNotice from '$lib/components/BeaconNotice.svelte';
 
 	let { children } = $props();
 
@@ -53,6 +55,13 @@
 		app.load();
 	});
 
+	// Tallet på appens ikon følger klokken. Ét sted, fordi der er ét tal: hentet,
+	// skubbet over websocket'en eller læst væk — mærket er det samme svar på alle
+	// tre, og en optælling pr. vej ville være tre, der kan blive uenige.
+	$effect(() => {
+		setBadge(app.unread);
+	});
+
 	/**
 	 * Global keys.
 	 *
@@ -184,6 +193,13 @@
 			</header>
 
 			<div class="content">
+				<!-- Sagt uopfordret, første gang en administrator er logget ind: hvad
+				     denne installation melder ind, og hvordan man siger nej.
+				     Øverst i indholdet og ikke svævende over det — en rude, der
+				     ligger oven på arbejdet, dækker knapper, og en besked, der er i
+				     vejen, bliver klikket væk uden at blive læst. Komponenten tegner
+				     ingenting, når der ikke er noget at fortælle. -->
+				<BeaconNotice />
 				{@render children()}
 			</div>
 		</main>

web/src/routes/indstillinger/data/+page.svelte

@@ -534,6 +534,18 @@
 		<pre class="payload">{t('beacon.exactly')}
 {JSON.stringify({ instance_id: beacon.instance_id, version: beacon.version }, null, 2)}</pre>
 
+		{#if beacon.last_error}
+			<!-- Et beacon, der ikke kan nå sin collector, fejler ellers i fuldstændig
+			     tavshed: det prøver igen i morgen, og "sidst sendt" bliver bare ved
+			     med at blive ældre. Ikke en fejl, der skal afbryde nogen — en linje,
+			     hvor siden ellers påstår, at alt er sendt. -->
+			<p class="hint">
+				{t('beacon.lastError', {
+					when: new Date(beacon.last_error_at).toLocaleString(tag()),
+					why: beacon.last_error
+				})}
+			</p>
+		{/if}
 		{#if beacon.last_ping_at}
 			<p class="hint">{t('beacon.lastPing', { when: new Date(beacon.last_ping_at).toLocaleString(tag()) })}</p>
 		{/if}
@@ -592,6 +604,20 @@
 				/>
 				<span>{t('beacon.publish')}</span>
 			</label>
+
+			{#if beacon.publish_count}
+				<div class="field">
+					<label for="publishmin">{t('beacon.publishMin')}</label>
+					<input
+						id="publishmin"
+						type="number"
+						min="0"
+						value={beacon.publish_min}
+						onchange={(e) => saveBeacon({ publish_min: Number(e.currentTarget.value) })}
+					/>
+					<p class="hint">{t('beacon.publishMinHint')}</p>
+				</div>
+			{/if}
 			<p class="hint">{t('beacon.publishHint')}</p>
 		{/if}
 	{/if}

web/src/routes/indstillinger/integrationer/+page.svelte

@@ -289,6 +289,9 @@
 
 	let feedURL = $state('');
 	let mailAddress = $state('');
+	// Krogen ind i indbakken: den URL, en genvej på telefonen eller et script kan
+	// skubbe en linje tekst til.
+	let hookURL = $state('');
 	/** Null until loaded, so the warning does not flash before the answer is in. */
 	let mailConfigured = $state(null);
 
@@ -301,6 +304,10 @@
 				mailConfigured = r.configured;
 			})
 			.catch(() => {});
+		api
+			.getHookURL()
+			.then((r) => (hookURL = r.url))
+			.catch(() => {});
 	});
 
 	async function rotateFeed() {
@@ -323,6 +330,15 @@
 		}
 	}
 
+	async function rotateHook() {
+		if (!confirm(t('int.newHookQuestion'))) return;
+		try {
+			hookURL = (await api.rotateHookURL()).url;
+		} catch (e) {
+			app.toast(humanMessage(e));
+		}
+	}
+
 	async function copy(text) {
 		try {
 			await navigator.clipboard.writeText(text);
@@ -674,6 +690,38 @@
 	</div>
 </section>
 
+<section class="panel">
+	<header>
+		<h2>{t('int.hookToTask')}</h2>
+		<p class="hint">
+			{t('int.hookHint')}
+		</p>
+	</header>
+
+	<div class="field">
+		<label for="hook">{t('int.yourHook')}</label>
+		<input id="hook" class="mono" value={hookURL} readonly />
+		<p class="hint">
+			{t('int.hookHow')}
+		</p>
+	</div>
+
+	<!-- Vist som den kommando, den er. Den, der skal sætte det op, skal kunne
+	     prøve det af ét sted, før de bygger genvejen på telefonen — og se, at
+	     kroppen bare er den linje, opgaven skal hedde. -->
+	<div class="field">
+		<label for="hookcurl">{t('int.hookExample')}</label>
+		<textarea id="hookcurl" class="mono" rows="3" readonly
+			>{`curl -X POST ${hookURL} \\\n  -H "Content-Type: text/plain" \\\n  -d "Ring til Anders i morgen p1 #Firma"`}</textarea
+		>
+	</div>
+
+	<div class="row">
+		<button class="secondary" onclick={() => copy(hookURL)}>{t('int.copy')}</button>
+		<button class="danger" onclick={rotateHook}>{t('int.newHook')}</button>
+	</div>
+</section>
+
 <section class="panel">
 	<header>
 		<h2>{t('int.caldav')}</h2>

web/src/service-worker.js

@@ -145,6 +145,19 @@ self.addEventListener('push', (event) => {
 	}
 
 	const title = payload.title || 'verdande';
+	// Mærket på appens ikon — i Dock'en på en Mac, på proceslinjen på en pc.
+	//
+	// Sat her, fordi det her er det eneste, der kører, når appen ikke er åben: det
+	// er netop dér, et tal på ikonet er det, der siger, at der er noget nyt. Tallet
+	// kommer med beskeden frem for at blive talt op her; en service-worker husker
+	// ingenting mellem to opvågninger, så et mærke, den selv talte, ville kun kunne
+	// gå opad.
+	//
+	// Kan browseren ikke sætte mærker, sker der ingenting. Det er ikke en fejl at
+	// melde om: beskeden selv kom frem, og den er hovedsagen.
+	if (typeof payload.unread === 'number' && 'setAppBadge' in self.navigator) {
+		self.navigator.setAppBadge(payload.unread).catch(() => {});
+	}
 	event.waitUntil(
 		self.registration.showNotification(title, {
 			body: payload.body || '',