//	sipp                              launch the interactive TUI

//	sipp tui [-r URL] [-k KEY]        launch the interactive TUI

//	sipp auth                         save remote URL + API key to config

//	sipp server [--host H] [--port P] start the web server

//	sipp [-r URL] [-k KEY] <file>     upload a file to a remote sipp server

	"bufio"

	"github.com/stevedylandev/andromeda/apps/sipp-go/tui"

  sipp                              launch interactive TUI

  sipp tui [-r URL] [-k KEY]        launch interactive TUI

  sipp auth                         save remote URL + API key to ~/.config/sipp/config.toml

  SIPP_DB_PATH     local sqlite path for TUI in local mode

	if len(args) == 0 {

		runTUI(nil)

	case "-h", "--help":

		fmt.Print(usage)

	case "tui":

		runTUI(args[1:])

	case "auth":

		runAuth()

func runTUI(args []string) {

	if err := tui.Run(tui.ParseArgs(args)); err != nil {

		fmt.Fprintln(os.Stderr, err)

		os.Exit(1)

	}

}

func runAuth() {

	cfg, _ := tui.LoadConfig()

	in := bufio.NewReader(os.Stdin)

	fmt.Printf("Remote URL [%s]: ", cfg.RemoteURL)

	url, _ := in.ReadString('\n')

	url = strings.TrimSpace(url)

	if url != "" {

		cfg.RemoteURL = url

	}

	masked := ""

	if cfg.APIKey != "" {

		masked = "********"

	}

	fmt.Printf("API key [%s]: ", masked)

	key, _ := in.ReadString('\n')

	key = strings.TrimSpace(key)

	if key != "" {

		cfg.APIKey = key

	}

	if err := tui.SaveConfig(cfg); err != nil {

		fmt.Fprintln(os.Stderr, "save config:", err)

		os.Exit(1)

	}

	path, _ := tui.ConfigPath()

	fmt.Println("saved", path)

}

		cfg, _ := tui.LoadConfig()

		if cfg.RemoteURL != "" {

			remote = cfg.RemoteURL

		}

		if apiKey == "" {

			apiKey = cfg.APIKey

		}

	}

	if remote == "" {

		fmt.Fprintln(os.Stderr, "remote URL not set (use -r, SIPP_REMOTE_URL, or `sipp auth`)")

	github.com/BurntSushi/toml v1.6.0

	github.com/atotto/clipboard v0.1.4

	github.com/charmbracelet/bubbles v1.0.0

	github.com/charmbracelet/bubbletea v1.3.10

	github.com/charmbracelet/lipgloss v1.1.0

	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect

	github.com/charmbracelet/colorprofile v0.4.1 // indirect

	github.com/charmbracelet/x/ansi v0.11.6 // indirect

	github.com/charmbracelet/x/cellbuf v0.0.15 // indirect

	github.com/charmbracelet/x/term v0.2.2 // indirect

	github.com/clipperhouse/displaywidth v0.9.0 // indirect

	github.com/clipperhouse/stringish v0.1.1 // indirect

	github.com/clipperhouse/uax29/v2 v2.5.0 // indirect

	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect

	github.com/lucasb-eyer/go-colorful v1.3.0 // indirect

	github.com/mattn/go-localereader v0.0.1 // indirect

	github.com/mattn/go-runewidth v0.0.19 // indirect

	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect

	github.com/muesli/cancelreader v0.2.2 // indirect

	github.com/muesli/termenv v0.16.0 // indirect

	github.com/rivo/uniseg v0.4.7 // indirect

	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect

	golang.org/x/sys v0.38.0 // indirect

	golang.org/x/text v0.26.0 // indirect

github.com/BurntSushi/toml v1.6.0 h1:dRaEfpa2VI55EwlIW72hMRHdWouJeRF7TPYhI+AUQjk=

github.com/BurntSushi/toml v1.6.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=

github.com/MakeNowJust/heredoc v1.0.0 h1:cXCdzVdstXyiTqTvfqk9SDHpKNjxuom+DOlyEeQ4pzQ=

github.com/MakeNowJust/heredoc v1.0.0/go.mod h1:mG5amYoWBHf8vpLOuehzbGGw0EHxpZZ6lCpQ4fNJ8LE=

github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4=

github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=

github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=

github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=

github.com/aymanbagabas/go-udiff v0.3.1 h1:LV+qyBQ2pqe0u42ZsUEtPiCaUoqgA9gYRDs3vj1nolY=

github.com/aymanbagabas/go-udiff v0.3.1/go.mod h1:G0fsKmG+P6ylD0r6N/KgQD/nWzgfnl8ZBcNLgcbrw8E=

github.com/charmbracelet/bubbles v1.0.0 h1:12J8/ak/uCZEMQ6KU7pcfwceyjLlWsDLAxB5fXonfvc=

github.com/charmbracelet/bubbles v1.0.0/go.mod h1:9d/Zd5GdnauMI5ivUIVisuEm3ave1XwXtD1ckyV6r3E=

github.com/charmbracelet/bubbletea v1.3.10 h1:otUDHWMMzQSB0Pkc87rm691KZ3SWa4KUlvF9nRvCICw=

github.com/charmbracelet/bubbletea v1.3.10/go.mod h1:ORQfo0fk8U+po9VaNvnV95UPWA1BitP1E0N6xJPlHr4=

github.com/charmbracelet/colorprofile v0.4.1 h1:a1lO03qTrSIRaK8c3JRxJDZOvhvIeSco3ej+ngLk1kk=

github.com/charmbracelet/colorprofile v0.4.1/go.mod h1:U1d9Dljmdf9DLegaJ0nGZNJvoXAhayhmidOdcBwAvKk=

github.com/charmbracelet/lipgloss v1.1.0 h1:vYXsiLHVkK7fp74RkV7b2kq9+zDLoEU4MZoFqR/noCY=

github.com/charmbracelet/lipgloss v1.1.0/go.mod h1:/6Q8FR2o+kj8rz4Dq0zQc3vYf7X+B0binUUBwA0aL30=

github.com/charmbracelet/x/ansi v0.11.6 h1:GhV21SiDz/45W9AnV2R61xZMRri5NlLnl6CVF7ihZW8=

github.com/charmbracelet/x/ansi v0.11.6/go.mod h1:2JNYLgQUsyqaiLovhU2Rv/pb8r6ydXKS3NIttu3VGZQ=

github.com/charmbracelet/x/cellbuf v0.0.15 h1:ur3pZy0o6z/R7EylET877CBxaiE1Sp1GMxoFPAIztPI=

github.com/charmbracelet/x/cellbuf v0.0.15/go.mod h1:J1YVbR7MUuEGIFPCaaZ96KDl5NoS0DAWkskup+mOY+Q=

github.com/charmbracelet/x/exp/golden v0.0.0-20241011142426-46044092ad91 h1:payRxjMjKgx2PaCWLZ4p3ro9y97+TVLZNaRZgJwSVDQ=

github.com/charmbracelet/x/exp/golden v0.0.0-20241011142426-46044092ad91/go.mod h1:wDlXFlCrmJ8J+swcL/MnGUuYnqgQdW9rhSD61oNMb6U=

github.com/charmbracelet/x/term v0.2.2 h1:xVRT/S2ZcKdhhOuSP4t5cLi5o+JxklsoEObBSgfgZRk=

github.com/charmbracelet/x/term v0.2.2/go.mod h1:kF8CY5RddLWrsgVwpw4kAa6TESp6EB5y3uxGLeCqzAI=

github.com/clipperhouse/displaywidth v0.9.0 h1:Qb4KOhYwRiN3viMv1v/3cTBlz3AcAZX3+y9OLhMtAtA=

github.com/clipperhouse/displaywidth v0.9.0/go.mod h1:aCAAqTlh4GIVkhQnJpbL0T/WfcrJXHcj8C0yjYcjOZA=

github.com/clipperhouse/stringish v0.1.1 h1:+NSqMOr3GR6k1FdRhhnXrLfztGzuG+VuFDfatpWHKCs=

github.com/clipperhouse/stringish v0.1.1/go.mod h1:v/WhFtE1q0ovMta2+m+UbpZ+2/HEXNWYXQgCt4hdOzA=

github.com/clipperhouse/uax29/v2 v2.5.0 h1:x7T0T4eTHDONxFJsL94uKNKPHrclyFI0lm7+w94cO8U=

github.com/clipperhouse/uax29/v2 v2.5.0/go.mod h1:Wn1g7MK6OoeDT0vL+Q0SQLDz/KpfsVRgg6W7ihQeh4g=

github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6baUTXGLOoWe4PQhGxaX0KpnayAqC48p4=

github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f/go.mod h1:vw97MGsxSvLiUE2X8qFplwetxpGLQrlU1Q9AUEIzCaM=

github.com/lucasb-eyer/go-colorful v1.3.0 h1:2/yBRLdWBZKrf7gB40FoiKfAWYQ0lqNcbuQwVHXptag=

github.com/lucasb-eyer/go-colorful v1.3.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=

github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4=

github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88=

github.com/mattn/go-runewidth v0.0.19 h1:v++JhqYnZuu5jSKrk9RbgF5v4CGUjqRfBm05byFGLdw=

github.com/mattn/go-runewidth v0.0.19/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs=

github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI=

github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6/go.mod h1:CJlz5H+gyd6CUWT45Oy4q24RdLyn7Md9Vj2/ldJBSIo=

github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=

github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=

github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc=

github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk=

github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=

github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=

github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=

github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=

golang.org/x/mod v0.25.0 h1:n7a+ZbQKQA/Ysbyb0/6IbB1H/X41mKgbhfv7AfG/44w=

golang.org/x/mod v0.25.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=

golang.org/x/sync v0.15.0 h1:KWH3jNZsfyT6xfAfKiz6MRNmd46ByHDYaZ7KSkCtdW8=

golang.org/x/sync v0.15.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=

golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

golang.org/x/sys v0.38.0 h1:3yZWxaJjBmCWXqhN1qh02AkOnCQ1poK6oF+a7xWL6Gc=

golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=

golang.org/x/text v0.26.0 h1:P42AVeLghgTYr4+xUnTRKDMqpar+PtX7KWuNQL21L8M=

golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA=

package store

import (

	"database/sql"

	"errors"

	"github.com/stevedylandev/andromeda/crates-go/auth"

	_ "modernc.org/sqlite"

)

type Snippet struct {

	ID      int64  `json:"id"`

	ShortID string `json:"short_id"`

	Content string `json:"content"`

	Name    string `json:"name"`

}

type SnippetInput struct {

	Name    string `json:"name"`

	Content string `json:"content"`

}

const schema = `

CREATE TABLE IF NOT EXISTS snippets (

    id INTEGER PRIMARY KEY AUTOINCREMENT,

    short_id TEXT NOT NULL UNIQUE,

    content TEXT NOT NULL,

    name TEXT NOT NULL

);

`

func Open(path string) (*sql.DB, error) {

	db, err := sql.Open("sqlite", path)

	if err != nil {

		return nil, err

	}

	db.SetMaxOpenConns(1)

	db.SetMaxIdleConns(1)

	if _, err := db.Exec(schema); err != nil {

		return nil, err

	}

	return db, nil

}

func scanSnippet(s interface{ Scan(...any) error }) (*Snippet, error) {

	var sn Snippet

	err := s.Scan(&sn.ID, &sn.ShortID, &sn.Content, &sn.Name)

	if errors.Is(err, sql.ErrNoRows) {

		return nil, nil

	}

	if err != nil {

		return nil, err

	}

	return &sn, nil

}

func Create(db *sql.DB, name, content string) (*Snippet, error) {

	shortID, err := auth.GenerateShortID(10)

	if err != nil {

		return nil, err

	}

	res, err := db.Exec(`INSERT INTO snippets (short_id, content, name) VALUES (?, ?, ?)`, shortID, content, name)

	if err != nil {

		return nil, err

	}

	id, _ := res.LastInsertId()

	return &Snippet{ID: id, ShortID: shortID, Content: content, Name: name}, nil

}

func GetByShortID(db *sql.DB, shortID string) (*Snippet, error) {

	return scanSnippet(db.QueryRow(`SELECT id, short_id, content, name FROM snippets WHERE short_id = ?`, shortID))

}

func List(db *sql.DB) ([]Snippet, error) {

	rows, err := db.Query(`SELECT id, short_id, content, name FROM snippets ORDER BY id DESC`)

	if err != nil {

		return nil, err

	}

	defer rows.Close()

	out := []Snippet{}

	for rows.Next() {

		s, err := scanSnippet(rows)

		if err != nil {

			return nil, err

		}

		out = append(out, *s)

	}

	return out, rows.Err()

}

func DeleteByShortID(db *sql.DB, shortID string) (bool, error) {

	res, err := db.Exec(`DELETE FROM snippets WHERE short_id = ?`, shortID)

	if err != nil {

		return false, err

	}

	n, _ := res.RowsAffected()

	return n > 0, nil

}

func UpdateByShortID(db *sql.DB, shortID, name, content string) (*Snippet, error) {

	res, err := db.Exec(`UPDATE snippets SET name = ?, content = ? WHERE short_id = ?`, name, content, shortID)

	if err != nil {

		return nil, err

	}

	if n, _ := res.RowsAffected(); n == 0 {

		return nil, nil

	}

	return GetByShortID(db, shortID)

}

	"github.com/stevedylandev/andromeda/apps/sipp-go/internal/store"

type Snippet = store.Snippet

var (

	createSnippet         = store.Create

	getSnippetByShortID   = store.GetByShortID

	getAllSnippets        = store.List

	deleteSnippetByShortID = store.DeleteByShortID

	updateSnippetByShortID = store.UpdateByShortID

)

	db, err := store.Open(dbPath)

package tui

import (

	"bytes"

	"database/sql"

	"encoding/json"

	"fmt"

	"io"

	"net/http"

	"os"

	"strings"

	"time"

	"github.com/stevedylandev/andromeda/apps/sipp-go/internal/store"

	"github.com/stevedylandev/andromeda/crates-go/config"

)

type Snippet = store.Snippet

type Backend interface {

	List() ([]Snippet, error)

	Get(shortID string) (*Snippet, error)

	Create(name, content string) (*Snippet, error)

	Update(shortID, name, content string) (*Snippet, error)

	Delete(shortID string) (bool, error)

	RemoteURL() string

	Close() error

}

type LocalBackend struct {

	DB *sql.DB

}

func (b *LocalBackend) List() ([]Snippet, error)                      { return store.List(b.DB) }

func (b *LocalBackend) Get(s string) (*Snippet, error)                { return store.GetByShortID(b.DB, s) }

func (b *LocalBackend) Create(n, c string) (*Snippet, error)          { return store.Create(b.DB, n, c) }

func (b *LocalBackend) Update(s, n, c string) (*Snippet, error)       { return store.UpdateByShortID(b.DB, s, n, c) }

func (b *LocalBackend) Delete(s string) (bool, error)                 { return store.DeleteByShortID(b.DB, s) }

func (b *LocalBackend) RemoteURL() string                             { return "" }

func (b *LocalBackend) Close() error                                  { return b.DB.Close() }

type RemoteBackend struct {

	BaseURL string

	APIKey  string

	Client  *http.Client

}

func (r *RemoteBackend) RemoteURL() string { return r.BaseURL }

func (r *RemoteBackend) Close() error      { return nil }

func (r *RemoteBackend) do(method, path string, body any, out any) error {

	var reader io.Reader

	if body != nil {

		buf, err := json.Marshal(body)

		if err != nil {

			return err

		}

		reader = bytes.NewReader(buf)

	}

	req, err := http.NewRequest(method, strings.TrimRight(r.BaseURL, "/")+path, reader)

	if err != nil {

		return err

	}

	if body != nil {

		req.Header.Set("Content-Type", "application/json")

	}

	if r.APIKey != "" {

		req.Header.Set("x-api-key", r.APIKey)

	}

	resp, err := r.Client.Do(req)

	if err != nil {

		return err

	}

	defer resp.Body.Close()

	if resp.StatusCode == http.StatusNotFound {

		return errNotFound

	}

	if resp.StatusCode >= 400 {

		b, _ := io.ReadAll(resp.Body)

		return fmt.Errorf("%s: %s", resp.Status, strings.TrimSpace(string(b)))

	}

	if out == nil || resp.StatusCode == http.StatusNoContent {

		return nil

	}

	return json.NewDecoder(resp.Body).Decode(out)

}

var errNotFound = fmt.Errorf("not found")

func (r *RemoteBackend) List() ([]Snippet, error) {

	var out []Snippet

	if err := r.do("GET", "/api/snippets", nil, &out); err != nil {

		return nil, err

	}

	return out, nil

}

func (r *RemoteBackend) Get(shortID string) (*Snippet, error) {

	var s Snippet

	if err := r.do("GET", "/api/snippets/"+shortID, nil, &s); err != nil {

		if err == errNotFound {

			return nil, nil

		}

		return nil, err

	}

	return &s, nil

}

func (r *RemoteBackend) Create(name, content string) (*Snippet, error) {

	var s Snippet

	if err := r.do("POST", "/api/snippets", store.SnippetInput{Name: name, Content: content}, &s); err != nil {

		return nil, err

	}

	return &s, nil

}

func (r *RemoteBackend) Update(shortID, name, content string) (*Snippet, error) {

	var s Snippet

	if err := r.do("PUT", "/api/snippets/"+shortID, store.SnippetInput{Name: name, Content: content}, &s); err != nil {

		if err == errNotFound {

			return nil, nil

		}

		return nil, err

	}

	return &s, nil

}

func (r *RemoteBackend) Delete(shortID string) (bool, error) {

	if err := r.do("DELETE", "/api/snippets/"+shortID, nil, nil); err != nil {

		if err == errNotFound {

			return false, nil

		}

		return false, err

	}

	return true, nil

}

type Options struct {

	RemoteURL string

	APIKey    string

	DBPath    string

}

func ParseArgs(args []string) Options {

	opts := Options{}

	for i := 0; i < len(args); i++ {

		a := args[i]

		switch {

		case (a == "--remote" || a == "-r") && i+1 < len(args):

			opts.RemoteURL = args[i+1]

			i++

		case strings.HasPrefix(a, "--remote="):

			opts.RemoteURL = strings.TrimPrefix(a, "--remote=")

		case (a == "--api-key" || a == "-k") && i+1 < len(args):

			opts.APIKey = args[i+1]

			i++

		case strings.HasPrefix(a, "--api-key="):

			opts.APIKey = strings.TrimPrefix(a, "--api-key=")

		case a == "--db" && i+1 < len(args):

			opts.DBPath = args[i+1]

			i++

		}

	}

	return opts

}

func ResolveBackend(opts Options) (Backend, error) {

	cfg, _ := LoadConfig()

	remoteURL := opts.RemoteURL

	if remoteURL == "" {

		remoteURL = os.Getenv("SIPP_REMOTE_URL")

	}

	apiKey := opts.APIKey

	if apiKey == "" {

		apiKey = os.Getenv("SIPP_API_KEY")

	}

	if apiKey == "" {

		apiKey = cfg.APIKey

	}

	dbPath := opts.DBPath

	if dbPath == "" {

		dbPath = config.Getenv("SIPP_DB_PATH", "sipp.sqlite")

	}

	useRemote := remoteURL != ""

	if !useRemote {

		if _, err := os.Stat(dbPath); err != nil && cfg.RemoteURL != "" {

			remoteURL = cfg.RemoteURL

			useRemote = true

		}

	}

	if useRemote {

		return &RemoteBackend{

			BaseURL: remoteURL,

			APIKey:  apiKey,

			Client:  &http.Client{Timeout: 15 * time.Second},

		}, nil

	}

	db, err := store.Open(dbPath)

	if err != nil {

		return nil, err

	}

	return &LocalBackend{DB: db}, nil

}

package tui

import (

	"os"

	"path/filepath"

	"github.com/BurntSushi/toml"

)

type Config struct {

	RemoteURL string `toml:"remote_url"`

	APIKey    string `toml:"api_key"`

}

func ConfigPath() (string, error) {

	dir, err := os.UserConfigDir()

	if err != nil {

		return "", err

	}

	return filepath.Join(dir, "sipp", "config.toml"), nil

}

func LoadConfig() (Config, error) {

	var cfg Config

	path, err := ConfigPath()

	if err != nil {

		return cfg, err

	}

	data, err := os.ReadFile(path)

	if err != nil {

		if os.IsNotExist(err) {

			return cfg, nil

		}

		return cfg, err

	}

	if err := toml.Unmarshal(data, &cfg); err != nil {

		return cfg, err

	}

	return cfg, nil

}

func SaveConfig(cfg Config) error {

	path, err := ConfigPath()

	if err != nil {

		return err

	}

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

		return err

	}

	f, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o600)

	if err != nil {

		return err

	}

	defer f.Close()

	return toml.NewEncoder(f).Encode(cfg)

}

package tui

import (

	"fmt"

	"os"

	"os/exec"

	"path/filepath"

	"runtime"

	tea "github.com/charmbracelet/bubbletea"

)

func openExternalEditor(shortID, name, content string) tea.Cmd {

	editor := os.Getenv("EDITOR")

	if editor == "" {

		return func() tea.Msg {

			return statusMsg{text: "$EDITOR not set", ok: false}

		}

	}

	base := name

	if base == "" {

		base = "snippet.txt"

	}

	tmp := filepath.Join(os.TempDir(), fmt.Sprintf("sipp-%s-%s", shortID, filepath.Base(base)))

	if err := os.WriteFile(tmp, []byte(content), 0o600); err != nil {

		return func() tea.Msg {

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

		}

	}

	cmd := exec.Command(editor, tmp)

	return tea.ExecProcess(cmd, func(err error) tea.Msg {

		defer os.Remove(tmp)

		if err != nil {

			return editorFinishedMsg{shortID: shortID, err: err}

		}

		b, rerr := os.ReadFile(tmp)

		if rerr != nil {

			return editorFinishedMsg{shortID: shortID, err: rerr}

		}

		return editorFinishedMsg{shortID: shortID, content: string(b)}

	})

}

func openURL(url string) error {

	var cmd *exec.Cmd

	switch runtime.GOOS {

	case "linux":

		cmd = exec.Command("xdg-open", url)

	case "darwin":

		cmd = exec.Command("open", url)

	case "windows":

		cmd = exec.Command("rundll32", "url.dll,FileProtocolHandler", url)

	default:

		return fmt.Errorf("unsupported platform %s", runtime.GOOS)

	}

	return cmd.Start()

}

package tui

import (

	"bytes"

	"strings"

	"github.com/alecthomas/chroma/v2"

	"github.com/alecthomas/chroma/v2/formatters"

	"github.com/alecthomas/chroma/v2/lexers"

	"github.com/alecthomas/chroma/v2/styles"

)

type highlighter struct {

	cache map[string]string

}

func newHighlighter() *highlighter {

	return &highlighter{cache: map[string]string{}}

}

func (h *highlighter) render(shortID, name, content string) string {

	if v, ok := h.cache[shortID]; ok {

		return v

	}

	out := highlightCode(name, content)

	h.cache[shortID] = out

	return out

}

func (h *highlighter) invalidate(shortID string) {

	delete(h.cache, shortID)

}

func highlightCode(name, content string) string {

	var lexer chroma.Lexer

	if name != "" {

		lexer = lexers.Match(name)

	}

	if lexer == nil {

		lexer = lexers.Analyse(content)

	}

	if lexer == nil {

		lexer = lexers.Fallback

	}

	style := styles.Get("monokai")

	if style == nil {

		style = styles.Fallback

	}

	formatter := formatters.Get("terminal256")

	if formatter == nil {

		formatter = formatters.Fallback

	}

	iter, err := lexer.Tokenise(nil, content)

	if err != nil {

		return content

	}

	var buf bytes.Buffer

	if err := formatter.Format(&buf, style, iter); err != nil {

		return content

	}

	return strings.TrimRight(buf.String(), "\n")

}

package tui

import "github.com/charmbracelet/bubbles/key"

type keyMap struct {

	Up          key.Binding

	Down        key.Binding

	Open        key.Binding

	Back        key.Binding

	Quit        key.Binding

	Create      key.Binding

	Edit        key.Binding

	ExtEdit     key.Binding

	Delete      key.Binding

	Copy        key.Binding

	CopyLink    key.Binding

	OpenBrowser key.Binding

	Search      key.Binding

	Refresh     key.Binding

	Help        key.Binding

	Save        key.Binding

	SwitchField key.Binding

	Cancel      key.Binding

}

func defaultKeys() keyMap {

	return keyMap{

		Up:          key.NewBinding(key.WithKeys("up", "k"), key.WithHelp("↑/k", "up")),

		Down:        key.NewBinding(key.WithKeys("down", "j"), key.WithHelp("↓/j", "down")),

		Open:        key.NewBinding(key.WithKeys("enter", "l"), key.WithHelp("⏎/l", "open")),

		Back:        key.NewBinding(key.WithKeys("h", "esc"), key.WithHelp("h/esc", "back")),

		Quit:        key.NewBinding(key.WithKeys("q"), key.WithHelp("q", "quit")),

		Create:      key.NewBinding(key.WithKeys("c"), key.WithHelp("c", "create")),

		Edit:        key.NewBinding(key.WithKeys("e"), key.WithHelp("e", "edit")),

		ExtEdit:     key.NewBinding(key.WithKeys("E"), key.WithHelp("E", "$EDITOR")),

		Delete:      key.NewBinding(key.WithKeys("d"), key.WithHelp("d", "delete")),

		Copy:        key.NewBinding(key.WithKeys("y"), key.WithHelp("y", "copy text")),

		CopyLink:    key.NewBinding(key.WithKeys("Y"), key.WithHelp("Y", "copy link")),

		OpenBrowser: key.NewBinding(key.WithKeys("o"), key.WithHelp("o", "browser")),

		Search:      key.NewBinding(key.WithKeys("/"), key.WithHelp("/", "search")),

		Refresh:     key.NewBinding(key.WithKeys("r"), key.WithHelp("r", "refresh")),

		Help:        key.NewBinding(key.WithKeys("?"), key.WithHelp("?", "help")),

		Save:        key.NewBinding(key.WithKeys("ctrl+s"), key.WithHelp("⌃s", "save")),

		SwitchField: key.NewBinding(key.WithKeys("tab"), key.WithHelp("⇥", "switch field")),

		Cancel:      key.NewBinding(key.WithKeys("esc"), key.WithHelp("esc", "cancel")),

	}

}

func (k keyMap) ShortHelp() []key.Binding {

	return []key.Binding{k.Open, k.Create, k.Edit, k.Delete, k.Search, k.Help, k.Quit}

}

func (k keyMap) FullHelp() [][]key.Binding {

	return [][]key.Binding{

		{k.Up, k.Down, k.Open, k.Back},

		{k.Create, k.Edit, k.ExtEdit, k.Delete},

		{k.Copy, k.CopyLink, k.OpenBrowser, k.Search},

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

		{k.Cancel, k.Quit},

	}

}

package tui

type snippetsLoadedMsg struct {

	snippets []Snippet

	err      error

}

type snippetSavedMsg struct {

	snippet *Snippet

	err     error

}

type snippetDeletedMsg struct {

	shortID string

	err     error

}

type editorFinishedMsg struct {

	shortID string

	content string

	err     error

}

type statusMsg struct {

	text string

	ok   bool

}

type clearStatusMsg struct{}

package tui

import (

	"strings"

	"time"

	"github.com/charmbracelet/bubbles/help"

	"github.com/charmbracelet/bubbles/textarea"

	"github.com/charmbracelet/bubbles/textinput"

	"github.com/charmbracelet/bubbles/viewport"

	tea "github.com/charmbracelet/bubbletea"

)

type Focus int

const (

	FocusList Focus = iota

	FocusContent

	FocusCreateName

	FocusCreateContent

	FocusEditName

	FocusEditContent

	FocusSearch

)

type Model struct {

	backend  Backend

	isRemote bool

	snippets []Snippet

	filtered []int

	cursor   int

	focus         Focus

	showHelp      bool

	confirmDelete bool

	nameInput   textinput.Model

	contentArea textarea.Model

	searchInput textinput.Model

	contentVP   viewport.Model

	help        help.Model

	keys        keyMap

	highlighter *highlighter

	editShortID string

	status      string

	statusOK    bool

	statusUntil time.Time

	width, height int

	ready         bool

	loading       bool

}

func newModel(backend Backend) Model {

	ti := textinput.New()

	ti.Placeholder = "name.ext"

	ti.Prompt = ""

	ti.CharLimit = 200

	ta := textarea.New()

	ta.Placeholder = "Paste code..."

	ta.ShowLineNumbers = true

	ta.Prompt = ""

	si := textinput.New()

	si.Placeholder = "search names"

	si.Prompt = "/ "

	vp := viewport.New(0, 0)

	return Model{

		backend:     backend,

		isRemote:    backend.RemoteURL() != "",

		focus:       FocusList,

		nameInput:   ti,

		contentArea: ta,

		searchInput: si,

		contentVP:   vp,

		help:        help.New(),

		keys:        defaultKeys(),

		highlighter: newHighlighter(),

	}

}

func (m Model) Init() tea.Cmd {

	return loadSnippetsCmd(m.backend)

}

func (m *Model) visible() []Snippet {

	if m.filtered == nil {

		return m.snippets

	}

	out := make([]Snippet, 0, len(m.filtered))

	for _, i := range m.filtered {

		out = append(out, m.snippets[i])

	}

	return out

}

func (m *Model) current() *Snippet {

	list := m.visible()

	if m.cursor < 0 || m.cursor >= len(list) {

		return nil

	}

	return &list[m.cursor]

}

func (m *Model) applyFilter(q string) {

	q = strings.TrimSpace(strings.ToLower(q))

	if q == "" {

		m.filtered = nil

		if m.cursor >= len(m.snippets) {

			m.cursor = 0

		}

		return

	}

	idx := []int{}

	for i, s := range m.snippets {

		if strings.Contains(strings.ToLower(s.Name), q) || strings.Contains(strings.ToLower(s.ShortID), q) {

			idx = append(idx, i)

		}

	}

	m.filtered = idx

	if m.cursor >= len(idx) {

		m.cursor = 0

	}

}

func (m *Model) setStatus(text string, ok bool) tea.Cmd {

	m.status = text

	m.statusOK = ok

	m.statusUntil = time.Now().Add(2 * time.Second)

	return tea.Tick(2*time.Second, func(time.Time) tea.Msg { return clearStatusMsg{} })

}

func (m *Model) shareURL(shortID string) string {

	if m.backend.RemoteURL() == "" {

		return ""

	}

	return strings.TrimRight(m.backend.RemoteURL(), "/") + "/s/" + shortID

}

package tui

import (

	tea "github.com/charmbracelet/bubbletea"

)

func Run(opts Options) error {

	backend, err := ResolveBackend(opts)

	if err != nil {

		return err

	}

	defer backend.Close()

	p := tea.NewProgram(newModel(backend), tea.WithAltScreen())

	_, err = p.Run()

	return err

}

package tui

import (

	"strings"

	"github.com/atotto/clipboard"

	"github.com/charmbracelet/bubbles/key"

	tea "github.com/charmbracelet/bubbletea"

)

func loadSnippetsCmd(b Backend) tea.Cmd {

	return func() tea.Msg {

		list, err := b.List()

		return snippetsLoadedMsg{snippets: list, err: err}

	}

}

func saveSnippetCmd(b Backend, shortID, name, content string) tea.Cmd {

	return func() tea.Msg {

		var (

			s   *Snippet

			err error

		)

		if shortID == "" {

			s, err = b.Create(name, content)

		} else {

			s, err = b.Update(shortID, name, content)

		}

		return snippetSavedMsg{snippet: s, err: err}

	}

}

func deleteSnippetCmd(b Backend, shortID string) tea.Cmd {

	return func() tea.Msg {

		_, err := b.Delete(shortID)

		return snippetDeletedMsg{shortID: shortID, err: err}

	}

}

func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {

	switch msg := msg.(type) {

	case tea.WindowSizeMsg:

		m.width, m.height = msg.Width, msg.Height

		m.ready = true

		m.resizePanes()

		return m, nil

	case snippetsLoadedMsg:

		m.loading = false

		if msg.err != nil {

			return m, m.setStatus("load: "+msg.err.Error(), false)

		}

		m.snippets = msg.snippets

		m.applyFilter(m.searchInput.Value())

		m.refreshPreview()

		return m, nil

	case snippetSavedMsg:

		if msg.err != nil {

			return m, m.setStatus("save: "+msg.err.Error(), false)

		}

		if msg.snippet != nil && m.highlighter != nil {

			m.highlighter.invalidate(msg.snippet.ShortID)

		}

		m.focus = FocusList

		m.nameInput.Reset()

		m.contentArea.Reset()

		m.editShortID = ""

		return m, tea.Batch(loadSnippetsCmd(m.backend), m.setStatus("saved", true))

	case snippetDeletedMsg:

		if msg.err != nil {

			return m, m.setStatus("delete: "+msg.err.Error(), false)

		}

		if m.highlighter != nil {

			m.highlighter.invalidate(msg.shortID)

		}

		return m, tea.Batch(loadSnippetsCmd(m.backend), m.setStatus("deleted", true))

	case editorFinishedMsg:

		if msg.err != nil {

			return m, m.setStatus("editor: "+msg.err.Error(), false)

		}

		if msg.shortID == "" {

			m.contentArea.SetValue(msg.content)

			return m, nil

		}

		var orig *Snippet

		for i := range m.snippets {

			if m.snippets[i].ShortID == msg.shortID {

				orig = &m.snippets[i]

				break

			}

		}

		if orig == nil || strings.TrimRight(orig.Content, "\n") == strings.TrimRight(msg.content, "\n") {

			return m, nil

		}

		return m, saveSnippetCmd(m.backend, msg.shortID, orig.Name, msg.content)

	case statusMsg:

		return m, m.setStatus(msg.text, msg.ok)

	case clearStatusMsg:

		m.status = ""

		return m, nil

	case tea.KeyMsg:

		return m.handleKey(msg)

	}

	return m, nil

}

func (m *Model) resizePanes() {

	if !m.ready {

		return

	}

	listW := m.width * 30 / 100

	if listW < 24 {

		listW = 24

	}

	contentW := m.width - listW - 2

	if contentW < 20 {

		contentW = 20

	}

	bodyH := m.height - 2

	if bodyH < 5 {

		bodyH = 5

	}

	m.contentVP.Width = contentW - 2

	m.contentVP.Height = bodyH - 2

	m.nameInput.Width = contentW - 4

	m.contentArea.SetWidth(contentW - 2)

	m.contentArea.SetHeight(bodyH - 5)

	m.searchInput.Width = listW - 4

	m.refreshPreview()

}

func (m *Model) refreshPreview() {

	s := m.current()

	if s == nil {

		m.contentVP.SetContent("")

		return

	}

	body := s.Content

	if m.highlighter != nil {

		body = m.highlighter.render(s.ShortID, s.Name, s.Content)

	}

	m.contentVP.SetContent(body)

}

func (m Model) handleKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {

	if msg.String() == "ctrl+c" {

		return m, tea.Quit

	}