Files
alan 40ba2ac117 Open ntfy notifications in the app and notify chats that need the operator
Run notifications now always click through to pipelines://run/<id>; a valid
PIPELINES_WEB_PUBLIC_URL adds an "Open in browser" ntfy view action instead
of replacing the click. Queued rows derive links from the run id at delivery,
so legacy rows holding a web URL still open the app.

Unresolved chat questions/forms and permission requests publish one async,
bounded notification to the system destination (pipelines://chat/<id> plus the
browser action), deduplicated per form/request id across reconnects and
replays. stage.PublishNtfy gains optional, strictly validated view actions.
Server tests now clear the operator's real ntfy environment.
2026-10-30 20:40:06 +00:00

264 lines
10 KiB
Go

package stage
import (
"bytes"
"context"
"encoding/json"
"fmt"
"io"
"maps"
"mime"
"net/http"
"net/url"
"os"
"path/filepath"
"regexp"
"strings"
"time"
"unicode/utf8"
)
const NtfyType = "ntfy"
var destinationName = regexp.MustCompile(`^[a-z][a-z0-9_]{0,63}$`)
var ntfyMessageID = regexp.MustCompile(`^[A-Za-z0-9_-]{1,128}$`)
var ntfyTopic = regexp.MustCompile(`^[-_A-Za-z0-9]{1,64}$`)
var ntfyTokenValue = regexp.MustCompile(`^[A-Za-z0-9_-]+$`)
// NtfyStage publishes to an operator-configured destination. Tokens never enter
// stage prompts, definitions, output maps, or diagnostics. No automatic retries:
// an ambiguous network failure may already have delivered the notification.
type NtfyStage struct{}
func (NtfyStage) Validate(def Definition) error {
if def.Type != NtfyType {
return fmt.Errorf("expected ntfy stage")
}
for name := range def.Blocks {
switch name {
case "configs", "edges", "output":
default:
return fmt.Errorf("unexpected block %q for ntfy stage", name)
}
}
for key := range def.Configs {
if key != "destination" && key != "timeout" {
return fmt.Errorf("unknown ntfy config %q", key)
}
}
if _, err := StageTimeout(def); err != nil {
return err
}
if !destinationName.MatchString(def.Configs["destination"]) {
return fmt.Errorf("ntfy destination must be a lowercase name containing letters, digits, or underscores")
}
if def.Edges["success"] == "" {
return fmt.Errorf("ntfy stage requires a success outcome")
}
return nil
}
func (NtfyStage) Run(ctx context.Context, def Definition, input Values) (Result, error) {
if err := (NtfyStage{}).Validate(def); err != nil {
return Result{}, err
}
timeout, _ := StageTimeout(def)
ctx, cancel := context.WithTimeout(ctx, timeout)
defer cancel()
title, _ := input["title"].(string)
summary, _ := input["summary"].(string)
markdown, _ := input["markdown"].(string)
for name, text := range map[string]string{"title": title, "summary": summary, "markdown": markdown} {
if strings.TrimSpace(text) == "" || !utf8.ValidString(text) || strings.ContainsRune(text, '\x00') {
return Result{}, fmt.Errorf("ntfy input.%s must be a nonempty UTF-8 string", name)
}
}
if len(title) > 256 || len(summary) > 2048 || len(markdown) > 1<<20 {
return Result{}, fmt.Errorf("ntfy input exceeds limits (title 256 bytes, summary 2048 bytes, markdown 1 MiB)")
}
if strings.ContainsAny(title, "\r\n") || strings.ContainsAny(summary, "\r\n") {
return Result{}, fmt.Errorf("ntfy title and summary must be single-line strings")
}
delivery, err := PublishNtfy(ctx, def.Configs["destination"], title, summary, "digest.md", []byte(markdown), "")
if err != nil {
return Result{}, err
}
output := maps.Clone(input)
output["delivery"] = delivery
return Result{Outcome: "success", Output: output}, nil
}
// PublishNtfy is shared by native delivery stages and stage notification hooks.
// An empty filename publishes an event without an attachment. A non-empty click
// is an optional ntfy Click action (an absolute URL) so a tap on the notification
// opens the destination the operator should act on; it is validated here and
// never carries credentials. Optional views add ntfy "view" action buttons (for
// example "Open in browser"); each is validated as strictly as the click.
func PublishNtfy(ctx context.Context, destination, title, summary, filename string, data []byte, click string, views ...NtfyView) (Values, error) {
if !destinationName.MatchString(destination) || strings.TrimSpace(title) == "" || strings.TrimSpace(summary) == "" || len(title) > 256 || len(summary) > 2048 || !utf8.ValidString(title) || !utf8.ValidString(summary) || strings.ContainsAny(title+summary, "\r\n\x00") {
return nil, fmt.Errorf("invalid ntfy notification metadata")
}
if !validNtfyClick(click) {
return nil, fmt.Errorf("invalid ntfy click action")
}
actions, err := ntfyViewActions(views)
if err != nil {
return nil, err
}
if len(data) > 1<<20 || (filename != "" && (filename != filepath.Base(filename) || filename == "." || strings.ContainsAny(filename, "/\\\r\n\x00") || len(filename) > 200)) {
return nil, fmt.Errorf("invalid ntfy attachment")
}
prefix := "PIPELINES_NTFY_" + strings.ToUpper(destination)
if destination == "system" {
prefix = "PIPELINES_NTFY"
}
endpoint := os.Getenv(prefix + "_URL")
token := os.Getenv(prefix + "_TOKEN")
if path := os.Getenv(prefix + "_TOKEN_FILE"); path != "" {
if token != "" {
return nil, fmt.Errorf("configure only one ntfy token source")
}
file, err := os.Open(path)
if err != nil {
return nil, fmt.Errorf("cannot read ntfy token file")
}
contents, err := io.ReadAll(io.LimitReader(file, 4097))
file.Close()
if err != nil || len(contents) > 4096 {
return nil, fmt.Errorf("invalid ntfy token file")
}
token = strings.TrimSpace(string(contents))
if token == "" {
return nil, fmt.Errorf("ntfy token file is empty")
}
}
u, err := url.Parse(endpoint)
if err != nil || u.Hostname() == "" || (u.Scheme != "http" && u.Scheme != "https") || u.User != nil || u.RawQuery != "" || u.Fragment != "" || !ntfyTopic.MatchString(strings.TrimPrefix(u.Path, "/")) || u.RawPath != "" {
return nil, fmt.Errorf("configure %s_URL with an HTTP(S) ntfy topic URL (no credentials or query)", prefix)
}
if token != "" && (len(token) > 4096 || !ntfyTokenValue.MatchString(token)) {
return nil, fmt.Errorf("invalid ntfy token configuration")
}
method := http.MethodPut
if filename == "" {
method = http.MethodPost
data = []byte(summary)
}
request, err := http.NewRequestWithContext(ctx, method, endpoint, bytes.NewReader(data))
if err != nil {
return nil, fmt.Errorf("cannot create ntfy request")
}
request.Header.Set("Content-Type", "application/octet-stream")
if filename == "" {
request.Header.Set("Content-Type", "text/plain; charset=utf-8")
} else if strings.HasSuffix(filename, ".md") {
request.Header.Set("Content-Type", "text/markdown; charset=utf-8")
}
request.Header.Set("Title", mime.BEncoding.Encode("utf-8", title))
request.Header.Set("Message", mime.BEncoding.Encode("utf-8", summary))
if click != "" {
request.Header.Set("Click", click)
}
if actions != "" {
request.Header.Set("Actions", actions)
}
if filename != "" {
request.Header.Set("Filename", mime.BEncoding.Encode("utf-8", filename))
}
if strings.HasSuffix(filename, ".md") {
request.Header.Set("Markdown", "yes")
}
if token != "" {
request.Header.Set("Authorization", "Bearer "+token)
}
client := &http.Client{Timeout: 20 * time.Second, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}
response, err := client.Do(request)
if err != nil {
if ctx.Err() != nil {
return nil, ctx.Err()
}
return nil, fmt.Errorf("ntfy delivery unconfirmed; inspect destination before retrying")
}
defer response.Body.Close()
if response.StatusCode < 200 || response.StatusCode >= 300 {
return nil, fmt.Errorf("ntfy publish returned HTTP %d; delivery not confirmed", response.StatusCode)
}
body, err := io.ReadAll(io.LimitReader(response.Body, (64<<10)+1))
if err != nil || len(body) > 64<<10 {
return nil, fmt.Errorf("ntfy acknowledgment unreadable; inspect destination before retrying")
}
var ack struct {
ID string `json:"id"`
Event string `json:"event"`
Attachment struct {
URL string `json:"url"`
Name string `json:"name"`
} `json:"attachment"`
}
if json.Unmarshal(body, &ack) != nil || !ntfyMessageID.MatchString(ack.ID) || ack.Event != "message" || (filename != "" && ack.Attachment.Name != filename) {
return nil, fmt.Errorf("ntfy acknowledgment invalid or missing attachment; inspect destination before retrying")
}
if filename != "" {
attachment, err := url.Parse(ack.Attachment.URL)
if err != nil || attachment.Hostname() == "" || (attachment.Scheme != "http" && attachment.Scheme != "https") || attachment.User != nil {
return nil, fmt.Errorf("ntfy acknowledgment has no valid attachment URL; inspect destination before retrying")
}
}
return Values{"destination": destination, "message_id": ack.ID, "attachment_url": ack.Attachment.URL, "filename": filename}, nil
}
// validNtfyClick accepts an empty click or an absolute URL the ntfy server will
// hand to the operating system on tap: a scheme, no credentials, no fragment,
// no control characters and a bounded length. The value is an operator-visible
// deep link, never a place to smuggle a token.
func validNtfyClick(click string) bool {
if click == "" {
return true
}
if len(click) > 2048 || !utf8.ValidString(click) || strings.ContainsAny(click, "\r\n\t\x00 ") {
return false
}
u, err := url.Parse(click)
return err == nil && u.Scheme != "" && u.User == nil && u.Fragment == ""
}
// NtfyView is one ntfy "view" action button: a tap opens URL. Label is short
// printable ASCII and URL is an absolute HTTP(S) address without credentials.
type NtfyView struct {
Label string
URL string
}
// ntfyViewActions renders views in ntfy's simple Actions header format
// ("view, <label>, <url>", separated by "; "). Commas, semicolons and quotes are
// rejected rather than escaped, so a value can never split into another action.
func ntfyViewActions(views []NtfyView) (string, error) {
if len(views) > 3 { // ntfy allows at most three actions.
return "", fmt.Errorf("at most 3 ntfy actions")
}
parts := make([]string, 0, len(views))
for _, view := range views {
label := strings.TrimSpace(view.Label)
if label == "" || len(label) > 64 || strings.ContainsAny(label, ",;\"'\\=") || !printableASCII(label) {
return "", fmt.Errorf("invalid ntfy action label")
}
if view.URL == "" || !validNtfyClick(view.URL) || strings.ContainsAny(view.URL, ",;\"'\\") || !printableASCII(view.URL) {
return "", fmt.Errorf("invalid ntfy action URL")
}
if u, err := url.Parse(view.URL); err != nil || (u.Scheme != "http" && u.Scheme != "https") || u.Hostname() == "" {
return "", fmt.Errorf("invalid ntfy action URL")
}
parts = append(parts, "view, "+label+", "+view.URL)
}
return strings.Join(parts, "; "), nil
}
func printableASCII(text string) bool {
for i := 0; i < len(text); i++ {
if text[i] < 0x20 || text[i] > 0x7e {
return false
}
}
return true
}