ui

type BatchFinishedMsg ¶

type BatchFinishedMsg struct {
	Done    int
	Failed  int
	Skipped int
	Aborted int
}

BatchFinishedMsg signals all items have run; render the final summary frame and auto-quit.

type BatchItemBeginMsg ¶

type BatchItemBeginMsg struct {
	Index    int // 0-based index into the batch
	URL      string
	FileName string
}

BatchItemBeginMsg signals the start of a new item inside a persistent batch TUI program. The model resets per-item state but keeps the SAN cabinet, history, and program alive (no alt-screen toggling).

type BatchItemEndMsg ¶

type BatchItemEndMsg struct {
	Index  int
	Status BatchItemStatus
	Reason string
}

BatchItemEndMsg signals an item finished (success / fail / skip / abort). Updates the SAN bay status without quitting the program.

type BatchItemResult ¶

type BatchItemResult struct {
	Status BatchItemStatus
	Reason string
}

type BatchItemSnapshot ¶

type BatchItemSnapshot struct {
	Label  string
	Status BatchItemStatus
}

type BatchItemStatus ¶

type BatchItemStatus int

const (
	BatchItemQueued BatchItemStatus = iota
	BatchItemDone
	BatchItemSkipped
	BatchItemFailed
	BatchItemAborted
)

type BatchRunOptions ¶

type BatchRunOptions struct {
	Ctx           context.Context
	NumConns      int
	WillVerify    bool
	Items         []BatchItemSnapshot
	URLs          []string
	OnQuit        func()
	OnSkipCurrent func()
}

BatchRunOptions configures a persistent batch TUI session.

type BatchSummary ¶

type BatchSummary struct {
	Done    int
	Failed  int
	Skipped int
	Aborted int
}

BatchSummary aggregates the tally over the whole batch.

func RunBatch(opts BatchRunOptions, runItem func(idx int) BatchItemResult) (BatchSummary, error)

type CassetteItem ¶

type CassetteItem struct {
	URL        string
	Title      string        // resolved from yt-dlp metadata; empty until probed
	Channel    string        // populates the channel-tint sticker chip
	Duration   time.Duration // 00:00 until probed
	Resolution string        // "1080p60" — only on lush tier
	Status     CassetteStatus
	Err        string // populated on failure for the end-of-batch summary
}

CassetteItem is one row of the shelf — everything renderable about a single URL in the batch. Field renames cascade nowhere: the shelf is the only consumer.

type CassetteShelf ¶

type CassetteShelf struct {
	// contains filtered or unexported fields
}

CassetteShelf is the widget. Built once at batch start, mutated via the setter methods below as the orchestrator advances.

func NewCassetteShelf(urls []string) *CassetteShelf

func (s *CassetteShelf) Items() []CassetteItem

func (s *CassetteShelf) Len() int

func (s *CassetteShelf) SetActive(i int)

func (s *CassetteShelf) SetMeta(i int, title, channel, resolution string, dur time.Duration)

func (s *CassetteShelf) SetStatus(i int, st CassetteStatus, errMsg string)

func (s *CassetteShelf) Tick()

func (s *CassetteShelf) View(termWidth int) string

type CassetteStatus ¶

type CassetteStatus int

CassetteStatus is the lifecycle state of one tape on the shelf.

const (
	CassetteQueued CassetteStatus = iota
	CassetteProbing
	CassetteReady // probe done, waiting for the deck to swing to it
	CassetteLoading
	CassettePlaying
	CassetteMuxing
	CassetteDone
	CassetteSkipped
	CassetteFailed
)

type Console ¶

type Console struct {
	Stdout io.Writer
	Stderr io.Writer
}

Console is the non-TUI implementation of UI.

func (c Console) Errorf(format string, a ...any) (n int, err error)

func (c Console) Errorln(a ...any) (n int, err error)

func (c Console) Printf(format string, a ...any) (n int, err error)

func (c Console) Println(a ...any) (n int, err error)

type DownloadDoneMsg ¶

type DownloadDoneMsg struct{}

DownloadDoneMsg signals the entire pipeline (download + join + optional verify) finished.

type DownloadErrorMsg ¶

type DownloadErrorMsg struct{ Err error }

DownloadErrorMsg signals a fatal download error.

type DownloadStartMsg ¶

type DownloadStartMsg struct {
	URL      string
	FileName string
	Size     int64
	NumParts int
	IPs      []string
}

DownloadStartMsg is sent once download metadata is known.

type ExtractorDoneMsg ¶

type ExtractorDoneMsg struct{}

ExtractorDoneMsg signals success — auto-quit countdown begins.

type ExtractorErrorMsg ¶

type ExtractorErrorMsg struct{ Err error }

ExtractorErrorMsg signals a fatal error in the extractor pipeline.

type ExtractorFormat ¶

type ExtractorFormat struct {
	ID         string
	Ext        string
	Resolution string
	Height     int
	FPS        float64
	VCodec     string
	ACodec     string
	TBR        float64
	ABR        float64
	Filesize   int64
	Note       string
	HasVideo   bool
	HasAudio   bool
}

ExtractorFormat mirrors extractor.Format inside the ui package so the renderer doesn't pull a dependency cycle. Populated via the ExtractorFormatsMsg pipeline.

type ExtractorFormatsMsg ¶

type ExtractorFormatsMsg struct {
	Video      []ExtractorFormat
	Audio      []ExtractorFormat
	Containers []string
	IsLive     bool // live streams always skip the selector
}

ExtractorFormatsMsg seeds the VCR's browsing-mode selector with the format table parsed from yt-dlp's -J output. Sent immediately after the metadata message during the probe → select handshake.

An empty Video slice means there are no separately-selectable video streams; the model then skips the browser entirely and falls through to yt-dlp's default format spec.

type ExtractorLogMsg ¶

type ExtractorLogMsg struct {
	Level string // "info" | "warn" | "error"
	Text  string
}

ExtractorLogMsg adds a line to the on-screen log strip.

type ExtractorMetaMsg ¶

type ExtractorMetaMsg struct {
	Title      string
	Channel    string
	Duration   time.Duration
	Resolution string
	FPS        float64
	VCodec     string
	ACodec     string
	Container  string
	HasAudio   bool
	OutputFile string // hint — actual path resolved post-merge
}

ExtractorMetaMsg seeds the VCR header with metadata from yt-dlp -J.

type ExtractorOutputMsg ¶

type ExtractorOutputMsg struct{ Path string }

ExtractorOutputMsg surfaces yt-dlp's resolved output path post-merge.

type ExtractorPhaseMsg ¶

type ExtractorPhaseMsg struct {
	Phase string // "downloading" | "muxing" | "done" | "error"
}

ExtractorPhaseMsg switches the active panel: VCR vs Mixer vs done.

type ExtractorProgressMsg ¶

type ExtractorProgressMsg struct {
	Percent    float64 // 0..100
	Downloaded int64
	Total      int64
	SpeedBPS   float64
	ETA        time.Duration
	Fragment   int
	FragmentN  int
}

ExtractorProgressMsg pushes one progress update from yt-dlp.

type ExtractorResetDeckMsg ¶

type ExtractorResetDeckMsg struct{}

ExtractorResetDeckMsg clears the deck (progress, output path, logs) between batch items so the next tape starts fresh. The VCR returns to standby until the next ExtractorMetaMsg arrives.

type ExtractorRunOptions ¶

type ExtractorRunOptions struct {
	Ctx    context.Context
	URL    string
	OnQuit func()
}

ExtractorRunOptions configures RunExtractorTUI.

type ExtractorSelectionMsg ¶

type ExtractorSelectionMsg struct {
	Spec      string
	Container string

	HeightCeiling int
	FPSFloor      int
	VCodec        string
	ABRCeiling    int
	Progressive   bool
}

ExtractorSelectionMsg is internal — the model emits it when the user commits a format choice in browsing mode. The runner forwards the payload to the worker goroutine via a buffered channel.

In addition to the exact format spec, the message carries adaptive descriptors (height ceiling, codec hint, audio bitrate ceiling). The batch pipeline uses those to build a yt-dlp filter expression that survives videos that lack the originally-picked format IDs.

type ExtractorSelector ¶

type ExtractorSelector func(ctx context.Context) (ExtractorSelectionMsg, error)

ExtractorSelector blocks until the user commits a format selection from the VCR's browsing mode, or until ctx is cancelled. Returns the full ExtractorSelectionMsg so callers can pull both the exact spec (for single-URL runs) and the adaptive descriptors (for batch FormatAll caching). A zero-value selection means "use the default pipeline" — happens when the source has no selectable formats or the user dismissed without picking.

type ExtractorShelfActiveMsg ¶

type ExtractorShelfActiveMsg struct {
	Index int
}

ExtractorShelfActiveMsg marks one cassette as the currently-playing tape. Pass Index=-1 between items or at end-of-batch.

type ExtractorShelfMetaMsg ¶

type ExtractorShelfMetaMsg struct {
	Index      int
	Title      string
	Channel    string
	Resolution string
	Duration   time.Duration
}

ExtractorShelfMetaMsg fills in the metadata for one cassette as probes resolve. Fired by the eager probe pool so spine labels populate ahead of the deck reaching that tape.

type ExtractorShelfSeedMsg ¶

type ExtractorShelfSeedMsg struct {
	URLs []string
}

ExtractorShelfSeedMsg installs the cassette shelf at batch start. One CassetteItem per URL. Sent before any per-tape activity so the shelf is visible from the first frame.

type ExtractorShelfStatusMsg ¶

type ExtractorShelfStatusMsg struct {
	Index  int
	Status CassetteStatus
	Err    string
}

ExtractorShelfStatusMsg updates one cassette's lifecycle state.

type ExtractorURLMsg ¶

type ExtractorURLMsg struct{ URL string }

ExtractorURLMsg updates the "source" line shown above the shelf when the active tape changes mid-batch. In single-URL mode the URL is fixed at construction time and this message is never sent.

type JoinDoneMsg ¶

type JoinDoneMsg struct{}

JoinDoneMsg signals joining finished.

type JoinProgressMsg ¶

type JoinProgressMsg struct{ Current int }

JoinProgressMsg carries joining progress.

type JoinStartMsg ¶

type JoinStartMsg struct{ Total int }

JoinStartMsg signals the file-joining phase started.

type LogMsg ¶

type LogMsg struct {
	Level string // "info" | "warn" | "error"
	Text  string
}

LogMsg adds an entry to the on-screen log panel.

type MessageType ¶

type MessageType int

MessageBox renders a styled message box that fits the modem theme.

const (
	MessageInfo MessageType = iota
	MessageWarning
	MessageError
	MessageSuccess
)

type MixerAnimation ¶

type MixerAnimation struct {
	// contains filtered or unexported fields
}

MixerAnimation — analog-mixer themed visualization for the post-processing (ffmpeg mux) phase. Even though we don't get true progress from yt-dlp's internal ffmpeg call, we drive a believable rolling animation: VU meters on V/A channel strips, a sweeping EQ graph, motorized fader catch-up, and a master meter that pegs as the mux finishes.

func NewMixer() MixerAnimation

func (m *MixerAnimation) Frame() int

func (m *MixerAnimation) Mode() MixerMode

func (m *MixerAnimation) SetMeta(meta MixerMeta)

func (m *MixerAnimation) SetMode(mode MixerMode)

func (m *MixerAnimation) Tick()

func (m MixerAnimation) View() string

type MixerMeta ¶

type MixerMeta struct {
	VideoCodec string // tag for video channel strip
	AudioCodec string // tag for audio channel strip
	Container  string // master section "BUS OUT" caption (mp4 / mkv / webm)
	OutputFile string // shown on the master strip
	Bitrate    string // optional
}

MixerMeta — labels shown on the channel strips and master section.

type MixerMode ¶

type MixerMode int

MixerMode is the mixer panel's operational state.

const (
	MixerIdle MixerMode = iota
	MixerMixing
	MixerDone
	MixerError
)

type PartDoneMsg ¶

type PartDoneMsg struct{ Index int }

PartDoneMsg signals a chunk finished downloading successfully.

type PartProgressMsg ¶

type PartProgressMsg struct {
	Index      int
	Downloaded int64
	Total      int64
}

PartProgressMsg carries incremental progress for one chunk.

type RunOptions ¶

type RunOptions struct {
	// Ctx is observed for external cancellation (e.g. SIGINT routed through
	// signal.NotifyContext at main).  When Ctx is cancelled, RunWithTUI
	// surfaces a "stopping…" overlay and waits for fn to drain.
	Ctx context.Context
	// OnSkip is called when the user presses 's' (batch mode only).
	OnSkip func()
	// OnQuit is called when the user presses 'q' / 'ctrl+c'.
	OnQuit       func()
	NumConns     int
	WillVerify   bool
	BatchCurrent int
	BatchTotal   int
	BatchHistory []BatchItemSnapshot
}

RunOptions configures a TUI session.

type SkippingMsg ¶

type SkippingMsg struct{}

SkippingMsg overlays a "skipping" panel for the current batch item.

type StoppingMsg ¶

type StoppingMsg struct {
	// Reason renders inside the stopping panel; e.g. "Aborted by user".
	Reason string
}

StoppingMsg is sent when an external cancellation (e.g. SIGINT routed through signal.NotifyContext) has been requested. The TUI overlays a "stopping" panel until the worker goroutine reports completion.

type UI ¶

type UI interface {
	Printf(format string, a ...any) (n int, err error)
	Println(a ...any) (n int, err error)
	Errorf(format string, a ...any) (n int, err error)
	Errorln(a ...any) (n int, err error)
}

UI represents simple IO output.

type VCRAnimation ¶

type VCRAnimation struct {
	// contains filtered or unexported fields
}

VCRAnimation drives the on-screen VCR. Tick() advances the animation frame; Update() pushes new download progress. The renderer is pure.

func NewVCR() VCRAnimation

func (v VCRAnimation) CurrentAudio() (ExtractorFormat, bool)

func (v VCRAnimation) CurrentContainer() string

func (v VCRAnimation) CurrentVideo() (ExtractorFormat, bool)

func (v *VCRAnimation) CycleAudio(step int)

func (v *VCRAnimation) CycleContainer(step int)

func (v *VCRAnimation) CycleVideo(step int)

func (v *VCRAnimation) Frame() int

func (v VCRAnimation) HasFormats() bool

func (v *VCRAnimation) Mode() VCRMode

func (v VCRAnimation) Selection() ExtractorSelectionMsg

func (v *VCRAnimation) SetFormats(video, audio []ExtractorFormat, containers []string)

func (v *VCRAnimation) SetMeta(m VCRMeta)

func (v *VCRAnimation) SetMode(m VCRMode)

func (v *VCRAnimation) Tick()

func (v *VCRAnimation) Update(pct float64, downloaded, total int64, speedBPS float64, eta time.Duration, fragment, fragmentN int)

func (v VCRAnimation) View() string

type VCRMeta ¶

type VCRMeta struct {
	Title       string
	Channel     string
	Duration    time.Duration
	Resolution  string
	FPS         float64
	VCodec      string
	ACodec      string
	Container   string
	HasAudio    bool   // controls whether the AUDIO meter is shown
	StreamLabel string // "VIDEO" / "AUDIO" / "" — drives front-LED
}

VCRMeta — the metadata strip shown above the tape window. All fields are optional; absent values render as "—".

type VCRMode ¶

type VCRMode int

VCRMode is the operational state of the VCR panel. Mirrors the extractor.Phase but stays in the ui package so the renderer never imports extractor.

const (
	VCRStandby   VCRMode = iota // pre-recording, "tape inserted" state
	VCRBrowsing                 // probe complete; user is picking a tape
	VCRRecording                // [download] phase active
	VCREjecting                 // post-record cooldown (between phases)
	VCRError
)

type VerifyDetails ¶

type VerifyDetails struct {
	SignedBy    string // user id, e.g. "Linus Torvalds <torvalds@kernel.org>"
	KeyID       string // long key id, e.g. "ABCDEF1234567890"
	Fingerprint string // 40-hex fingerprint with spaces every 4 chars
	SignedAt    string // signature timestamp string
	Verdict     string // short verdict label rendered in the verdict row
	Raw         string // raw gpg output, kept for the "details" pane
}

func ParseGPGOutput(output string) VerifyDetails

gpg: Signature made Mon Jan  1 12:00:00 2024 UTC
gpg:                using RSA key ABCDEF1234567890ABCDEF1234567890DEADBEEF
gpg: Good signature from "Linus Torvalds <torvalds@kernel.org>" [unknown]
Primary key fingerprint: ABCD 1234 EF56 7890 ABCD 1234 EF56 7890 ABCD 1234
gpg: BAD signature from "Mallory <mallory@example.com>"

type VerifyDoneMsg ¶

type VerifyDoneMsg struct {
	OK     bool
	Detail string // gpg output excerpt
}

VerifyDoneMsg signals GPG verification has completed.

type VerifyStartMsg ¶

type VerifyStartMsg struct{}

VerifyStartMsg signals GPG signature verification has begun.