- Bubble Tea/Lip Gloss/Glamour for the TUI editor

- `github.com/pkg/browser` and `github.com/atotto/clipboard` for TUI browser/copy actions

	github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c // indirect

github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ=

github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU=

golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

package tui

import "github.com/pkg/browser"

func openURL(url string) error {

	return browser.OpenURL(url)

}

	tmp, err := os.CreateTemp("", "jotts-*.md")

	if err != nil {

		return func() tea.Msg {

			return statusMsg{text: "tempfile: " + err.Error(), ok: false}

		}

	}

	path := tmp.Name()

	if _, err := tmp.WriteString(content); err != nil {

		_ = tmp.Close()

		_ = os.Remove(path)

	_ = tmp.Close()

	cmd := exec.Command(editor, path)

		defer os.Remove(path)

		b, rerr := os.ReadFile(path)

# Optional Cloudflare R2 storage for uploads. Leave R2_BUCKET empty for local files.

R2_ACCOUNT_ID=

R2_ACCESS_KEY_ID=

R2_SECRET_ACCESS_KEY=

R2_BUCKET=

R2_PUBLIC_URL=

- Upload storage supports local filesystem (`UPLOADS_DIR`, default `uploads`)

  or Cloudflare R2 when `R2_BUCKET` and credentials are set.

	poststorage "github.com/stevedylandev/andromeda/apps/posts-go/storage"

	Storage      poststorage.Backend

	BlogTitle  string

	NavLinks   []NavLink

	FaviconURL string

	OGImageURL string

	SiteURL    string

	HeaderHTML template.HTML

	FooterHTML template.HTML

func createFile(db *sql.DB, filename, originalName, contentType string, size int64, backend string) (*UploadedFile, error) {

	}

	if backend == "" {

		backend = "local"

		`INSERT INTO files (short_id, filename, original_name, content_type, size, storage_backend) VALUES (?, ?, ?, ?, ?, ?)`,

		shortID, filename, originalName, contentType, size, backend)

	github.com/aws/aws-sdk-go-v2 v1.41.7 // indirect

	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.10 // indirect

	github.com/aws/aws-sdk-go-v2/credentials v1.19.16 // indirect

	github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.23 // indirect

	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.23 // indirect

	github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.24 // indirect

	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.9 // indirect

	github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.9.15 // indirect

	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.23 // indirect

	github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.23 // indirect

	github.com/aws/aws-sdk-go-v2/service/s3 v1.101.0 // indirect

	github.com/aws/smithy-go v1.25.1 // indirect

github.com/aws/aws-sdk-go-v2 v1.41.7 h1:DWpAJt66FmnnaRIOT/8ASTucrvuDPZASqhhLey6tLY8=

github.com/aws/aws-sdk-go-v2 v1.41.7/go.mod h1:4LAfZOPHNVNQEckOACQx60Y8pSRjIkNZQz1w92xpMJc=

github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.10 h1:gx1AwW1Iyk9Z9dD9F4akX5gnN3QZwUB20GGKH/I+Rho=

github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.10/go.mod h1:qqY157uZoqm5OXq/amuaBJyC9hgBCBQnsaWnPe905GY=

github.com/aws/aws-sdk-go-v2/credentials v1.19.16 h1:r3RJBuU7X9ibt8RHbMjWE6y60QbKBiII6wSrXnapxSU=

github.com/aws/aws-sdk-go-v2/credentials v1.19.16/go.mod h1:6cx7zqDENJDbBIIWX6P8s0h6hqHC8Avbjh9Dseo27ug=

github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.23 h1:GpT/TrnBYuE5gan2cZbTtvP+JlHsutdmlV2YfEyNde0=

github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.23/go.mod h1:xYWD6BS9ywC5bS3sz9Xh04whO/hzK2plt2Zkyrp4JuA=

github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.23 h1:bpd8vxhlQi2r1hiueOw02f/duEPTMK59Q4QMAoTTtTo=

github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.23/go.mod h1:15DfR2nw+CRHIk0tqNyifu3G1YdAOy68RftkhMDDwYk=

github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.24 h1:OQqn11BtaYv1WLUowvcA30MpzIu8Ti4pcLPIIyoKZrA=

github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.24/go.mod h1:X5ZJyfwVrWA96GzPmUCWFQaEARPR7gCrpq2E92PJwAE=

github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.9 h1:FLudkZLt5ci0ozzgkVo8BJGwvqNaZbTWb3UcucAateA=

github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.9/go.mod h1:w7wZ/s9qK7c8g4al+UyoF1Sp/Z45UwMGcqIzLWVQHWk=

github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.9.15 h1:ieLCO1JxUWuxTZ1cRd0GAaeX7O6cIxnwk7tc1LsQhC4=

github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.9.15/go.mod h1:e3IzZvQ3kAWNykvE0Tr0RDZCMFInMvhku3qNpcIQXhM=

github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.23 h1:pbrxO/kuIwgEsOPLkaHu0O+m4fNgLU8B3vxQ+72jTPw=

github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.23/go.mod h1:/CMNUqoj46HpS3MNRDEDIwcgEnrtZlKRaHNaHxIFpNA=

github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.23 h1:03xatSQO4+AM1lTAbnRg5OK528EUg744nW7F73U8DKw=

github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.23/go.mod h1:M8l3mwgx5ToK7wot2sBBce/ojzgnPzZXUV445gTSyE8=

github.com/aws/aws-sdk-go-v2/service/s3 v1.101.0 h1:etqBTKY581iwLL/H/S2sVgk3C9lAsTJFeXWFDsDcWOU=

github.com/aws/aws-sdk-go-v2/service/s3 v1.101.0/go.mod h1:L2dcoOgS2VSgbPLvpak2NyUPsO1TBN7M45Z4H7DlRc4=

github.com/aws/smithy-go v1.25.1 h1:J8ERsGSU7d+aCmdQur5Txg6bVoYelvQJgtZehD12GkI=

github.com/aws/smithy-go v1.25.1/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc=

	backend := a.Storage

	if backend == nil {

		http.Redirect(w, r, "/admin/files?error=Storage+not+configured", http.StatusSeeOther)

	if err := backend.Put(r.Context(), stored, contentType, data); err != nil {

		a.Log.Error("save file", "backend", backend.Name(), "err", err)

	if _, err := createFile(a.DB, stored, originalName, contentType, int64(len(data)), backend.Name()); err != nil {

		_ = backend.Delete(r.Context(), stored)

	if file.StorageBackend == "r2" && a.Storage != nil && a.Storage.Name() == "r2" {

		_ = a.Storage.Delete(r.Context(), file.Filename)

	} else {

		_ = removeFile(joinPath(a.UploadsDir, file.Filename))

	}

	f, _ := getFileByFilename(a.DB, filename)

	if f != nil && f.StorageBackend == "r2" {

		if a.Storage != nil && a.Storage.Name() == "r2" {

			if u := a.Storage.PublicURL(filename); u != "" {

				http.Redirect(w, r, u, http.StatusTemporaryRedirect)

				return

			}

		}

		http.NotFound(w, r)

		return

	}

	if f != nil && f.ContentType != "" {

	poststorage "github.com/stevedylandev/andromeda/apps/posts-go/storage"

	storageBackend := poststorage.Backend(poststorage.NewLocal(uploadsDir))

	if os.Getenv("R2_BUCKET") != "" {

		r2, err := poststorage.NewR2(

			os.Getenv("R2_ACCOUNT_ID"),

			os.Getenv("R2_ACCESS_KEY_ID"),

			os.Getenv("R2_SECRET_ACCESS_KEY"),

			os.Getenv("R2_BUCKET"),

			os.Getenv("R2_PUBLIC_URL"),

		)

		if err != nil {

			log.Fatalf("configure r2: %v", err)

		}

		storageBackend = r2

		logger.Info("using R2 storage backend", "bucket", os.Getenv("R2_BUCKET"))

	} else {

		logger.Info("using local storage backend", "dir", uploadsDir)

	}

		Storage:      storageBackend,

package storage

import "context"

type Backend interface {

	Put(ctx context.Context, key, contentType string, data []byte) error

	Delete(ctx context.Context, key string) error

	PublicURL(key string) string

	Name() string

}

package storage

import (

	"context"

	"os"

	"path/filepath"

)

type Local struct {

	Dir string

}

func NewLocal(dir string) *Local { return &Local{Dir: dir} }

func (l *Local) Put(ctx context.Context, key, contentType string, data []byte) error {

	select {

	case <-ctx.Done():

		return ctx.Err()

	default:

	}

	if err := os.MkdirAll(l.Dir, 0o755); err != nil {

		return err

	}

	return os.WriteFile(filepath.Join(l.Dir, key), data, 0o644)

}

func (l *Local) Delete(ctx context.Context, key string) error {

	select {

	case <-ctx.Done():

		return ctx.Err()

	default:

	}

	err := os.Remove(filepath.Join(l.Dir, key))

	if os.IsNotExist(err) {

		return nil

	}

	return err

}

func (l *Local) PublicURL(key string) string { return "/uploads/" + key }

func (l *Local) Name() string                { return "local" }

package storage

import (

	"bytes"

	"context"

	"fmt"

	"net/url"

	"strings"

	"github.com/aws/aws-sdk-go-v2/aws"

	"github.com/aws/aws-sdk-go-v2/credentials"

	"github.com/aws/aws-sdk-go-v2/service/s3"

)

type R2 struct {

	bucket    string

	publicURL string

	client    *s3.Client

}

func NewR2(accountID, accessKeyID, secretAccessKey, bucket, publicURL string) (*R2, error) {

	if strings.TrimSpace(accountID) == "" || strings.TrimSpace(accessKeyID) == "" || strings.TrimSpace(secretAccessKey) == "" || strings.TrimSpace(bucket) == "" || strings.TrimSpace(publicURL) == "" {

		return nil, fmt.Errorf("R2_ACCOUNT_ID, R2_ACCESS_KEY_ID, R2_SECRET_ACCESS_KEY, R2_BUCKET, and R2_PUBLIC_URL are required")

	}

	endpoint := "https://" + accountID + ".r2.cloudflarestorage.com"

	cfg := aws.Config{

		Region:      "auto",

		Credentials: credentials.NewStaticCredentialsProvider(accessKeyID, secretAccessKey, ""),

	}

	client := s3.NewFromConfig(cfg, func(o *s3.Options) {

		o.BaseEndpoint = aws.String(endpoint)

		o.UsePathStyle = true

	})

	return &R2{bucket: bucket, publicURL: strings.TrimRight(publicURL, "/"), client: client}, nil

}

func (r *R2) Put(ctx context.Context, key, contentType string, data []byte) error {

	_, err := r.client.PutObject(ctx, &s3.PutObjectInput{

		Bucket:      aws.String(r.bucket),

		Key:         aws.String(key),

		Body:        bytes.NewReader(data),

		ContentType: aws.String(contentType),

	})

	return err

}

func (r *R2) Delete(ctx context.Context, key string) error {

	_, err := r.client.DeleteObject(ctx, &s3.DeleteObjectInput{Bucket: aws.String(r.bucket), Key: aws.String(key)})

	return err

}

func (r *R2) PublicURL(key string) string {

	if r.publicURL == "" {

		return ""

	}

	return r.publicURL + "/" + url.PathEscape(key)

}

func (r *R2) Name() string { return "r2" }

JPEG EXIF metadata is preserved after recompression, with GPS data stripped to

match the Rust implementation. The 20 MB upload limit is preserved.

package main

import "encoding/binary"

const exifPrefix = "Exif\x00\x00"

func extractExif(orig []byte) []byte {

	if len(orig) < 4 || orig[0] != 0xff || orig[1] != 0xd8 {

		return nil

	}

	pos := 2

	for pos+4 <= len(orig) {

		if orig[pos] != 0xff {

			return nil

		}

		marker := orig[pos+1]

		pos += 2

		if marker == 0xda || marker == 0xd9 { // SOS or EOI

			return nil

		}

		if marker >= 0xd0 && marker <= 0xd7 { // restart markers have no length

			continue

		}

		if pos+2 > len(orig) {

			return nil

		}

		segLen := int(binary.BigEndian.Uint16(orig[pos : pos+2]))

		if segLen < 2 || pos+segLen > len(orig) {

			return nil

		}

		payload := orig[pos+2 : pos+segLen]

		if marker == 0xe1 && len(payload) >= len(exifPrefix) && string(payload[:len(exifPrefix)]) == exifPrefix {

			exif := make([]byte, len(payload)-len(exifPrefix))

			copy(exif, payload[len(exifPrefix):])

			return exif

		}

		pos += segLen

	}

	return nil

}

func stripGPS(exif []byte) []byte {

	if len(exif) < 8 {

		return exif

	}

	out := make([]byte, len(exif))

	copy(out, exif)

	var order binary.ByteOrder

	switch string(out[:2]) {

	case "II":

		order = binary.LittleEndian

	case "MM":

		order = binary.BigEndian

	default:

		return out

	}

	if order.Uint16(out[2:4]) != 42 {

		return out

	}

	ifd0 := int(order.Uint32(out[4:8]))

	if ifd0 < 0 || ifd0+2 > len(out) {

		return out

	}

	count := int(order.Uint16(out[ifd0 : ifd0+2]))

	entries := ifd0 + 2

	for i := 0; i < count; i++ {

		entry := entries + i*12

		if entry+12 > len(out) {

			return out

		}

		tag := order.Uint16(out[entry : entry+2])

		if tag == 0x8825 { // GPSInfo IFDPointer

			gpsOffset := int(order.Uint32(out[entry+8 : entry+12]))

			if gpsOffset >= 0 && gpsOffset+2 <= len(out) {

				order.PutUint16(out[gpsOffset:gpsOffset+2], 0)

			}

			return out

		}

	}

	return out

}

func injectExif(jpegBytes, exif []byte) []byte {

	if len(exif) == 0 || len(jpegBytes) < 2 || jpegBytes[0] != 0xff || jpegBytes[1] != 0xd8 {

		return jpegBytes

	}

	payloadLen := len(exifPrefix) + len(exif)

	segLen := payloadLen + 2

	if segLen > 0xffff {

		return jpegBytes

	}

	out := make([]byte, 0, len(jpegBytes)+segLen+2)

	out = append(out, jpegBytes[:2]...)

	out = append(out, 0xff, 0xe1, byte(segLen>>8), byte(segLen))

	out = append(out, exifPrefix...)

	out = append(out, exif...)

	out = append(out, jpegBytes[2:]...)

	return out

}

	exif := stripGPS(extractExif(data))

	return injectExif(out.Bytes(), exif), nil

	WrapToggle  key.Binding

		WrapToggle:  key.NewBinding(key.WithKeys("ctrl+w"), key.WithHelp("⌃w", "wrap")),

		{k.Refresh, k.WrapToggle, k.Help, k.Save, k.SwitchField},

	wrapContent   bool

	"github.com/charmbracelet/lipgloss"

	if m.wrapContent {

		m.contentArea.SetWidth(contentW - 2)

	} else {

		m.contentArea.SetWidth(10000)

	}

	if m.wrapContent && m.contentVP.Width > 0 {

		body = lipgloss.NewStyle().Width(m.contentVP.Width).Render(body)

	}

	case key.Matches(msg, m.keys.WrapToggle):

		m.wrapContent = !m.wrapContent

		m.contentVP.GotoTop()

		m.refreshPreview()

		if m.wrapContent {

			return m, m.setStatus("wrap on", true)

		}

		return m, m.setStatus("wrap off", true)

	case key.Matches(msg, m.keys.WrapToggle):

		m.wrapContent = !m.wrapContent

		if m.wrapContent {

			m.contentArea.SetWidth(m.contentVP.Width)

			return m, m.setStatus("wrap on", true)

		}

		m.contentArea.SetWidth(10000)

		return m, m.setStatus("wrap off", true)

	if m.wrapContent {

		header += " (wrap)"

	}

	}

	if m.wrapContent {

		header += " (wrap)"