feat(v5): 5.5.0 — Kern und Oberfläche aufgeteilt, Übersicht und Einstellungen neu, Erst-Einrichtung mit Poster-Kulisse
Commander-Wünsche vom 02.09.2026 vor der Freigabe von 5.4.0 (die deshalb nie veröffentlicht wurde): Kern: kern/index.ts ist nur noch Bootstrap und Router; Dienste in kern/dienste/ (Einstellungen, Werkzeuge, Laufwerke, Erkennung, Vorgänge, Speicher, Benachrichtigung, Automatik), Kontext in kern/kontext.ts, Protokoll-Datei in gemeinsam/protokoll.ts, Platz-Rechnung in gemeinsam/platz.ts. Oberfläche: fenster/App.tsx ist nur noch der Rahmen; bausteine.tsx, dialoge/, uebersicht/ (LaufwerkKachel, KompressionsKarte, SpeicherKarte, VerlaufKarte), einstellungen/ (Karten je Funktion, SprachAuswahl), einrichtung/ (ErstEinrichtung, PosterHintergrund). Neu: Bibliothek weg, dafür Verlauf; Speicher-und-Bilanz-Karte (statfs); LED-Fußleiste; MakeMKV-Kopf in die Einstellungen; Sprach-Chips mit Dropdown statt Allgemeinem Preset; Karten Automatik/Benachrichtigung/Allgemein/Update; Durchsuchen bei Werkzeugen; Arbeitsordner lokal (Encode dort, dann in die Ablage); Platz-Prüfung vor dem Rip (Dialog und Kern); Automatik mit Countdown; Serien-Merker über Discs; Rettungs-Abbild mit Nullen nur nach gesehenen Lesefehlern (kern/rip/rettung.ts, Phase rettet, iso:-Quelle); Warteschlange pausieren; Discord/Telegram-Benachrichtigung; Protokoll-Datei je Tag; Fensterlage 80 % mittig, gemerkt; Erst-Einrichtung in acht Schritten vor dem Poster-Grid. Beweise: 413 Tests (neu: speicher, benachrichtigung, automatik, rettung, fensterlage, protokoll, kleinkram-550), drei Typprüfungen, Klick-Beweis mit 29 Schritten inklusive Erst-Einrichtung (zweiter Start mit RIPPY_START_BEREICH=einrichtung), Bilder beweise/klick/01…09. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
This commit is contained in:
Hitonabi
co-authored by
Claude Fable 5.1
Claude Fable 5.1
parent
6678c81592
commit
3dc6798c79
@@ -5,6 +5,8 @@
|
||||
// Kontextgrenze — contextBridge kann keine Ports übertragen)
|
||||
// 2. den Haupt-Status (Kanal 'haupt-status')
|
||||
// 3. rippy.melden(art) für kurze Rückmeldungen ans Haupt
|
||||
// … plus die Windows-Dialoge und Shell-Wege, die nur das Haupt öffnen kann
|
||||
// (Ordner/Datei wählen, Ordner im Explorer zeigen, Protokoll öffnen).
|
||||
//
|
||||
// Beides wird GEPUFFERT: Das Haupt schickt Port und Status direkt nach
|
||||
// did-finish-load — ob die React-Seite ihre Horcher da schon registriert
|
||||
@@ -52,6 +54,18 @@ contextBridge.exposeInMainWorld('rippy', {
|
||||
ordnerWaehlen(titel: string): Promise<string | null> {
|
||||
return ipcRenderer.invoke('ordner-waehlen', String(titel)) as Promise<string | null>
|
||||
},
|
||||
/** Echter Windows-Dateidialog für Programme (5.5.0: Werkzeuge → Durchsuchen). */
|
||||
dateiWaehlen(titel: string): Promise<string | null> {
|
||||
return ipcRenderer.invoke('datei-waehlen', String(titel)) as Promise<string | null>
|
||||
},
|
||||
/** Einen Ordner im Explorer zeigen (5.5.0). Liefert '' oder den Fehler. */
|
||||
ordnerOeffnen(pfad: string): Promise<string> {
|
||||
return ipcRenderer.invoke('ordner-oeffnen', String(pfad)) as Promise<string>
|
||||
},
|
||||
/** Den Protokoll-Ordner im Explorer zeigen (5.5.0). */
|
||||
protokollOeffnen(): Promise<string> {
|
||||
return ipcRenderer.invoke('protokoll-oeffnen') as Promise<string>
|
||||
},
|
||||
/** Autostart an/aus (§ 8) — liefert den tatsächlichen Zustand zurück. */
|
||||
autostartSetzen(an: boolean): Promise<boolean> {
|
||||
return ipcRenderer.invoke('autostart-setzen', an === true) as Promise<boolean>
|
||||
|
||||
+176
-2686
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,462 @@
|
||||
// Die Bausteine der Oberfläche (5.5.0, Separation of Concerns): alles,
|
||||
// was mehr als ein Bereich braucht — Formatierer, Symbole, Badge, Kacheln,
|
||||
// Segment-Anzeige, Schalter, Felder, Karten. Der Kino-Mix (Design-Entscheid
|
||||
// des Commanders, 31.08.2026) lebt in den Tokens von stil.css; hier sind
|
||||
// nur die Klassen, die ihn tragen.
|
||||
import { useEffect, useRef, useState } from 'react'
|
||||
import type { DiscInfoStand, GeraeteInfo, RipStatus, SprachEintrag } from '../gemeinsam/nachrichten'
|
||||
|
||||
// ── Formatierer ─────────────────────────────────────────────────────────
|
||||
export function gb(bytes: number): string {
|
||||
return `${(bytes / 1e9).toFixed(2).replace('.', ',')} GB`
|
||||
}
|
||||
|
||||
/** Größen mit passender Einheit: 412 GB, 2,2 TB. */
|
||||
export function gbKurz(bytes: number): string {
|
||||
if (bytes >= 1e12) return `${(bytes / 1e12).toFixed(1).replace('.', ',')} TB`
|
||||
if (bytes >= 1e9) return `${Math.round(bytes / 1e9)} GB`
|
||||
return `${(bytes / 1e6).toFixed(0)} MB`
|
||||
}
|
||||
|
||||
export function dauerText(s: number): string {
|
||||
const m = Math.floor(s / 60)
|
||||
return m >= 60
|
||||
? `${Math.floor(m / 60)}:${String(m % 60).padStart(2, '0')} h`
|
||||
: `${m}:${String(Math.round(s % 60)).padStart(2, '0')} min`
|
||||
}
|
||||
|
||||
/** „1 h 42 min" für Statistik und Verlauf. */
|
||||
export function dauerGrob(s: number): string {
|
||||
const m = Math.round(s / 60)
|
||||
if (m < 60) return `${m} min`
|
||||
return `${Math.floor(m / 60)} h ${String(m % 60).padStart(2, '0')} min`
|
||||
}
|
||||
|
||||
export function datumKurz(iso: string | null): string {
|
||||
if (iso === null || iso.length < 16) return '—'
|
||||
return iso.slice(0, 16).replace('T', ' ')
|
||||
}
|
||||
|
||||
export function restzeitText(prozent: number, startMs: number | undefined): string {
|
||||
if (startMs === undefined || prozent <= 2 || prozent >= 100) return ''
|
||||
const verstrichen = (Date.now() - startMs) / 1000
|
||||
const restS = Math.round((verstrichen * (100 - prozent)) / prozent)
|
||||
if (restS < 90) return `REST ~${restS} S`
|
||||
return `REST ~${Math.round(restS / 60)} MIN`
|
||||
}
|
||||
|
||||
// ── TMDb-Bilder: Größen aus /configuration gemessen (01.09.2026) ────────
|
||||
export function posterUrlKlein(pfad: string): string {
|
||||
return bildUrl(pfad, 'w154')
|
||||
}
|
||||
export function posterUrlGross(pfad: string): string {
|
||||
return bildUrl(pfad, 'w342')
|
||||
}
|
||||
export function backdropUrl(pfad: string): string {
|
||||
return bildUrl(pfad, 'w780')
|
||||
}
|
||||
/** Freigestellter Schriftzug — SVG-Logos zeigt Chromium direkt. */
|
||||
export function logoUrl(pfad: string): string {
|
||||
return bildUrl(pfad, 'w300')
|
||||
}
|
||||
export function profilUrl(pfad: string): string {
|
||||
return bildUrl(pfad, 'w185')
|
||||
}
|
||||
function bildUrl(pfad: string, groesse: string): string {
|
||||
if (pfad.length === 0) return ''
|
||||
if (pfad.startsWith('http')) return pfad
|
||||
return `https://image.tmdb.org/t/p/${groesse}${pfad}`
|
||||
}
|
||||
|
||||
/** „1988 · FSK 16 · 124 Min · Animation · ★ 7,9" — nur, was da ist. */
|
||||
export function metaZeile(info: DiscInfoStand): string {
|
||||
const teile: string[] = []
|
||||
if (info.jahr !== null) teile.push(String(info.jahr))
|
||||
if (info.fsk.length > 0) teile.push(`FSK ${info.fsk}`)
|
||||
if (info.laufzeitMinuten > 0) teile.push(`${info.laufzeitMinuten} Min`)
|
||||
if (info.genres.length > 0) teile.push(info.genres.slice(0, 3).join(' · '))
|
||||
if (info.bewertung > 0) teile.push(`★ ${info.bewertung.toFixed(1).replace('.', ',')}`)
|
||||
return teile.join(' · ')
|
||||
}
|
||||
|
||||
export function sicherheitsWort(confidence: number): string {
|
||||
if (confidence >= 0.9) return 'sehr wahrscheinlich'
|
||||
if (confidence >= 0.8) return 'wahrscheinlich'
|
||||
if (confidence >= 0.6) return 'Vorschlag'
|
||||
return 'unsicher'
|
||||
}
|
||||
|
||||
/** 'Staffel 1 · Disc 2 · 2 Folgen' — was die Disc über ihre Lage in der
|
||||
* Ausgabe sagt. Die Folgenzahl stammt aus ihrem eigenen
|
||||
* Inhaltsverzeichnis, ist also gemessen und nicht geraten. '' wenn die
|
||||
* Disc nichts davon verrät. */
|
||||
export function discHerkunft(info: DiscInfoStand): string {
|
||||
const teile: string[] = []
|
||||
if (info.staffel !== null) teile.push(`Staffel ${info.staffel}`)
|
||||
if (info.discNr !== null) teile.push(`Disc ${info.discNr}`)
|
||||
if (info.folgen > 0) teile.push(info.folgen === 1 ? '1 Folge' : `${info.folgen} Folgen`)
|
||||
return teile.join(' · ')
|
||||
}
|
||||
|
||||
/** Vorbelegung der Sprachen je Titel: die Einstellung, soweit der Titel
|
||||
* sie hat — sonst alles, was er hat (japanischer Ton statt gar keiner). */
|
||||
export function sprachenVorbelegt(vorhanden: readonly SprachEintrag[], einstellung: string): string[] {
|
||||
const da = vorhanden.map((s) => s.lang)
|
||||
const wunsch = einstellung
|
||||
.split(',')
|
||||
.map((s) => s.trim().toLowerCase())
|
||||
.filter((s) => s.length > 0)
|
||||
const treffer = wunsch.filter((w) => da.includes(w))
|
||||
return treffer.length > 0 ? treffer : da
|
||||
}
|
||||
|
||||
export const TYP_NAMEN: Record<GeraeteInfo['typ'], string> = {
|
||||
cd: 'Audio-CD',
|
||||
dvd: 'DVD',
|
||||
bluray: 'Blu-ray',
|
||||
uhd: '4K-UHD',
|
||||
unknown: 'unbekannt',
|
||||
}
|
||||
|
||||
export const PHASEN_MONO: Record<RipStatus['phase'], string> = {
|
||||
'liest-info': 'PHASE 1/4 — LIEST TITEL-INFO',
|
||||
rettet: 'RETTUNGS-ABBILD — LIEST SEKTOR FÜR SEKTOR',
|
||||
rippt: 'PHASE 2/4 — RIPPT (VERLUSTFREI)',
|
||||
komprimiert: 'PHASE 3/4 — KOMPRIMIERT',
|
||||
'legt-ab': 'PHASE 4/4 — LEGT AB',
|
||||
fertig: 'FERTIG',
|
||||
fehler: 'FEHLER',
|
||||
abgebrochen: 'ABGEBROCHEN',
|
||||
}
|
||||
|
||||
export const LAUFENDE_PHASEN: readonly string[] = ['liest-info', 'rettet', 'rippt', 'komprimiert', 'legt-ab']
|
||||
|
||||
export const FELD_KLASSE =
|
||||
'mt-1 w-full rounded-lg border border-white/12 bg-samt px-3 py-2 font-mono text-xs text-schnee placeholder:text-nebel focus:border-gold/60 focus:outline-none'
|
||||
|
||||
export const KNOPF_LEISE = 'rounded-lg border border-white/15 bg-samt/60 px-3 py-1.5 text-xs text-dunst hover:text-schnee disabled:opacity-35'
|
||||
export const KNOPF_GOLD =
|
||||
'rounded-xl bg-gradient-to-b from-gold-hell to-gold-tief px-5 py-1.5 text-xs font-bold text-buehne shadow-[inset_0_1px_0_oklch(1_0_0/0.4)] hover:brightness-105 disabled:opacity-35'
|
||||
|
||||
// ── Ikonografie: eine Handvoll Strich-Symbole, alle aus demselben Guss ──
|
||||
export function IconDisc({ groesse, farbe }: { groesse: number; farbe: string }) {
|
||||
return (
|
||||
<svg width={groesse} height={groesse} viewBox="0 0 24 24" fill="none" stroke={farbe} strokeWidth="1.6">
|
||||
<circle cx="12" cy="12" r="9"></circle>
|
||||
<circle cx="12" cy="12" r="2.6"></circle>
|
||||
<path d="M12 3v3.4M12 17.6V21"></path>
|
||||
</svg>
|
||||
)
|
||||
}
|
||||
|
||||
export function IconPlay() {
|
||||
return (
|
||||
<svg width="14" height="14" viewBox="0 0 24 24" fill="currentColor">
|
||||
<path d="M7 4.5v15l13-7.5z"></path>
|
||||
</svg>
|
||||
)
|
||||
}
|
||||
|
||||
export function IconStop() {
|
||||
return (
|
||||
<svg width="13" height="13" viewBox="0 0 24 24" fill="currentColor">
|
||||
<rect x="6" y="6" width="12" height="12" rx="1.5"></rect>
|
||||
</svg>
|
||||
)
|
||||
}
|
||||
|
||||
export function IconEject() {
|
||||
return (
|
||||
<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
|
||||
<path d="M5 17h14M12 4l6 9H6z"></path>
|
||||
</svg>
|
||||
)
|
||||
}
|
||||
|
||||
export function IconStift() {
|
||||
return (
|
||||
<svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
|
||||
<path d="M4 20l4.5-1L20 7.5 16.5 4 5 15.5 4 20z"></path>
|
||||
</svg>
|
||||
)
|
||||
}
|
||||
|
||||
// ── Eigene Fensterknöpfe (§ 4.2, seit 5.1.3) ────────────────────────────
|
||||
// Bewusst schlicht und in Windows-Maßen (46 × 32) — wer sie sucht, findet
|
||||
// sie dort, wo er sie erwartet. Sie sitzen in der Ziehfläche und müssen
|
||||
// deshalb `nicht-ziehbar` sein, sonst verschluckt der Fenstergriff den Klick.
|
||||
export const IconMinimieren = (): React.JSX.Element => (
|
||||
<svg width="10" height="10" viewBox="0 0 10 10" aria-hidden="true">
|
||||
<path d="M0 5h10" stroke="currentColor" strokeWidth="1.1" />
|
||||
</svg>
|
||||
)
|
||||
|
||||
export const IconMaximieren = (): React.JSX.Element => (
|
||||
<svg width="10" height="10" viewBox="0 0 10 10" fill="none" aria-hidden="true">
|
||||
<rect x="0.6" y="0.6" width="8.8" height="8.8" stroke="currentColor" strokeWidth="1.1" />
|
||||
</svg>
|
||||
)
|
||||
|
||||
export const IconWiederherstellen = (): React.JSX.Element => (
|
||||
<svg width="10" height="10" viewBox="0 0 10 10" fill="none" aria-hidden="true">
|
||||
<rect x="0.6" y="2.6" width="6.8" height="6.8" stroke="currentColor" strokeWidth="1.1" />
|
||||
<path d="M2.7 2.6V0.6h6.7v6.7h-2" stroke="currentColor" strokeWidth="1.1" />
|
||||
</svg>
|
||||
)
|
||||
|
||||
export const IconSchliessen = (): React.JSX.Element => (
|
||||
<svg width="10" height="10" viewBox="0 0 10 10" aria-hidden="true">
|
||||
<path d="M0.6 0.6l8.8 8.8M9.4 0.6l-8.8 8.8" stroke="currentColor" strokeWidth="1.1" />
|
||||
</svg>
|
||||
)
|
||||
|
||||
export function FensterKnopf({
|
||||
titel,
|
||||
aufKlick,
|
||||
rot = false,
|
||||
children,
|
||||
}: {
|
||||
titel: string
|
||||
aufKlick: () => void
|
||||
rot?: boolean
|
||||
children: React.ReactNode
|
||||
}) {
|
||||
return (
|
||||
<button
|
||||
onClick={aufKlick}
|
||||
title={titel}
|
||||
aria-label={titel}
|
||||
className={`flex h-8 w-[46px] items-center justify-center text-dunst transition-colors ${
|
||||
rot ? 'hover:bg-rot hover:text-white' : 'hover:bg-white/10 hover:text-schnee'
|
||||
}`}
|
||||
>
|
||||
{children}
|
||||
</button>
|
||||
)
|
||||
}
|
||||
|
||||
// ── Kleine Bausteine des Schaltpults ────────────────────────────────────
|
||||
export function Badge({ text, ton }: { text: string; ton: 'gruen' | 'gelb' | 'blau' | 'grau' }) {
|
||||
const farben = {
|
||||
gruen: 'border-gruen/40 bg-gruen/10 text-gruen',
|
||||
gelb: 'border-warn/40 bg-warn/10 text-warn',
|
||||
blau: 'border-gold/40 bg-gold/10 text-gold-hell',
|
||||
grau: 'border-white/15 bg-white/5 text-dunst',
|
||||
}
|
||||
return (
|
||||
<span className={`inline-block rounded-full border px-2.5 py-0.5 text-[11px] leading-4 ${farben[ton]}`}>
|
||||
{text}
|
||||
</span>
|
||||
)
|
||||
}
|
||||
|
||||
/** Die kleinen Mess-Kacheln aus dem Schaltpult (MEDIUM / GRÖSSE / …). */
|
||||
export function InfoKachel({ label, wert, farbe }: { label: string; wert: string; farbe?: string }) {
|
||||
return (
|
||||
<div className="rounded-lg border border-white/10 bg-samt/70 px-3 py-2 min-w-0">
|
||||
<div className="font-mono text-[9px] tracking-[0.14em] text-nebel">{label}</div>
|
||||
<div className={`mt-0.5 truncate text-[13px] font-semibold ${farbe ?? 'text-schnee'}`} title={wert}>
|
||||
{wert}
|
||||
</div>
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
/** Die goldene Aussteuerungsanzeige — 20 Segmente, gefüllt nach Prozent. */
|
||||
export function SegmentBalken({ prozent }: { prozent: number }) {
|
||||
const segmente = 20
|
||||
const anteil = Math.max(0, Math.min(100, prozent)) / 100
|
||||
const voll = Math.floor(anteil * segmente)
|
||||
const halb = anteil * segmente - voll >= 0.3
|
||||
return (
|
||||
<div className="flex gap-1">
|
||||
{Array.from({ length: segmente }, (_, i) => (
|
||||
<div
|
||||
key={i}
|
||||
className={`h-3.5 flex-1 rounded-[3px] ${
|
||||
i < voll ? 'segment-gluehen' : i === voll && halb ? 'bg-gold/45' : 'bg-white/8'
|
||||
}`}
|
||||
/>
|
||||
))}
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
/** Ein schmaler Füllbalken (Speicher): Anteil belegt, Farbe nach Lage. */
|
||||
export function FuellBalken({ anteil, ton }: { anteil: number; ton: 'gold' | 'warn' | 'rot' }) {
|
||||
const farbe = ton === 'gold' ? 'from-gold-tief to-gold-hell' : ton === 'warn' ? 'from-warn to-warn' : 'from-rot to-rot'
|
||||
return (
|
||||
<div className="h-1.5 w-full overflow-hidden rounded-full bg-white/8">
|
||||
<div className={`h-full rounded-full bg-gradient-to-r ${farbe} transition-all`} style={{ width: `${Math.max(0, Math.min(100, anteil * 100))}%` }} />
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
export function Kicker({ text }: { text: string }) {
|
||||
return <h2 className="font-mono text-[10px] font-semibold tracking-[0.22em] text-gold/80">{text}</h2>
|
||||
}
|
||||
|
||||
/** Ein richtiger Schalter statt einer nackten Checkbox. */
|
||||
export function Schalter({ an, aufWechsel, label }: { an: boolean; aufWechsel: (an: boolean) => void; label: string }) {
|
||||
return (
|
||||
<button onClick={() => aufWechsel(!an)} className="flex items-center gap-3 text-left" role="switch" aria-checked={an}>
|
||||
<span
|
||||
className={`relative inline-block h-5 w-9 flex-none rounded-full transition-colors ${
|
||||
an ? 'bg-gradient-to-b from-gold-hell to-gold-tief' : 'bg-white/12'
|
||||
}`}
|
||||
>
|
||||
<span className={`absolute top-0.5 h-4 w-4 rounded-full bg-schnee shadow transition-all ${an ? 'left-[18px]' : 'left-0.5'}`} />
|
||||
</span>
|
||||
<span className="text-xs leading-5 text-dunst">{label}</span>
|
||||
</button>
|
||||
)
|
||||
}
|
||||
|
||||
/** Eine Einstellungs-Karte: Kicker, ein Satz Einordnung, dann die Felder. */
|
||||
export function SektionsKarte({
|
||||
id,
|
||||
titel,
|
||||
intro,
|
||||
children,
|
||||
}: {
|
||||
id: string
|
||||
titel: string
|
||||
intro: string
|
||||
children: React.ReactNode
|
||||
}) {
|
||||
return (
|
||||
<section id={id} className="scroll-mt-4 rounded-2xl border border-white/10 bg-karte/50 p-5">
|
||||
<Kicker text={titel} />
|
||||
<p className="mt-1.5 max-w-xl text-xs leading-5 text-nebel">{intro}</p>
|
||||
<div className="mt-4 space-y-3">{children}</div>
|
||||
</section>
|
||||
)
|
||||
}
|
||||
|
||||
/** Kleiner Status-Punkt für Schlüssel-Felder: hinterlegt oder leer. */
|
||||
export function HinterlegtPunkt({ wert }: { wert: string }) {
|
||||
return (
|
||||
<span className={`ml-2 font-mono text-[10px] ${wert.length > 0 ? 'text-gruen' : 'text-nebel'}`}>
|
||||
{wert.length > 0 ? '● hinterlegt' : '○ fehlt'}
|
||||
</span>
|
||||
)
|
||||
}
|
||||
|
||||
export function Feld({
|
||||
name,
|
||||
wert,
|
||||
hinweis,
|
||||
geheim,
|
||||
platzhalter,
|
||||
aufAendern,
|
||||
}: {
|
||||
name: string
|
||||
wert: string
|
||||
hinweis?: string
|
||||
geheim?: boolean
|
||||
platzhalter?: string
|
||||
aufAendern: (wert: string) => void
|
||||
}) {
|
||||
const [entwurf, setEntwurf] = useState(wert)
|
||||
useEffect(() => setEntwurf(wert), [wert])
|
||||
return (
|
||||
<label className="block">
|
||||
<span className="text-xs font-semibold text-dunst">{name}</span>
|
||||
{hinweis !== undefined && <span className="ml-2 text-xs text-nebel">{hinweis}</span>}
|
||||
<input
|
||||
type={geheim === true ? 'password' : 'text'}
|
||||
value={entwurf}
|
||||
placeholder={platzhalter}
|
||||
onChange={(e) => setEntwurf(e.target.value)}
|
||||
onBlur={() => {
|
||||
if (entwurf !== wert) aufAendern(entwurf)
|
||||
}}
|
||||
className={FELD_KLASSE}
|
||||
/>
|
||||
</label>
|
||||
)
|
||||
}
|
||||
|
||||
/** Ein Pfad-Feld mit Durchsuchen (Ordner oder Programm) — die echten
|
||||
* Windows-Dialoge, keine nachgebauten (§ 7). */
|
||||
export function PfadFeld({
|
||||
name,
|
||||
wert,
|
||||
hinweis,
|
||||
art,
|
||||
dialogTitel,
|
||||
aufAendern,
|
||||
}: {
|
||||
name: string
|
||||
wert: string
|
||||
hinweis?: string
|
||||
art: 'ordner' | 'programm'
|
||||
dialogTitel: string
|
||||
aufAendern: (wert: string) => void
|
||||
}) {
|
||||
const waehlen = async (): Promise<void> => {
|
||||
const gewaehlt = art === 'ordner' ? await window.rippy.ordnerWaehlen(dialogTitel) : await window.rippy.dateiWaehlen(dialogTitel)
|
||||
if (gewaehlt !== null) aufAendern(gewaehlt)
|
||||
}
|
||||
return (
|
||||
<div className="flex items-end gap-2">
|
||||
<div className="min-w-0 flex-1">
|
||||
<Feld name={name} wert={wert} hinweis={hinweis} aufAendern={aufAendern} />
|
||||
</div>
|
||||
<button onClick={() => void waehlen()} className={`${KNOPF_LEISE} py-2`}>
|
||||
Durchsuchen …
|
||||
</button>
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
/** Nur ein Klick, der WIRKLICH auf der Hintergrundfläche begann, schließt
|
||||
* einen Dialog.
|
||||
*
|
||||
* Commander-Fund (01.09.2026): „es gibt einen kleinen bug im UI wenn man
|
||||
* selbst den titel sucht das suchfenster schließt sich dann einfach."
|
||||
* Der Grund ist eine bekannte Falle: Wer im Eingabefeld Text markiert und
|
||||
* dabei über den Dialogrand hinauszieht, drückt INNEN und lässt AUSSEN
|
||||
* los. Der Browser meldet als Ziel des Klicks dann den gemeinsamen
|
||||
* Vorfahren — die Hintergrundfläche. Ein reiner onClick-Horcher darauf
|
||||
* schließt den Dialog also mitten im Tippen.
|
||||
*
|
||||
* Deshalb wird der Anfang gemerkt: Nur wenn Drücken UND Loslassen auf der
|
||||
* Fläche selbst passierten, ist es ein Klick daneben. */
|
||||
export function useHintergrundKlick(schliessen: () => void): {
|
||||
onMouseDown: (e: React.MouseEvent) => void
|
||||
onClick: (e: React.MouseEvent) => void
|
||||
} {
|
||||
const begannDraussen = useRef(false)
|
||||
return {
|
||||
onMouseDown: (e) => {
|
||||
begannDraussen.current = e.target === e.currentTarget
|
||||
},
|
||||
onClick: (e) => {
|
||||
if (begannDraussen.current && e.target === e.currentTarget) schliessen()
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
/** Der Rahmen jedes Dialogs: abgedunkelte Bühne, Karte in der Mitte. */
|
||||
export function DialogRahmen({
|
||||
schliessen,
|
||||
breite,
|
||||
children,
|
||||
}: {
|
||||
schliessen: () => void
|
||||
breite: string
|
||||
children: React.ReactNode
|
||||
}) {
|
||||
const hintergrund = useHintergrundKlick(schliessen)
|
||||
return (
|
||||
<div className="fixed inset-0 z-50 flex items-center justify-center bg-black/70 p-6 backdrop-blur-sm" {...hintergrund}>
|
||||
<div
|
||||
className={`max-h-[85vh] w-full ${breite} overflow-y-auto rounded-2xl border border-white/12 bg-buehne p-5 shadow-2xl shadow-black/60`}
|
||||
onClick={(e) => e.stopPropagation()}
|
||||
>
|
||||
{children}
|
||||
</div>
|
||||
</div>
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,82 @@
|
||||
// § 5 Schritt 4: „nein → fragen" — Suche + Auswahl der richtigen Metadaten.
|
||||
import { useEffect, useState } from 'react'
|
||||
import type { MetaVorschlag } from '../../gemeinsam/nachrichten'
|
||||
import { DialogRahmen, IconDisc, posterUrlKlein } from '../bausteine'
|
||||
import { metadatenSuchen, zuordnungSetzen } from '../kernverbindung'
|
||||
|
||||
export function AendernDialog({
|
||||
id,
|
||||
startText,
|
||||
vorschlaege,
|
||||
schliessen,
|
||||
}: {
|
||||
id: string
|
||||
startText: string
|
||||
vorschlaege: MetaVorschlag[]
|
||||
schliessen: () => void
|
||||
}) {
|
||||
const [text, setText] = useState(startText)
|
||||
useEffect(() => {
|
||||
metadatenSuchen(id, startText)
|
||||
// Nur beim Öffnen — weitere Suchen löst der Knopf aus.
|
||||
// eslint-disable-next-line react-hooks/exhaustive-deps
|
||||
}, [])
|
||||
return (
|
||||
<DialogRahmen schliessen={schliessen} breite="max-w-lg">
|
||||
<h3 className="mb-3 font-display text-lg font-bold text-schnee">Was ist das wirklich?</h3>
|
||||
<div className="mb-3 flex gap-2">
|
||||
<input
|
||||
value={text}
|
||||
onChange={(e) => setText(e.target.value)}
|
||||
onKeyDown={(e) => {
|
||||
if (e.key === 'Enter') metadatenSuchen(id, text)
|
||||
}}
|
||||
placeholder="Titel suchen …"
|
||||
className="flex-1 rounded-lg border border-white/12 bg-samt px-3 py-2 font-mono text-xs text-schnee placeholder:text-nebel focus:border-gold/60 focus:outline-none"
|
||||
/>
|
||||
<button
|
||||
onClick={() => metadatenSuchen(id, text)}
|
||||
className="rounded-lg border border-gold/50 bg-gold/10 px-4 py-2 text-xs font-semibold text-gold-hell hover:bg-gold/20"
|
||||
>
|
||||
Suchen
|
||||
</button>
|
||||
</div>
|
||||
{vorschlaege.length === 0 ? (
|
||||
<p className="font-mono text-xs text-nebel">Keine Treffer — anderen Suchtext probieren.</p>
|
||||
) : (
|
||||
<div className="space-y-1.5">
|
||||
{vorschlaege.map((v) => (
|
||||
<button
|
||||
key={`${v.typ}-${v.tmdbId}`}
|
||||
onClick={() => {
|
||||
zuordnungSetzen(id, v)
|
||||
schliessen()
|
||||
}}
|
||||
className="flex w-full items-center gap-3 rounded-xl border border-white/10 bg-karte/60 p-2 text-left hover:border-gold/50 hover:bg-karte"
|
||||
>
|
||||
{v.posterPfad.length > 0 ? (
|
||||
<img src={posterUrlKlein(v.posterPfad)} alt="" className="h-16 w-11 rounded-md object-cover" />
|
||||
) : (
|
||||
<span className="flex h-16 w-11 items-center justify-center rounded-md bg-samt">
|
||||
<IconDisc groesse={20} farbe="oklch(0.55 0.015 80)" />
|
||||
</span>
|
||||
)}
|
||||
<div>
|
||||
<p className="text-sm font-medium text-schnee">
|
||||
{v.titel}
|
||||
{v.jahr !== null ? ` (${v.jahr})` : ''}
|
||||
</p>
|
||||
<p className="font-mono text-[10px] tracking-wider text-nebel">{v.typ === 'tv' ? 'SERIE' : 'FILM'}</p>
|
||||
</div>
|
||||
</button>
|
||||
))}
|
||||
</div>
|
||||
)}
|
||||
<div className="mt-4 text-right">
|
||||
<button onClick={schliessen} className="rounded-lg border border-white/15 px-4 py-1.5 text-xs text-dunst hover:bg-white/5">
|
||||
Schließen
|
||||
</button>
|
||||
</div>
|
||||
</DialogRahmen>
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,331 @@
|
||||
// ── Auswahl: WAS soll gerippt werden? (§ 6.2) ───────────────────────────
|
||||
// Bis zum 01.09.2026 rippte Rippy IMMER alles — Trailer, Werbung und
|
||||
// Alterskennzeichen inklusive. Der Info-Lauf dauert 20–120 s, deshalb
|
||||
// beginnt er erst hier und nicht schon beim Einlegen.
|
||||
// 5.4.0: Sprachen je Titel, Staffel/Folge von Hand, Zielpfad-Vorschau.
|
||||
// 5.5.0: Platz-Prüfung vor dem Rip und der Serien-Merker (Folge von Disc 1
|
||||
// zählt auf Disc 2 weiter).
|
||||
import { useState } from 'react'
|
||||
import { zielVorschau } from '../../gemeinsam/ablagepfad'
|
||||
import { platzUrteil } from '../../gemeinsam/platz'
|
||||
import type {
|
||||
DiscInfoStand,
|
||||
DiscTitelVorschlag,
|
||||
GeraeteInfo,
|
||||
SpeicherStand,
|
||||
SprachEintrag,
|
||||
TitelRolle,
|
||||
TitelStand,
|
||||
} from '../../gemeinsam/nachrichten'
|
||||
import { DialogRahmen, KNOPF_GOLD, dauerText, gb, gbKurz, sprachenVorbelegt } from '../bausteine'
|
||||
import { ripStarten } from '../kernverbindung'
|
||||
|
||||
/** Sprach-Chips eines Titels — anklickbar, außerhalb des Auswahl-Labels
|
||||
* (ein Knopf IM Label würde die Checkbox mit umschalten). */
|
||||
function SprachChips({
|
||||
name,
|
||||
vorhanden,
|
||||
gewaehlt,
|
||||
aufWechsel,
|
||||
}: {
|
||||
name: string
|
||||
vorhanden: readonly SprachEintrag[]
|
||||
gewaehlt: readonly string[]
|
||||
aufWechsel: (lang: string) => void
|
||||
}) {
|
||||
if (vorhanden.length === 0) return null
|
||||
return (
|
||||
<span className="inline-flex flex-wrap items-center gap-1">
|
||||
<span className="mr-0.5 font-mono text-[10px] tracking-wider text-nebel">{name}</span>
|
||||
{vorhanden.map((s) => {
|
||||
const an = gewaehlt.includes(s.lang)
|
||||
return (
|
||||
<button
|
||||
key={s.lang}
|
||||
type="button"
|
||||
onClick={() => aufWechsel(s.lang)}
|
||||
className={`rounded-md border px-1.5 py-0.5 font-mono text-[10.5px] ${
|
||||
an ? 'border-gold/50 bg-gold/15 text-gold-hell' : 'border-white/12 text-nebel hover:text-dunst'
|
||||
}`}
|
||||
title={`${s.sprache}${s.spuren > 1 ? ` (${s.spuren} Spuren)` : ''}`}
|
||||
>
|
||||
{an ? '✓ ' : ''}
|
||||
{s.lang}
|
||||
{s.spuren > 1 ? `×${s.spuren}` : ''}
|
||||
</button>
|
||||
)
|
||||
})}
|
||||
</span>
|
||||
)
|
||||
}
|
||||
|
||||
export function TitelWahlDialog({
|
||||
id,
|
||||
typ,
|
||||
stand,
|
||||
info,
|
||||
einstellungen,
|
||||
regel,
|
||||
speicher,
|
||||
schliessen,
|
||||
}: {
|
||||
id: string
|
||||
typ: GeraeteInfo['typ']
|
||||
stand: TitelStand | undefined
|
||||
info: DiscInfoStand | undefined
|
||||
einstellungen: Record<string, string>
|
||||
/** Klartext der Aufbewahrungs-Regel — damit klar ist, was mit dem
|
||||
* Roh-Material passiert. */
|
||||
regel: string
|
||||
speicher: SpeicherStand | null
|
||||
schliessen: () => void
|
||||
}) {
|
||||
const [gewaehlt, setGewaehlt] = useState<Set<number> | null>(null)
|
||||
// Eigene Rollen-Wahl je Titel; was hier nicht drinsteht, behaelt Rippys
|
||||
// Vorschlag ('hauptfilm' beim Film, 'folge' bei der Serie, sonst 'extra').
|
||||
const [rollen, setRollen] = useState<Record<number, TitelRolle>>({})
|
||||
// Sprachen je Titel (5.4.0): Was hier nicht drinsteht, ist vorbelegt
|
||||
// (Einstellung, soweit der Titel sie hat — sonst alles, was er hat).
|
||||
const [sprachen, setSprachen] = useState<Record<number, { audio: string[]; untertitel: string[] }>>({})
|
||||
// Staffel und erste Folge von Hand (5.4.0) — die Staffel kommt von der
|
||||
// Disc, die erste Folge vom Serien-Merker (5.5.0: die vorige Disc dieser
|
||||
// Serie) oder vom Nutzer („auf Disc 2 sind 3–4").
|
||||
const merker = info?.serienMerker ?? null
|
||||
const merkerGilt = merker !== null && (info?.discNr === null || info === undefined || (info.discNr ?? 1) > 1)
|
||||
const [staffel, setStaffel] = useState<string>(
|
||||
info !== undefined && info.staffel !== null ? String(info.staffel) : merker !== null ? String(merker.staffel) : '',
|
||||
)
|
||||
const [ersteFolge, setErsteFolge] = useState(merkerGilt && merker !== null ? String(merker.naechsteFolge) : '')
|
||||
// Rippys Vorauswahl gilt, bis der Nutzer sie anfasst.
|
||||
const aktiv = gewaehlt ?? new Set((stand?.titel ?? []).filter((t) => t.gewaehlt).map((t) => t.nr))
|
||||
const rolleVon = (t: DiscTitelVorschlag): TitelRolle => rollen[t.nr] ?? t.rolle
|
||||
const sprachenVon = (t: DiscTitelVorschlag): { audio: string[]; untertitel: string[] } =>
|
||||
sprachen[t.nr] ?? {
|
||||
audio: sprachenVorbelegt(t.sprachen.audio, einstellungen['audioSprachen'] ?? ''),
|
||||
untertitel: sprachenVorbelegt(t.sprachen.untertitel, einstellungen['untertitelSprachen'] ?? ''),
|
||||
}
|
||||
const sprachWechsel = (t: DiscTitelVorschlag, art: 'audio' | 'untertitel', lang: string): void => {
|
||||
const jetzt = sprachenVon(t)
|
||||
const liste = jetzt[art].includes(lang) ? jetzt[art].filter((l) => l !== lang) : [...jetzt[art], lang]
|
||||
setSprachen({ ...sprachen, [t.nr]: { ...jetzt, [art]: liste } })
|
||||
}
|
||||
const umschalten = (nr: number): void => {
|
||||
const neu = new Set(aktiv)
|
||||
if (neu.has(nr)) neu.delete(nr)
|
||||
else neu.add(nr)
|
||||
setGewaehlt(neu)
|
||||
}
|
||||
const alle = stand?.titel ?? []
|
||||
const gewaehlteTitel = alle.filter((t) => aktiv.has(t.nr))
|
||||
const gesamtBytes = gewaehlteTitel.reduce((s, t) => s + t.groesseBytes, 0)
|
||||
const alsSerie = gewaehlteTitel.some((t) => rolleVon(t) === 'folge')
|
||||
const hauptTitel = gewaehlteTitel.filter((t) => rolleVon(t) !== 'extra').length
|
||||
const extras = gewaehlteTitel.filter((t) => rolleVon(t) === 'extra').length
|
||||
const zahlOderNull = (text: string, mindestens: number): number | null => {
|
||||
const n = Number(text.trim())
|
||||
return text.trim().length > 0 && Number.isInteger(n) && n >= mindestens ? n : null
|
||||
}
|
||||
const staffelZahl = zahlOderNull(staffel, 0)
|
||||
const folgeZahl = zahlOderNull(ersteFolge, 1)
|
||||
const vorschau = zielVorschau({
|
||||
ablage: einstellungen['ablage'] ?? 'Videos\\Rippy',
|
||||
alsSerie,
|
||||
titel: info?.titel ?? '',
|
||||
jahr: info?.jahr ?? null,
|
||||
staffel: staffelZahl,
|
||||
ersteFolge: folgeZahl,
|
||||
hauptTitel,
|
||||
extras,
|
||||
vorgangsName: `${typ}-<Zeitstempel>`,
|
||||
})
|
||||
// Platz-Prüfung (5.5.0): gegen den Arbeitsordner — dort landen Roh und Encode.
|
||||
const komprimiert = einstellungen['transcodeEnabled'] !== 'false'
|
||||
const platz = speicher !== null && speicher.arbeit.ok ? platzUrteil(speicher.arbeit.freiBytes, gesamtBytes, komprimiert) : { text: '', hart: false }
|
||||
|
||||
return (
|
||||
<DialogRahmen schliessen={schliessen} breite="max-w-3xl">
|
||||
<h3 className="font-display text-xl font-bold text-schnee">Was soll gerippt werden?</h3>
|
||||
|
||||
{stand === undefined || stand.laeuft ? (
|
||||
<p className="mt-4 font-mono text-xs text-nebel">
|
||||
Rippy liest die Titel der Disc … das dauert bis zu zwei Minuten. Solange dreht das Laufwerk.
|
||||
</p>
|
||||
) : stand.fehler.length > 0 ? (
|
||||
<p className="mt-4 font-mono text-xs text-rot">✗ {stand.fehler}</p>
|
||||
) : (
|
||||
<>
|
||||
<p className={`mt-1 text-xs ${stand.unsicher ? 'text-warn' : 'text-dunst'}`}>
|
||||
{stand.unsicher ? '⚠ ' : ''}
|
||||
{stand.einordnung}
|
||||
</p>
|
||||
|
||||
<div className="mt-3 flex flex-wrap gap-1.5">
|
||||
<button
|
||||
onClick={() => setGewaehlt(new Set(alle.filter((t) => t.gewaehlt).map((t) => t.nr)))}
|
||||
className="rounded-lg border border-gold/40 bg-gold/12 px-2.5 py-1 text-[11px] text-gold-hell"
|
||||
>
|
||||
Rippys Vorschlag
|
||||
</button>
|
||||
<button
|
||||
onClick={() =>
|
||||
setGewaehlt(
|
||||
// Alles Sehenswerte: Hauptinhalt und Zugaben, aber weder
|
||||
// Sammeltitel noch Logos/Warnungen.
|
||||
new Set(alle.filter((t) => !t.grund.startsWith('Sammeltitel') && !t.grund.startsWith('zu kurz')).map((t) => t.nr)),
|
||||
)
|
||||
}
|
||||
className="rounded-lg border border-white/15 px-2.5 py-1 text-[11px] text-dunst hover:text-schnee"
|
||||
>
|
||||
Hauptinhalt + Extras
|
||||
</button>
|
||||
<button onClick={() => setGewaehlt(new Set(alle.map((t) => t.nr)))} className="rounded-lg border border-white/15 px-2.5 py-1 text-[11px] text-dunst hover:text-schnee">
|
||||
Alles
|
||||
</button>
|
||||
<button onClick={() => setGewaehlt(new Set())} className="rounded-lg border border-white/15 px-2.5 py-1 text-[11px] text-dunst hover:text-schnee">
|
||||
Nichts
|
||||
</button>
|
||||
</div>
|
||||
|
||||
<div className="mt-3 space-y-1">
|
||||
{alle.map((t) => {
|
||||
const an = aktiv.has(t.nr)
|
||||
const wahl = sprachenVon(t)
|
||||
return (
|
||||
<div key={t.nr} className={`rounded-lg border ${an ? 'border-gold/40 bg-gold/8' : 'border-white/8 bg-samt/40'}`}>
|
||||
<label className="flex cursor-pointer items-center gap-3 p-2">
|
||||
<input type="checkbox" checked={an} onChange={() => umschalten(t.nr)} className="accent-[oklch(0.83_0.11_75)]" />
|
||||
<span className="w-16 flex-none font-mono text-[11px] text-nebel">Titel {t.nr}</span>
|
||||
<span className="w-24 flex-none font-mono text-xs text-schnee">{dauerText(t.dauerS)}</span>
|
||||
<span className="w-20 flex-none font-mono text-[11px] text-dunst">{gb(t.groesseBytes)}</span>
|
||||
<span className="hidden w-20 flex-none font-mono text-[11px] text-nebel sm:inline">{t.kapitel} Kap.</span>
|
||||
{an ? (
|
||||
<select
|
||||
value={rolleVon(t)}
|
||||
onChange={(e) => setRollen({ ...rollen, [t.nr]: e.target.value as TitelRolle })}
|
||||
onClick={(e) => e.stopPropagation()}
|
||||
className="flex-none rounded-lg border border-white/15 bg-samt/70 px-2 py-0.5 text-[11px] text-dunst"
|
||||
title="Bestimmt, WOHIN der Titel abgelegt wird"
|
||||
>
|
||||
<option value="hauptfilm">Hauptfilm</option>
|
||||
<option value="extra">Extra</option>
|
||||
<option value="folge">Folge</option>
|
||||
</select>
|
||||
) : (
|
||||
<span className="min-w-0 flex-1 truncate text-[11px] text-nebel">{t.grund}</span>
|
||||
)}
|
||||
</label>
|
||||
{/* Sprachen je Titel (5.4.0): Was der Info-Lauf an DIESEM
|
||||
Titel gemessen hat — anhaken, was in die Datei soll.
|
||||
Der Commander-Fall: japanischer Ton, deutsche Untertitel. */}
|
||||
{an && (t.sprachen.audio.length > 0 || t.sprachen.untertitel.length > 0) && (
|
||||
<div className="flex flex-wrap items-center gap-x-4 gap-y-1 border-t border-white/8 px-2 py-1.5 pl-9">
|
||||
<SprachChips name="TON" vorhanden={t.sprachen.audio} gewaehlt={wahl.audio} aufWechsel={(lang) => sprachWechsel(t, 'audio', lang)} />
|
||||
<SprachChips name="UNTERTITEL" vorhanden={t.sprachen.untertitel} gewaehlt={wahl.untertitel} aufWechsel={(lang) => sprachWechsel(t, 'untertitel', lang)} />
|
||||
{wahl.audio.length === 0 && t.sprachen.audio.length > 0 && (
|
||||
<span className="font-mono text-[10.5px] text-warn">kein Ton gewählt — HandBrake nimmt die erste Spur</span>
|
||||
)}
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
)
|
||||
})}
|
||||
{alle.length === 0 && <p className="font-mono text-xs text-warn">Die Disc gab keine Titel her.</p>}
|
||||
</div>
|
||||
|
||||
{alsSerie && (
|
||||
<div className="mt-3 flex flex-wrap items-end gap-3 rounded-xl border border-white/8 bg-samt/40 p-3">
|
||||
<label className="block">
|
||||
<span className="font-mono text-[10px] tracking-wider text-nebel">STAFFEL</span>
|
||||
<input
|
||||
type="number"
|
||||
min={0}
|
||||
value={staffel}
|
||||
onChange={(e) => setStaffel(e.target.value)}
|
||||
placeholder={info !== undefined && info.staffel !== null ? String(info.staffel) : '1'}
|
||||
className="mt-1 block w-20 rounded-lg border border-white/12 bg-buehne px-2 py-1 font-mono text-xs text-schnee"
|
||||
/>
|
||||
</label>
|
||||
<label className="block">
|
||||
<span className="font-mono text-[10px] tracking-wider text-nebel">AB FOLGE</span>
|
||||
<input
|
||||
type="number"
|
||||
min={1}
|
||||
value={ersteFolge}
|
||||
onChange={(e) => setErsteFolge(e.target.value)}
|
||||
placeholder="automatisch"
|
||||
className="mt-1 block w-28 rounded-lg border border-white/12 bg-buehne px-2 py-1 font-mono text-xs text-schnee"
|
||||
/>
|
||||
</label>
|
||||
<p className="min-w-[200px] flex-1 text-[11px] leading-4 text-nebel">
|
||||
{merkerGilt && merker !== null
|
||||
? `Serien-Merker: Die vorige Disc dieser Serie endete mit Folge ${merker.naechsteFolge - 1} (${merker.wann.slice(0, 10)}) — Rippy zählt ab ${merker.naechsteFolge} weiter. Stimmt das nicht, ändere die Zahl.`
|
||||
: 'Leer heißt: Rippy ordnet die Folgen über die TMDb-Laufzeiten zu, und nur, wenn es eindeutig ist. Weißt du es besser („auf Disc 2 sind die Folgen 3 und 4"), trag es hier ein — dann zählt Rippy fortlaufend in Disc-Reihenfolge.'}
|
||||
{info !== undefined && info.discNr !== null && ` Die Disc nennt sich selbst Disc ${info.discNr}.`}
|
||||
</p>
|
||||
</div>
|
||||
)}
|
||||
|
||||
{/* Vorschau (5.4.0): Rolle, Serie, Staffel und Extras entscheiden
|
||||
einiges — zwei Zeilen Zielpfad ersparen Überraschungen. */}
|
||||
<div className="mt-3 rounded-xl border border-white/8 bg-buehne/70 p-3 font-mono text-[11px] leading-5">
|
||||
<p className="text-[10px] tracking-wider text-nebel">LANDET IN</p>
|
||||
<p className="break-all text-gold-hell">{vorschau[0]}</p>
|
||||
<p className="text-dunst">{vorschau[1]}</p>
|
||||
</div>
|
||||
|
||||
{/* Platz-Prüfung (5.5.0): 40 Minuten Lesen sollen nicht an einem
|
||||
vollen Laufwerk scheitern. */}
|
||||
{speicher !== null && speicher.arbeit.ok && (
|
||||
<p className={`mt-2 font-mono text-[11px] ${platz.hart ? 'text-rot' : platz.text.length > 0 ? 'text-warn' : 'text-nebel'}`}>
|
||||
{platz.text.length > 0
|
||||
? `${platz.hart ? '✗' : '⚠'} ${platz.text}`
|
||||
: `Platz: ${gbKurz(speicher.arbeit.freiBytes)} frei im Arbeitsordner — reicht für ${gb(gesamtBytes)} verlustfrei${komprimiert ? ' plus Kompression' : ''}.`}
|
||||
</p>
|
||||
)}
|
||||
|
||||
<p className="mt-3 font-mono text-[11px] text-nebel">
|
||||
{aktiv.size} von {alle.length} gewählt · zusammen {gb(gesamtBytes)} verlustfrei
|
||||
{regel.length > 0 ? ` · ${regel}` : ''}
|
||||
</p>
|
||||
<p className="mt-1 text-[11px] text-nebel">
|
||||
{alsSerie
|
||||
? 'Folgen landen unter Serien/… /Season NN. Ohne Vorgabe setzt Rippy die Episoden-Nummern nur, wenn die Laufzeiten eindeutig passen — sonst behalten die Dateien ihre Namen.'
|
||||
: 'Der Hauptfilm landet in seinem eigenen Ordner, Extras daneben im Unterordner „extras" — so lesen Jellyfin, Emby und Kodi sie als Zugaben.'}{' '}
|
||||
Das Laufwerk ist frei, sobald die Roh-Dateien liegen — die Kompression läuft danach im Hintergrund.
|
||||
</p>
|
||||
</>
|
||||
)}
|
||||
|
||||
<div className="mt-5 flex justify-between gap-2">
|
||||
<button onClick={schliessen} className="rounded-lg border border-white/15 px-4 py-1.5 text-xs text-dunst hover:text-schnee">
|
||||
Abbrechen
|
||||
</button>
|
||||
<button
|
||||
onClick={() => {
|
||||
ripStarten(
|
||||
id,
|
||||
gewaehlteTitel.map((t) => {
|
||||
const wahl = sprachenVon(t)
|
||||
return {
|
||||
nr: t.nr,
|
||||
rolle: rolleVon(t),
|
||||
dauerS: t.dauerS,
|
||||
groesseBytes: t.groesseBytes,
|
||||
audioSprachen: wahl.audio,
|
||||
untertitelSprachen: wahl.untertitel,
|
||||
}
|
||||
}),
|
||||
{ staffel: alsSerie ? staffelZahl : null, ersteFolge: alsSerie ? folgeZahl : null },
|
||||
)
|
||||
schliessen()
|
||||
}}
|
||||
disabled={aktiv.size === 0 || stand === undefined || stand.laeuft || platz.hart}
|
||||
className={KNOPF_GOLD}
|
||||
title={platz.hart ? platz.text : ''}
|
||||
>
|
||||
{aktiv.size === 1 ? 'Diesen Titel rippen' : `${aktiv.size} Titel rippen`}
|
||||
</button>
|
||||
</div>
|
||||
</DialogRahmen>
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,262 @@
|
||||
// ── Erst-Einrichtung (§ 6.9): nach der Installation, im Programm ────────
|
||||
// Zwei Regeln aus dem alten Setup: NUR ein Fehler blockiert (kein
|
||||
// Laufwerk ist eine WARNUNG — eine reine Komprimier-Maschine ist ein
|
||||
// vorgesehener Betriebsfall), und Erfolg wird am BESTAND gemessen.
|
||||
// 5.5.0: dieselben Bausteine wie die Einstellungen (Commander: „All diese
|
||||
// Dinge müssen auch in den FirstRun mit rein") — Ablage und Arbeitsordner,
|
||||
// Werkzeuge mit Durchsuchen, Kompression mit Sprach-Auswahl, TMDb,
|
||||
// Benachrichtigung, Automatik und Roh-Regel. Dazu der Poster-Hintergrund.
|
||||
import { useEffect, useState } from 'react'
|
||||
import { DEFAULT_HB_PRESET, presetEmpfehlung } from '../../gemeinsam/preset-empfehlung'
|
||||
import { Badge, FELD_KLASSE, Feld, KNOPF_GOLD, KNOPF_LEISE, PfadFeld, Schalter, gbKurz } from '../bausteine'
|
||||
import { SprachAuswahl } from '../einstellungen/SprachAuswahl'
|
||||
import { benachrichtigungTesten, einstellungSetzen, posterLaden, speicherLaden, type Verbindung } from '../kernverbindung'
|
||||
import { PosterHintergrund } from './PosterHintergrund'
|
||||
|
||||
const SCHRITTE = ['Willkommen', 'Prüfung', 'Ordner', 'Qualität', 'Titel', 'Meldungen', 'Automatik', 'Fertig']
|
||||
|
||||
export function ErstEinrichtung({ verbindung }: { verbindung: Verbindung }) {
|
||||
const [schritt, setSchritt] = useState(0)
|
||||
const werte = verbindung.einstellungen
|
||||
const werkzeuge = verbindung.werkzeuge
|
||||
const speicher = verbindung.speicher
|
||||
const setzen = einstellungSetzen
|
||||
const makemkvFehlt = werkzeuge !== null && werkzeuge.makemkvcon.length === 0
|
||||
const tmdbDa = (werte['tmdbApiKey'] ?? '').length > 0
|
||||
|
||||
// Poster, sobald ein TMDb-Schlüssel da ist — auch, wenn er gerade erst
|
||||
// eingetragen wurde.
|
||||
useEffect(() => {
|
||||
if (tmdbDa) posterLaden()
|
||||
}, [tmdbDa])
|
||||
useEffect(() => {
|
||||
speicherLaden()
|
||||
}, [schritt])
|
||||
|
||||
const pruefzeilen: Array<{ ok: boolean | null; pflicht: boolean; text: string }> = [
|
||||
{
|
||||
ok: werkzeuge === null ? null : werkzeuge.makemkvcon.length > 0,
|
||||
pflicht: true,
|
||||
text:
|
||||
werkzeuge === null
|
||||
? 'MakeMKV wird gesucht …'
|
||||
: werkzeuge.makemkvcon.length > 0
|
||||
? `MakeMKV gefunden: ${werkzeuge.makemkvcon}`
|
||||
: 'MakeMKV FEHLT — ohne makemkvcon kann Rippy keine Video-Disc lesen. Von makemkv.com/download installieren, dann findet Rippy es von selbst — oder unten den Pfad wählen.',
|
||||
},
|
||||
{
|
||||
ok: werkzeuge === null ? null : werkzeuge.handbrake.length > 0,
|
||||
pflicht: false,
|
||||
text: werkzeuge === null ? 'HandBrakeCLI wird gesucht …' : werkzeuge.handbrake.length > 0 ? `HandBrakeCLI dabei: ${werkzeuge.handbrake}` : 'HandBrakeCLI fehlt — Rippen geht, Komprimieren nicht.',
|
||||
},
|
||||
{
|
||||
ok: werkzeuge === null ? null : werkzeuge.flac.length > 0,
|
||||
pflicht: false,
|
||||
text: werkzeuge === null ? 'FLAC wird gesucht …' : werkzeuge.flac.length > 0 ? `FLAC dabei: ${werkzeuge.flac}` : 'FLAC fehlt — nur für Audio-CDs nötig.',
|
||||
},
|
||||
{
|
||||
ok: verbindung.laufwerke.length > 0 ? true : null,
|
||||
pflicht: false,
|
||||
text:
|
||||
verbindung.laufwerke.length > 0
|
||||
? `${verbindung.laufwerke.length} optisches Laufwerk gefunden (${verbindung.laufwerke.map((l) => l.id + ':').join(', ')})`
|
||||
: 'Kein optisches Laufwerk — nur eine Warnung: Eine reine Komprimier-Maschine ist ein vorgesehener Betriebsfall.',
|
||||
},
|
||||
]
|
||||
|
||||
// Was Rippy an DIESER Maschine gemessen hat — die Grundlage der
|
||||
// Preset-Empfehlung (Commander-Fund 01.09.2026: sie war unsichtbar).
|
||||
const backends = werkzeuge?.backends ?? []
|
||||
const presets = werkzeuge?.presets ?? []
|
||||
const nurCpu = backends.length > 0 && backends.every((b) => b.startsWith('cpu'))
|
||||
const EMPFEHLUNGEN: ReadonlyArray<readonly [string, string]> = [
|
||||
['DVD', 'dvd'],
|
||||
['Blu-ray', 'bluray'],
|
||||
['4K-UHD', 'uhd'],
|
||||
]
|
||||
|
||||
return (
|
||||
<>
|
||||
<PosterHintergrund pfade={verbindung.poster} />
|
||||
<div className="relative mx-auto max-w-2xl space-y-7 rounded-2xl border border-white/10 bg-buehne/80 p-6 pt-5 shadow-2xl shadow-black/60 backdrop-blur">
|
||||
<div className="flex flex-wrap gap-2">
|
||||
{SCHRITTE.map((name, i) => (
|
||||
<span
|
||||
key={name}
|
||||
className={`rounded-full px-3 py-1 text-xs ${i === schritt ? 'border border-gold/40 bg-gold/15 text-gold-hell' : i < schritt ? 'text-gruen' : 'text-nebel'}`}
|
||||
>
|
||||
{i + 1} {name}
|
||||
</span>
|
||||
))}
|
||||
</div>
|
||||
|
||||
{schritt === 0 && (
|
||||
<div className="space-y-3 text-sm text-dunst">
|
||||
<h2 className="font-display text-3xl font-bold text-schnee">Willkommen bei Rippy</h2>
|
||||
<p>Rippy sichert deine DVDs, Blu-rays und Audio-CDs — erst verlustfrei, dann komprimiert.</p>
|
||||
<p>Disc rein genügt: Rippy erkennt, was drauf ist, und startet bei sicherer Erkennung von selbst.</p>
|
||||
<p>Fertige Filme landen so abgelegt, dass Jellyfin, Emby, Kodi und Plex sie sofort erkennen.</p>
|
||||
<p>Rippy prüft gleich seine Werkzeuge und fragt dich danach ein paar Dinge: wohin, wie schnell, woher die Titel kommen, wie es sich meldet. Dauert zwei Minuten — ändern kannst du alles später.</p>
|
||||
</div>
|
||||
)}
|
||||
|
||||
{schritt === 1 && (
|
||||
<div className="space-y-3">
|
||||
<div className="space-y-2">
|
||||
{pruefzeilen.map((zeile, i) => (
|
||||
<p key={i} className={`font-mono text-xs ${zeile.ok === true ? 'text-gruen' : zeile.ok === null ? 'text-nebel' : zeile.pflicht ? 'text-rot' : 'text-warn'}`}>
|
||||
{zeile.ok === true ? '✓' : zeile.ok === null ? '…' : zeile.pflicht ? '✗' : '⚠'} {zeile.text}
|
||||
</p>
|
||||
))}
|
||||
</div>
|
||||
{makemkvFehlt && (
|
||||
<PfadFeld
|
||||
name="makemkvcon.exe von Hand wählen"
|
||||
hinweis="falls MakeMKV an einem ungewöhnlichen Ort liegt"
|
||||
wert={werte['werkzeug.makemkv'] ?? ''}
|
||||
art="programm"
|
||||
dialogTitel="makemkvcon.exe wählen"
|
||||
aufAendern={(w) => setzen('werkzeug.makemkv', w)}
|
||||
/>
|
||||
)}
|
||||
</div>
|
||||
)}
|
||||
|
||||
{schritt === 2 && (
|
||||
<div className="space-y-4">
|
||||
<p className="text-sm text-dunst">Wohin sollen fertige Filme, Musik und Abbilder? Ein Netzlaufwerk geht — Rippy baut darin selbst die Struktur.</p>
|
||||
<PfadFeld name="Ablage-Ordner" wert={werte['ablage'] ?? ''} art="ordner" dialogTitel="Ablage-Ordner wählen" aufAendern={(w) => setzen('ablage', w)} />
|
||||
{speicher !== null && speicher.ablage.ok && <p className="font-mono text-[10.5px] text-nebel">{gbKurz(speicher.ablage.freiBytes)} frei von {gbKurz(speicher.ablage.gesamtBytes)}</p>}
|
||||
<p className="text-sm text-dunst">
|
||||
Liegt die Ablage auf einem Server, wähle einen <span className="text-schnee">Arbeitsordner auf einer lokalen Platte</span>: Dort liegen die Roh-Dateien
|
||||
(30 GB und mehr je Blu-ray) und dort rechnet HandBrake. Nur das fertige Ergebnis wandert übers Netz.
|
||||
</p>
|
||||
<PfadFeld
|
||||
name="Arbeitsordner (lokal, optional)"
|
||||
hinweis="leer = unter der Ablage"
|
||||
wert={werte['arbeitsordner'] ?? ''}
|
||||
art="ordner"
|
||||
dialogTitel="Arbeitsordner wählen (lokale Platte)"
|
||||
aufAendern={(w) => setzen('arbeitsordner', w)}
|
||||
/>
|
||||
{speicher !== null && speicher.getrennt && speicher.arbeit.ok && (
|
||||
<p className="font-mono text-[10.5px] text-nebel">{gbKurz(speicher.arbeit.freiBytes)} frei von {gbKurz(speicher.arbeit.gesamtBytes)} — eine Blu-ray braucht rund 50 GB.</p>
|
||||
)}
|
||||
</div>
|
||||
)}
|
||||
|
||||
{schritt === 3 && (
|
||||
<div className="space-y-4">
|
||||
<p className="text-sm text-dunst">Rippy sichert eine Disc immer erst verlustfrei. Danach kann es eine kleinere Fassung berechnen — die kostet Zeit, spart aber viel Platz.</p>
|
||||
<Schalter an={werte['transcodeEnabled'] !== 'false'} aufWechsel={(an) => setzen('transcodeEnabled', an ? 'true' : 'false')} label="Nach dem Rip automatisch komprimieren" />
|
||||
<div className="rounded-xl border border-white/8 bg-samt/50 p-3">
|
||||
{werkzeuge === null ? (
|
||||
<p className="font-mono text-xs text-nebel">Encoder werden gemessen …</p>
|
||||
) : backends.length === 0 ? (
|
||||
<p className="font-mono text-xs text-warn">Keine Encoder gemessen — ohne HandBrakeCLI bleibt es beim verlustfreien Rip.</p>
|
||||
) : (
|
||||
<>
|
||||
<div className="flex flex-wrap items-center gap-1.5">
|
||||
<span className="font-mono text-[10px] tracking-wider text-nebel">AUF DIESER MASCHINE GEMESSEN:</span>
|
||||
{backends.map((backend) => (
|
||||
<Badge key={backend} text={backend} ton={backend.startsWith('cpu') ? 'grau' : 'blau'} />
|
||||
))}
|
||||
</div>
|
||||
<p className="mt-2 text-xs text-dunst">Danach wählt Rippy von selbst — Grafikkarte vor CPU, wo es eine gibt:</p>
|
||||
<div className="mt-2 grid gap-2 sm:grid-cols-3">
|
||||
{EMPFEHLUNGEN.map(([name, typ]) => (
|
||||
<div key={typ} className="rounded-lg border border-white/8 bg-buehne/60 p-2">
|
||||
<p className="font-mono text-[10px] tracking-wider text-nebel">{name}</p>
|
||||
<p className="mt-0.5 font-mono text-xs text-gold-hell">{presetEmpfehlung(typ, backends, presets) || DEFAULT_HB_PRESET}</p>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
{nurCpu && <p className="mt-2 text-xs text-warn">Nur CPU-Encoder gefunden — das Komprimieren dauert dann deutlich länger. Der verlustfreie Rip ist davon nicht betroffen.</p>}
|
||||
</>
|
||||
)}
|
||||
</div>
|
||||
<div className="grid gap-3 sm:grid-cols-2">
|
||||
<SprachAuswahl name="Tonspuren" hinweis="die erste ist deine Sprache" wert={werte['audioSprachen'] ?? ''} aufAendern={(w) => setzen('audioSprachen', w)} />
|
||||
<SprachAuswahl name="Untertitel" hinweis="vorgewählt bei fremdem Ton" wert={werte['untertitelSprachen'] ?? ''} aufAendern={(w) => setzen('untertitelSprachen', w)} />
|
||||
</div>
|
||||
<p className="text-xs text-nebel">Je Disc-Typ ein eigenes Preset geht später unter „Einstellungen → Kompression" — deine Wahl schlägt die Empfehlung immer.</p>
|
||||
</div>
|
||||
)}
|
||||
|
||||
{schritt === 4 && (
|
||||
<div className="space-y-3">
|
||||
<p className="text-sm text-dunst">Woher sollen Titel, Jahr, Poster und Beschreibung kommen? Dafür braucht Rippy einen kostenlosen TMDb-Schlüssel.</p>
|
||||
<Feld name="TMDb-API-Key" hinweis="kostenlos auf themoviedb.org → Einstellungen → API; in zwei Minuten geholt" wert={werte['tmdbApiKey'] ?? ''} aufAendern={(w) => setzen('tmdbApiKey', w)} />
|
||||
{tmdbDa && verbindung.poster.length > 0 && <p className="font-mono text-xs text-gruen">✓ Der Schlüssel funktioniert — die Poster im Hintergrund kommen von TMDb.</p>}
|
||||
<p className="text-xs text-nebel">Ohne Schlüssel rippt Rippy trotzdem — die Filme heißen dann so, wie die Disc sich selbst nennt, und es gibt keine Poster. Nachtragen geht jederzeit unter „Einstellungen → Metadaten".</p>
|
||||
</div>
|
||||
)}
|
||||
|
||||
{schritt === 5 && (
|
||||
<div className="space-y-3">
|
||||
<p className="text-sm text-dunst">Soll Rippy sich aufs Handy melden, wenn ein Rip fertig ist oder etwas schiefgeht? Windows-Meldungen kommen immer — das hier ist freiwillig.</p>
|
||||
<Feld name="Discord-Webhook" hinweis="Servereinstellungen → Integrationen → Webhooks" geheim wert={werte['discordWebhook'] ?? ''} aufAendern={(w) => setzen('discordWebhook', w)} />
|
||||
<div className="grid gap-3 sm:grid-cols-2">
|
||||
<Feld name="Telegram-Bot-Token" hinweis="von @BotFather" geheim wert={werte['telegramToken'] ?? ''} aufAendern={(w) => setzen('telegramToken', w)} />
|
||||
<Feld name="Telegram-Chat-ID" wert={werte['telegramChatId'] ?? ''} aufAendern={(w) => setzen('telegramChatId', w)} />
|
||||
</div>
|
||||
<button onClick={() => benachrichtigungTesten()} className={KNOPF_LEISE}>
|
||||
Testnachricht schicken
|
||||
</button>
|
||||
</div>
|
||||
)}
|
||||
|
||||
{schritt === 6 && (
|
||||
<div className="space-y-4">
|
||||
<p className="text-sm text-dunst">Wie selbstständig soll Rippy sein?</p>
|
||||
<Schalter an={werte['automatik'] !== 'aus'} aufWechsel={(an) => setzen('automatik', an ? 'an' : 'aus')} label="Automatik: bei sicherer Erkennung (ab 90 %) nach einem Countdown von selbst rippen — mit Stopp-Knopf" />
|
||||
<label className="block max-w-xs">
|
||||
<span className="text-xs font-semibold text-dunst">Countdown</span>
|
||||
<select value={werte['automatikSekunden'] ?? '30'} onChange={(e) => setzen('automatikSekunden', e.target.value)} className={FELD_KLASSE}>
|
||||
<option value="10">10 Sekunden</option>
|
||||
<option value="30">30 Sekunden (Vorgabe)</option>
|
||||
<option value="60">1 Minute</option>
|
||||
<option value="120">2 Minuten</option>
|
||||
</select>
|
||||
</label>
|
||||
<Schalter an={werte['autoAuswurf'] !== 'false'} aufWechsel={(an) => setzen('autoAuswurf', an ? 'true' : 'false')} label="Disc nach dem Rip auswerfen — die nächste kann rein, während die Kompression läuft" />
|
||||
<label className="block max-w-sm">
|
||||
<span className="text-xs font-semibold text-dunst">Roh-Dateien nach gelungener Kompression</span>
|
||||
<select value={werte['rohAufbewahrung'] ?? '7'} onChange={(e) => setzen('rohAufbewahrung', e.target.value)} className={FELD_KLASSE}>
|
||||
<option value="sofort">sofort löschen</option>
|
||||
<option value="7">nach 7 Tagen löschen (Vorgabe)</option>
|
||||
<option value="14">nach 14 Tagen löschen</option>
|
||||
<option value="30">nach 30 Tagen löschen</option>
|
||||
<option value="behalten">behalten — nur von Hand löschen</option>
|
||||
</select>
|
||||
</label>
|
||||
<p className="text-xs text-nebel">Die Roh-Dateien sind der Grund, warum ein Preset-Wechsel kein Neulesen kostet — und gelöscht wird nur, wenn das fertige Ergebnis nachweislich da ist.</p>
|
||||
</div>
|
||||
)}
|
||||
|
||||
{schritt === 7 && (
|
||||
<div className="space-y-3 text-sm text-dunst">
|
||||
<p>Das war's. Disc einlegen — Rippy meldet sich.</p>
|
||||
<p className="text-xs text-nebel">Rippy lebt im Infobereich neben der Uhr: Fenster zu heißt weiterlaufen, beendet wird über das Tray-Menü.</p>
|
||||
{makemkvFehlt && <p className="text-xs text-rot">Denk an MakeMKV: Ohne makemkvcon bleibt der Video-Weg zu (Einstellungen → Werkzeuge zeigt den Stand, sobald es installiert ist).</p>}
|
||||
</div>
|
||||
)}
|
||||
|
||||
<div className="flex justify-between">
|
||||
<button onClick={() => setSchritt((s) => Math.max(0, s - 1))} disabled={schritt === 0} className="rounded-lg border border-white/15 px-4 py-1.5 text-xs text-dunst hover:text-schnee disabled:opacity-35">
|
||||
Zurück
|
||||
</button>
|
||||
{schritt < SCHRITTE.length - 1 ? (
|
||||
<button onClick={() => setSchritt((s) => s + 1)} className={KNOPF_GOLD}>
|
||||
Weiter
|
||||
</button>
|
||||
) : (
|
||||
<button onClick={() => setzen('setup.done', 'true')} className={KNOPF_GOLD}>
|
||||
Los geht's
|
||||
</button>
|
||||
)}
|
||||
</div>
|
||||
</div>
|
||||
</>
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
// Der Poster-Hintergrund der Erst-Einrichtung (5.5.0, Commander: „diverse
|
||||
// Movie Cover die … im Hintergrund in nem Grid langsam von oben nach unten
|
||||
// laufen"). Vor dem TMDb-Schlüssel ein ruhiges Raster leerer Film-Karten,
|
||||
// danach echte Poster beliebter Filme (kern: erkennung.posterLaden). Die
|
||||
// Spalten laufen langsam, jede in eigenem Tempo, die Liste ist verdoppelt,
|
||||
// damit der Lauf nahtlos ist (Keyframes in stil.css: poster-lauf).
|
||||
import { IconDisc, posterUrlGross } from '../bausteine'
|
||||
|
||||
const SPALTEN = 7
|
||||
const JE_SPALTE = 6
|
||||
|
||||
export function PosterHintergrund({ pfade }: { pfade: string[] }) {
|
||||
const spalten: string[][] = Array.from({ length: SPALTEN }, () => [])
|
||||
pfade.forEach((p, i) => spalten[i % SPALTEN].push(p))
|
||||
return (
|
||||
<div className="pointer-events-none fixed inset-0 overflow-hidden" aria-hidden="true">
|
||||
<div className="absolute inset-0 flex gap-4 px-4 opacity-[0.5]">
|
||||
{spalten.map((spalte, i) => {
|
||||
// Auffüllen mit leeren Karten, damit jede Spalte voll ist.
|
||||
const karten: Array<string | null> = [...spalte]
|
||||
while (karten.length < JE_SPALTE) karten.push(null)
|
||||
const doppelt = [...karten, ...karten]
|
||||
return (
|
||||
<div
|
||||
key={i}
|
||||
className="poster-spalte flex flex-1 flex-col gap-4"
|
||||
style={{
|
||||
animationDuration: `${70 + (i % 3) * 25}s`,
|
||||
animationDelay: `${-i * 9}s`,
|
||||
marginTop: `${(i % 2) * -120}px`,
|
||||
}}
|
||||
>
|
||||
{doppelt.map((p, j) =>
|
||||
p !== null ? (
|
||||
<img key={j} src={posterUrlGross(p)} alt="" className="aspect-[2/3] w-full rounded-xl object-cover ring-1 ring-gold/25" loading="lazy" />
|
||||
) : (
|
||||
<div key={j} className="flex aspect-[2/3] w-full items-center justify-center rounded-xl bg-gradient-to-br from-[oklch(0.27_0.03_75)] to-[oklch(0.19_0.02_75)] ring-1 ring-gold/30">
|
||||
<IconDisc groesse={28} farbe="oklch(0.6 0.08 75)" />
|
||||
</div>
|
||||
),
|
||||
)}
|
||||
</div>
|
||||
)
|
||||
})}
|
||||
</div>
|
||||
{/* Der Verlauf ins Bühnen-Schwarz — die Poster bleiben Kulisse, der
|
||||
Assistent bleibt lesbar. */}
|
||||
<div className="absolute inset-0 bg-gradient-to-b from-buehne/35 via-buehne/55 to-buehne/90" />
|
||||
</div>
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,83 @@
|
||||
// Die Einstellungen — Sektionswahl links (oder oben im schmalen Fenster),
|
||||
// die Karten rechts. Jede Karte ist eine Datei in Karten.tsx (5.5.0).
|
||||
import { useEffect, useState } from 'react'
|
||||
import type { HauptStatus } from '../../gemeinsam/nachrichten'
|
||||
import type { Verbindung } from '../kernverbindung'
|
||||
import {
|
||||
AblageKarte,
|
||||
AllgemeinKarte,
|
||||
AutomatikKarte,
|
||||
BenachrichtigungKarte,
|
||||
KompressionKarte,
|
||||
MakemkvKarte,
|
||||
MedienserverKarte,
|
||||
MetadatenKarte,
|
||||
RohDateienKarte,
|
||||
UpdateKarte,
|
||||
WerkzeugeKarte,
|
||||
} from './Karten'
|
||||
|
||||
const SEKTIONEN: Array<[string, string]> = [
|
||||
['ablage', 'Ablage'],
|
||||
['kompression', 'Kompression'],
|
||||
['roh', 'Roh-Dateien'],
|
||||
['automatik', 'Automatik'],
|
||||
['metadaten', 'Metadaten'],
|
||||
['makemkv', 'MakeMKV'],
|
||||
['medienserver', 'Medienserver'],
|
||||
['benachrichtigung', 'Benachrichtigung'],
|
||||
['allgemein', 'Allgemein'],
|
||||
['update', 'Update'],
|
||||
['werkzeuge', 'Werkzeuge'],
|
||||
]
|
||||
|
||||
export function Einstellungen({ verbindung, haupt, start }: { verbindung: Verbindung; haupt: HauptStatus | null; start?: string }) {
|
||||
const [aktiv, setAktiv] = useState(start ?? 'ablage')
|
||||
|
||||
const springe = (id: string): void => {
|
||||
setAktiv(id)
|
||||
document.getElementById(id)?.scrollIntoView({ behavior: 'smooth', block: 'start' })
|
||||
}
|
||||
// „alle unter Roh-Dateien →" aus der Übersicht springt direkt zur Karte.
|
||||
useEffect(() => {
|
||||
if (start !== undefined) setTimeout(() => springe(start), 50)
|
||||
// eslint-disable-next-line react-hooks/exhaustive-deps
|
||||
}, [start])
|
||||
|
||||
// Schmales Fenster: die Sektionswahl legt sich als Zeile über die Karten.
|
||||
// Ab lg steht sie wieder als mitlaufende Spalte daneben (Commander-Fund
|
||||
// 01.09.2026: „alles gequetscht").
|
||||
return (
|
||||
<div className="flex flex-col gap-5 lg:flex-row lg:gap-8">
|
||||
<nav className="flex flex-row flex-wrap gap-1 lg:sticky lg:top-4 lg:h-fit lg:w-44 lg:flex-none lg:flex-col">
|
||||
{SEKTIONEN.map(([id, name]) => (
|
||||
<button
|
||||
key={id}
|
||||
onClick={() => springe(id)}
|
||||
className={`rounded-lg px-3 py-1.5 text-left text-[13px] ${
|
||||
aktiv === id ? 'border border-gold/40 bg-gold/12 font-semibold text-gold-hell' : 'border border-transparent text-dunst hover:bg-white/5 hover:text-schnee'
|
||||
}`}
|
||||
>
|
||||
{name}
|
||||
</button>
|
||||
))}
|
||||
</nav>
|
||||
|
||||
{/* Kein max-w mehr: Der 672-px-Deckel war der Grund, warum in einem
|
||||
breiten Fenster alles links klebte und rechts nichts stand. */}
|
||||
<div className="min-w-0 flex-1 space-y-5">
|
||||
<AblageKarte verbindung={verbindung} />
|
||||
<KompressionKarte verbindung={verbindung} />
|
||||
<RohDateienKarte verbindung={verbindung} aktivFuer={start === 'roh'} />
|
||||
<AutomatikKarte verbindung={verbindung} />
|
||||
<MetadatenKarte verbindung={verbindung} />
|
||||
<MakemkvKarte verbindung={verbindung} />
|
||||
<MedienserverKarte verbindung={verbindung} />
|
||||
<BenachrichtigungKarte verbindung={verbindung} />
|
||||
<AllgemeinKarte verbindung={verbindung} haupt={haupt} />
|
||||
<UpdateKarte verbindung={verbindung} haupt={haupt} />
|
||||
<WerkzeugeKarte verbindung={verbindung} />
|
||||
</div>
|
||||
</div>
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,656 @@
|
||||
// Die Einstellungs-Karten (5.5.0, je Karte eine Funktion): Ablage,
|
||||
// Kompression, Roh-Dateien, Automatik, Metadaten, MakeMKV, Medienserver,
|
||||
// Benachrichtigung, Allgemein, Update, Werkzeuge. Alle schreiben über
|
||||
// einstellungSetzen in die EINE Quelle (§ 6.7).
|
||||
import { useState } from 'react'
|
||||
import type { GeraeteInfo, HauptStatus, VorgangEintrag } from '../../gemeinsam/nachrichten'
|
||||
import { presetEmpfehlung } from '../../gemeinsam/preset-empfehlung'
|
||||
import {
|
||||
Badge,
|
||||
FELD_KLASSE,
|
||||
Feld,
|
||||
HinterlegtPunkt,
|
||||
KNOPF_LEISE,
|
||||
LAUFENDE_PHASEN,
|
||||
PfadFeld,
|
||||
Schalter,
|
||||
SektionsKarte,
|
||||
TYP_NAMEN,
|
||||
datumKurz,
|
||||
gb,
|
||||
gbKurz,
|
||||
} from '../bausteine'
|
||||
import {
|
||||
benachrichtigungTesten,
|
||||
einstellungSetzen,
|
||||
fremdenOrdnerLoeschen,
|
||||
kompressionAbbrechen,
|
||||
makemkvUpdate,
|
||||
rohAufraeumen,
|
||||
schluesselPruefen,
|
||||
vorgaengeLaden,
|
||||
vorgangNeuKomprimieren,
|
||||
vorgangRohLoeschen,
|
||||
type Verbindung,
|
||||
} from '../kernverbindung'
|
||||
import { phasenTon } from '../uebersicht/VerlaufKarte'
|
||||
import { SprachAuswahl } from './SprachAuswahl'
|
||||
|
||||
const setzen = einstellungSetzen
|
||||
|
||||
export function AblageKarte({ verbindung }: { verbindung: Verbindung }) {
|
||||
const werte = verbindung.einstellungen
|
||||
const speicher = verbindung.speicher
|
||||
return (
|
||||
<SektionsKarte
|
||||
id="ablage"
|
||||
titel="ABLAGE"
|
||||
intro="Die Ablage ist, wo Fertiges landet — auch ein Netzlaufwerk. Der Arbeitsordner ist, wo Rippy rechnet: Roh-Dateien und Kompression. Liegt die Ablage auf dem Server, gehört der Arbeitsordner auf eine lokale Platte."
|
||||
>
|
||||
<PfadFeld name="Ablage-Ordner" wert={werte['ablage'] ?? ''} art="ordner" dialogTitel="Ablage-Ordner wählen" aufAendern={(w) => setzen('ablage', w)} />
|
||||
{speicher !== null && speicher.ablage.ok && (
|
||||
<p className="font-mono text-[10.5px] text-nebel">
|
||||
{gbKurz(speicher.ablage.freiBytes)} frei von {gbKurz(speicher.ablage.gesamtBytes)}
|
||||
</p>
|
||||
)}
|
||||
<PfadFeld
|
||||
name="Arbeitsordner (lokal, optional)"
|
||||
hinweis="leer = unter der Ablage; Roh-Dateien und Kompression liegen dann dort"
|
||||
wert={werte['arbeitsordner'] ?? ''}
|
||||
art="ordner"
|
||||
dialogTitel="Arbeitsordner wählen (lokale Platte)"
|
||||
aufAendern={(w) => setzen('arbeitsordner', w)}
|
||||
/>
|
||||
{speicher !== null && speicher.getrennt && speicher.arbeit.ok && (
|
||||
<p className="font-mono text-[10.5px] text-nebel">
|
||||
{gbKurz(speicher.arbeit.freiBytes)} frei von {gbKurz(speicher.arbeit.gesamtBytes)} — eine Blu-ray braucht rund 50 GB.
|
||||
</p>
|
||||
)}
|
||||
<div className="rounded-xl border border-white/8 bg-buehne/60 p-3 font-mono text-[11px] leading-5 text-nebel">
|
||||
<p className="text-dunst">So legt Rippy ab:</p>
|
||||
<p>
|
||||
├─ Filme\Akira (1988)\ <span className="text-nebel/70">— Film, Poster und Infodatei beieinander</span>
|
||||
</p>
|
||||
<p>
|
||||
├─ Serien\Spartacus\Season 01\ <span className="text-nebel/70">— Folgen, wie Jellyfin sie erwartet</span>
|
||||
</p>
|
||||
<p>
|
||||
├─ Musik\ <span className="text-nebel/70">— Audio-CDs als FLAC, benannt nach MusicBrainz</span>
|
||||
</p>
|
||||
<p>
|
||||
├─ ISO\ <span className="text-nebel/70">— unerkannte Discs als 1:1-Abbild</span>
|
||||
</p>
|
||||
<p>
|
||||
└─ roh\ <span className="text-nebel/70">— im Arbeitsordner: verlustfreies Roh-Material, aufgeräumt nach der Regel unter „Roh-Dateien"</span>
|
||||
</p>
|
||||
</div>
|
||||
<Schalter
|
||||
an={werte['autoAuswurf'] !== 'false'}
|
||||
aufWechsel={(an) => setzen('autoAuswurf', an ? 'true' : 'false')}
|
||||
label="Disc nach dem Rip auswerfen — die nächste kann rein, während die Kompression läuft"
|
||||
/>
|
||||
</SektionsKarte>
|
||||
)
|
||||
}
|
||||
|
||||
function PresetWahl({
|
||||
name,
|
||||
schluessel,
|
||||
wert,
|
||||
presets,
|
||||
empfehlung,
|
||||
}: {
|
||||
name: string
|
||||
schluessel: string
|
||||
wert: string
|
||||
presets: string[]
|
||||
empfehlung: string
|
||||
}) {
|
||||
return (
|
||||
<label className="block">
|
||||
<span className="text-xs font-semibold text-dunst">{name}</span>
|
||||
<select value={wert} onChange={(e) => setzen(schluessel, e.target.value)} className={FELD_KLASSE}>
|
||||
<option value="">{empfehlung.length > 0 ? `automatisch: ${empfehlung}` : 'automatisch'}</option>
|
||||
<option value="keine">NICHT komprimieren (verlustfrei lassen)</option>
|
||||
{presets.map((preset) => (
|
||||
<option key={preset} value={preset}>
|
||||
{preset}
|
||||
</option>
|
||||
))}
|
||||
</select>
|
||||
</label>
|
||||
)
|
||||
}
|
||||
|
||||
export function KompressionKarte({ verbindung }: { verbindung: Verbindung }) {
|
||||
const werte = verbindung.einstellungen
|
||||
const presets = verbindung.werkzeuge?.presets ?? []
|
||||
const backends = verbindung.werkzeuge?.backends ?? []
|
||||
const empfehlungFuer = (typ: string): string => presetEmpfehlung(typ, backends, presets)
|
||||
return (
|
||||
<SektionsKarte
|
||||
id="kompression"
|
||||
titel="KOMPRESSION"
|
||||
intro="Nach dem verlustfreien Rip rechnet HandBrake die Filme auf Arbeitsgröße — der Rohling bleibt bis zum Erfolg liegen, es geht nie etwas verloren."
|
||||
>
|
||||
{verbindung.werkzeuge !== null && verbindung.werkzeuge.handbrake.length === 0 && (
|
||||
<p className="font-mono text-xs text-warn">⚠ HandBrakeCLI fehlt — Rippen geht, Komprimieren nicht (siehe Werkzeuge).</p>
|
||||
)}
|
||||
<Schalter an={werte['transcodeEnabled'] !== 'false'} aufWechsel={(an) => setzen('transcodeEnabled', an ? 'true' : 'false')} label="Nach dem Rip automatisch komprimieren" />
|
||||
{backends.length > 0 && (
|
||||
<div className="flex flex-wrap items-center gap-1.5">
|
||||
<span className="font-mono text-[10px] tracking-wider text-nebel">GEMESSENE ENCODER:</span>
|
||||
{backends.map((backend) => (
|
||||
<Badge key={backend} text={backend} ton={backend.startsWith('cpu') ? 'grau' : 'blau'} />
|
||||
))}
|
||||
</div>
|
||||
)}
|
||||
<div className="grid gap-3 sm:grid-cols-3">
|
||||
<PresetWahl name="DVD" schluessel="transcodePresetDvd" wert={werte['transcodePresetDvd'] ?? ''} presets={presets} empfehlung={empfehlungFuer('dvd')} />
|
||||
<PresetWahl name="Blu-ray" schluessel="transcodePresetBluray" wert={werte['transcodePresetBluray'] ?? ''} presets={presets} empfehlung={empfehlungFuer('bluray')} />
|
||||
<PresetWahl name="4K-UHD" schluessel="transcodePresetUhd" wert={werte['transcodePresetUhd'] ?? ''} presets={presets} empfehlung={empfehlungFuer('uhd')} />
|
||||
</div>
|
||||
<p className="text-[11px] leading-4 text-nebel">
|
||||
„automatisch" nimmt die Empfehlung aus der gemessenen Liste deines HandBrake — auf dieser Maschine die Grafikkarte, wo es sie gibt. Eine eigene Wahl
|
||||
schlägt die Empfehlung immer.
|
||||
</p>
|
||||
<div className="grid gap-3 sm:grid-cols-2">
|
||||
<SprachAuswahl
|
||||
name="Tonspuren"
|
||||
hinweis="Reihenfolge = Wunschreihenfolge; die erste ist deine Sprache"
|
||||
wert={werte['audioSprachen'] ?? ''}
|
||||
aufAendern={(w) => setzen('audioSprachen', w)}
|
||||
/>
|
||||
<SprachAuswahl name="Untertitel" hinweis="werden vorgewählt, wenn der Ton nicht deine Sprache ist" wert={werte['untertitelSprachen'] ?? ''} aufAendern={(w) => setzen('untertitelSprachen', w)} />
|
||||
</div>
|
||||
</SektionsKarte>
|
||||
)
|
||||
}
|
||||
|
||||
export function AutomatikKarte({ verbindung }: { verbindung: Verbindung }) {
|
||||
const werte = verbindung.einstellungen
|
||||
const an = werte['automatik'] !== 'aus'
|
||||
return (
|
||||
<SektionsKarte
|
||||
id="automatik"
|
||||
titel="AUTOMATIK"
|
||||
intro="Disc rein genügt: Ist Rippy sicher, was das ist, liest es die Titel und startet nach einem Countdown von selbst — mit seinem Vorschlag. Wo es unsicher ist, wartet es auf dich."
|
||||
>
|
||||
<Schalter an={an} aufWechsel={(a) => setzen('automatik', a ? 'an' : 'aus')} label="Automatik: bei sicherer Erkennung (ab 90 %) von selbst rippen" />
|
||||
<label className="block max-w-xs">
|
||||
<span className="text-xs font-semibold text-dunst">Countdown</span>
|
||||
<select value={werte['automatikSekunden'] ?? '30'} onChange={(e) => setzen('automatikSekunden', e.target.value)} disabled={!an} className={FELD_KLASSE}>
|
||||
<option value="10">10 Sekunden</option>
|
||||
<option value="30">30 Sekunden (Vorgabe)</option>
|
||||
<option value="60">1 Minute</option>
|
||||
<option value="120">2 Minuten</option>
|
||||
</select>
|
||||
</label>
|
||||
<p className="text-[11px] leading-4 text-nebel">
|
||||
Der Countdown steht in der Laufwerks-Kachel, mit „Stopp" und „Jetzt". Eine Disc, die schon einmal gerippt wurde, startet nie von selbst.
|
||||
</p>
|
||||
</SektionsKarte>
|
||||
)
|
||||
}
|
||||
|
||||
export function RohDateienKarte({ verbindung, aktivFuer }: { verbindung: Verbindung; aktivFuer?: boolean }) {
|
||||
const werte = verbindung.einstellungen
|
||||
const v = verbindung.vorgaenge
|
||||
const [presetWahl, setPresetWahl] = useState<Record<string, string>>({})
|
||||
const [alleZeigen, setAlleZeigen] = useState(aktivFuer === true)
|
||||
const presets = verbindung.werkzeuge?.presets ?? []
|
||||
const regelWert = werte['rohAufbewahrung'] ?? '7'
|
||||
const phasenText: Record<VorgangEintrag['phase'], string> = {
|
||||
rippt: 'rippt',
|
||||
wartet: 'wartet auf Kompression',
|
||||
komprimiert: 'komprimiert',
|
||||
'legt-ab': 'legt ab',
|
||||
fertig: 'fertig',
|
||||
fehler: 'Fehler',
|
||||
abgebrochen: 'abgebrochen',
|
||||
}
|
||||
const liste = v?.vorgaenge ?? []
|
||||
const sichtbar = alleZeigen ? liste : liste.slice(0, 12)
|
||||
|
||||
return (
|
||||
<SektionsKarte
|
||||
id="roh"
|
||||
titel="ROH-DATEIEN"
|
||||
intro="Jede Blu-ray lässt 30 GB und mehr verlustfreies Roh-Material liegen — genau dafür, dass ein Preset-Wechsel kein Neulesen kostet. Aufgeräumt wird nach Regel, und nur, wenn das fertige Ergebnis nachweislich da ist."
|
||||
>
|
||||
<div className="grid gap-3 sm:grid-cols-[1fr_auto] sm:items-end">
|
||||
<label className="block">
|
||||
<span className="text-xs font-semibold text-dunst">Nach gelungener Kompression</span>
|
||||
<select value={regelWert} onChange={(e) => setzen('rohAufbewahrung', e.target.value)} className={FELD_KLASSE}>
|
||||
<option value="sofort">sofort löschen</option>
|
||||
<option value="7">nach 7 Tagen löschen (Vorgabe)</option>
|
||||
<option value="14">nach 14 Tagen löschen</option>
|
||||
<option value="30">nach 30 Tagen löschen</option>
|
||||
<option value="behalten">behalten — nur von Hand löschen</option>
|
||||
</select>
|
||||
</label>
|
||||
<div className="flex gap-2">
|
||||
<button onClick={() => rohAufraeumen()} className={`${KNOPF_LEISE} py-2`} title="Die Regel jetzt anwenden, statt auf den täglichen Takt zu warten">
|
||||
Jetzt aufräumen
|
||||
</button>
|
||||
<button onClick={() => vorgaengeLaden()} className={`${KNOPF_LEISE} py-2`} title="Belegung neu messen">
|
||||
Aktualisieren
|
||||
</button>
|
||||
</div>
|
||||
</div>
|
||||
<div className="rounded-xl border border-white/8 bg-buehne/60 p-3 font-mono text-[11px] leading-5 text-nebel">
|
||||
{v === null ? (
|
||||
<p>Belegung wird gemessen …</p>
|
||||
) : (
|
||||
<>
|
||||
<p>
|
||||
<span className="text-dunst">Belegung jetzt:</span> <span className="text-gold-hell">{gb(v.rohGesamtBytes)}</span> in{' '}
|
||||
{liste.filter((e) => !e.rohGeloescht).length + v.fremde.length} Roh-Ordnern
|
||||
</p>
|
||||
<p>{v.regel}</p>
|
||||
<p className="text-nebel/70">Unkomprimierte Rips (z. B. 4K verlustfrei) liegen im Zielordner, nicht hier — sie sind nie betroffen.</p>
|
||||
</>
|
||||
)}
|
||||
</div>
|
||||
|
||||
{liste.length === 0 && v !== null && <p className="font-mono text-xs text-nebel">Noch kein Vorgang — der erste Rip legt hier einen Eintrag an.</p>}
|
||||
<div className="space-y-2">
|
||||
{sichtbar.map((e) => {
|
||||
const ruhig = e.phase === 'fertig' || e.phase === 'fehler' || e.phase === 'abgebrochen'
|
||||
return (
|
||||
<div key={e.id} className="rounded-xl border border-white/8 bg-buehne/60 p-3">
|
||||
<div className="flex flex-wrap items-baseline gap-x-3 gap-y-1">
|
||||
<span className="font-display text-[14px] font-bold text-schnee">
|
||||
{e.titel}
|
||||
{e.jahr !== null && <span className="ml-1 font-medium text-dunst">({e.jahr})</span>}
|
||||
</span>
|
||||
<Badge text={phasenText[e.phase]} ton={phasenTon(e.phase)} />
|
||||
<span className="font-mono text-[10.5px] text-nebel">
|
||||
{(TYP_NAMEN[e.typ as GeraeteInfo['typ']] ?? e.typ).toUpperCase()} · {datumKurz(e.begonnen)}
|
||||
{e.titelZahl > 0 && ` · ${e.titelZahl} Titel`}
|
||||
{e.preset.length > 0 && ` · ${e.preset}`}
|
||||
</span>
|
||||
</div>
|
||||
<p className="mt-1 font-mono text-[11px] leading-5 text-nebel">
|
||||
<span className="text-dunst">Roh:</span> {e.rohGeloescht ? 'gelöscht' : gb(e.rohBytes)}
|
||||
{e.faelligAm.length > 0 && ` · fällig ${datumKurz(e.faelligAm)}`}
|
||||
{' · '}
|
||||
<span className="text-dunst">Fertig:</span>{' '}
|
||||
{e.phase === 'fertig' ? (
|
||||
<span className="break-all">
|
||||
{e.fertigBytes > 0 ? `${gb(e.fertigBytes)} · ` : ''}
|
||||
{e.zielOrdner}
|
||||
{!e.komprimiert && ' (verlustfrei, ohne Kompression)'}
|
||||
</span>
|
||||
) : (
|
||||
'—'
|
||||
)}
|
||||
</p>
|
||||
{e.fehler.length > 0 && <p className="mt-1 break-all font-mono text-[11px] text-warn">⚠ {e.fehler}</p>}
|
||||
<div className="mt-2 flex flex-wrap items-center gap-2">
|
||||
{e.neuKomprimierbar && (
|
||||
<>
|
||||
<select
|
||||
value={presetWahl[e.id] ?? ''}
|
||||
onChange={(ev) => setPresetWahl({ ...presetWahl, [e.id]: ev.target.value })}
|
||||
className="rounded-lg border border-white/15 bg-samt/70 px-2 py-1 text-[11px] text-dunst"
|
||||
title="Preset für die Wiederholung — leer: wie eingestellt"
|
||||
>
|
||||
<option value="">Preset wie eingestellt</option>
|
||||
{presets.map((p) => (
|
||||
<option key={p} value={p}>
|
||||
{p}
|
||||
</option>
|
||||
))}
|
||||
</select>
|
||||
<button
|
||||
onClick={() => vorgangNeuKomprimieren(e.id, presetWahl[e.id] ?? '')}
|
||||
className="rounded-lg border border-gold/40 bg-gold/12 px-3 py-1 text-[11px] font-semibold text-gold-hell hover:bg-gold/20"
|
||||
title="Die Roh-Dateien liegen genau dafür da — kein Neulesen der Disc"
|
||||
>
|
||||
Neu komprimieren
|
||||
</button>
|
||||
</>
|
||||
)}
|
||||
{!e.rohGeloescht && ruhig && (
|
||||
<button onClick={() => vorgangRohLoeschen(e.id)} className="rounded-lg border border-rot/40 bg-rot/10 px-3 py-1 text-[11px] text-rot hover:bg-rot/20" title="Den Roh-Ordner dieses Vorgangs jetzt löschen">
|
||||
Roh-Dateien löschen
|
||||
</button>
|
||||
)}
|
||||
{e.phase === 'fertig' && e.zielOrdner.length > 0 && (
|
||||
<button onClick={() => void window.rippy.ordnerOeffnen(e.zielOrdner)} className="rounded-lg border border-white/15 px-3 py-1 text-[11px] text-dunst hover:text-schnee">
|
||||
Ordner öffnen
|
||||
</button>
|
||||
)}
|
||||
{(e.phase === 'wartet' || e.phase === 'komprimiert' || e.phase === 'legt-ab') && (
|
||||
<button onClick={() => kompressionAbbrechen(e.id)} className="rounded-lg border border-white/15 px-3 py-1 text-[11px] text-dunst hover:text-rot">
|
||||
Kompression abbrechen
|
||||
</button>
|
||||
)}
|
||||
</div>
|
||||
</div>
|
||||
)
|
||||
})}
|
||||
</div>
|
||||
{liste.length > sichtbar.length && (
|
||||
<button onClick={() => setAlleZeigen(true)} className="font-mono text-[10.5px] text-nebel hover:text-dunst">
|
||||
▸ alle {liste.length} Vorgänge zeigen
|
||||
</button>
|
||||
)}
|
||||
|
||||
{v !== null && v.fremde.length > 0 && (
|
||||
<div className="rounded-xl border border-warn/30 bg-warn/5 p-3">
|
||||
<p className="font-mono text-[10.5px] tracking-wider text-warn">ORDNER OHNE VORGANG</p>
|
||||
<p className="mt-1 text-[11px] leading-4 text-nebel">Aus der Zeit vor 5.4.0 oder von Hand hineingelegt — Rippy kennt sie nicht und löscht sie deshalb NIE von selbst.</p>
|
||||
<div className="mt-2 space-y-1">
|
||||
{v.fremde.map((f) => (
|
||||
<div key={f.ordner} className="flex items-center justify-between gap-3">
|
||||
<span className="min-w-0 break-all font-mono text-[11px] text-dunst">
|
||||
{f.ordner} · {gb(f.bytes)}
|
||||
</span>
|
||||
<button onClick={() => fremdenOrdnerLoeschen(f.ordner)} className="flex-none rounded-lg border border-rot/40 bg-rot/10 px-2.5 py-0.5 text-[10.5px] text-rot hover:bg-rot/20">
|
||||
Löschen
|
||||
</button>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
</div>
|
||||
)}
|
||||
</SektionsKarte>
|
||||
)
|
||||
}
|
||||
|
||||
export function MetadatenKarte({ verbindung }: { verbindung: Verbindung }) {
|
||||
const werte = verbindung.einstellungen
|
||||
return (
|
||||
<SektionsKarte
|
||||
id="metadaten"
|
||||
titel="METADATEN"
|
||||
intro="TMDb erkennt Titel, Jahr, Poster, Logo und Beschreibung; OMDb hilft bei Ausreißern nach. Beide Schlüssel sind kostenlos und in zwei Minuten geholt."
|
||||
>
|
||||
<div className="grid gap-3 sm:grid-cols-2">
|
||||
<div>
|
||||
<Feld name="TMDb-API-Key" geheim wert={werte['tmdbApiKey'] ?? ''} aufAendern={(w) => setzen('tmdbApiKey', w)} />
|
||||
<p className="mt-1 font-mono text-[10px] text-nebel">
|
||||
www.themoviedb.org → Einstellungen → API
|
||||
<HinterlegtPunkt wert={werte['tmdbApiKey'] ?? ''} />
|
||||
</p>
|
||||
</div>
|
||||
<div>
|
||||
<Feld name="OMDb-API-Key" geheim wert={werte['omdbApiKey'] ?? ''} aufAendern={(w) => setzen('omdbApiKey', w)} />
|
||||
<p className="mt-1 font-mono text-[10px] text-nebel">
|
||||
www.omdbapi.com/apikey.aspx
|
||||
<HinterlegtPunkt wert={werte['omdbApiKey'] ?? ''} />
|
||||
</p>
|
||||
</div>
|
||||
</div>
|
||||
<p className="text-[11px] leading-4 text-nebel">
|
||||
Ohne Schlüssel rippt Rippy trotzdem — die Filme heißen dann wie das Disc-Label, und „Ändern …" an der Laufwerks-Kachel bleibt ohne Suche.
|
||||
</p>
|
||||
</SektionsKarte>
|
||||
)
|
||||
}
|
||||
|
||||
export function MakemkvKarte({ verbindung }: { verbindung: Verbindung }) {
|
||||
const werte = verbindung.einstellungen
|
||||
const s = verbindung.schluessel
|
||||
const b = verbindung.beschaffung
|
||||
return (
|
||||
<SektionsKarte
|
||||
id="makemkv"
|
||||
titel="MAKEMKV"
|
||||
intro="MakeMKV liest die Discs. Rippy holt den frei veröffentlichten Beta-Key automatisch aus dem Hersteller-Forum, hinterlegt ihn und fragt MakeMKV selbst, ob er angenommen wird — täglich."
|
||||
>
|
||||
<div className="rounded-xl border border-white/8 bg-buehne/60 p-3">
|
||||
{s === null ? (
|
||||
<p className="font-mono text-xs text-nebel">Schlüssel wird geprüft …</p>
|
||||
) : (
|
||||
<>
|
||||
<p className="flex items-center gap-2 font-mono text-[10.5px] tracking-wider">
|
||||
<span className={`inline-block h-2 w-2 rounded-full ${s.angenommen === true ? 'bg-gruen' : s.weiterBetrieb ? 'bg-warn' : 'bg-rot'}`} />
|
||||
<span className={s.angenommen === true ? 'text-gruen' : s.weiterBetrieb ? 'text-warn' : 'text-rot'}>
|
||||
{s.angenommen === true ? 'SCHLÜSSEL ANGENOMMEN' : s.weiterBetrieb ? 'BETA-MODUS — RIPS LAUFEN' : 'AUSFALL'}
|
||||
</span>
|
||||
{s.version.length > 0 && <span className="ml-auto text-nebel">MakeMKV {s.version}</span>}
|
||||
</p>
|
||||
<p className="mt-1.5 text-xs leading-5 text-dunst">{s.text}</p>
|
||||
<p className="mt-1 font-mono text-[10px] text-nebel">
|
||||
zuletzt geprüft: {s.geholtAm.slice(0, 16).replace('T', ' ')}
|
||||
{s.gueltigBis.length > 0 && ` · Key gültig bis ${s.gueltigBis}`}
|
||||
</p>
|
||||
</>
|
||||
)}
|
||||
</div>
|
||||
<div className="flex flex-wrap gap-2">
|
||||
{s !== null && s.angenommen === false && (
|
||||
<button
|
||||
onClick={() => makemkvUpdate()}
|
||||
disabled={b !== null && b.laeuft}
|
||||
className="rounded-lg bg-gradient-to-b from-warn to-[oklch(0.72_0.12_78)] px-3 py-1.5 text-xs font-bold text-buehne shadow-[inset_0_1px_0_oklch(1_0_0/0.35)] hover:brightness-105 disabled:opacity-40"
|
||||
title="Holt den offiziellen Installer über die Quellenkette, prüft ihn und startet ihn — Windows fragt einmal nach Adminrechten."
|
||||
>
|
||||
MakeMKV aktualisieren …
|
||||
</button>
|
||||
)}
|
||||
<button onClick={() => schluesselPruefen()} disabled={b !== null && b.laeuft} className={KNOPF_LEISE} title="Forum-Key holen, hinterlegen und MakeMKV selbst fragen, ob er angenommen wird">
|
||||
Schlüssel neu prüfen
|
||||
</button>
|
||||
</div>
|
||||
{b !== null && (
|
||||
<div className="rounded-lg border border-white/10 bg-buehne/70 p-2.5">
|
||||
<p className={`font-mono text-[11px] leading-5 ${b.fehler ? 'text-rot' : b.laeuft ? 'text-gold-hell' : 'text-gruen'}`}>{b.text}</p>
|
||||
{b.laeuft && b.anteil !== null && (
|
||||
<div className="mt-1.5 h-1.5 overflow-hidden rounded-full bg-white/8">
|
||||
<div className="h-full rounded-full bg-gradient-to-r from-gold-tief to-gold-hell transition-all" style={{ width: `${Math.round(b.anteil * 100)}%` }} />
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
)}
|
||||
<Feld
|
||||
name="Eigener Schlüssel (Dauerlizenz)"
|
||||
hinweis="schlägt den automatischen Beta-Key — leer lassen, wenn keiner gekauft ist"
|
||||
geheim
|
||||
wert={werte['makemkvAppKey'] ?? ''}
|
||||
aufAendern={(w) => setzen('makemkvAppKey', w)}
|
||||
/>
|
||||
</SektionsKarte>
|
||||
)
|
||||
}
|
||||
|
||||
export function MedienserverKarte({ verbindung }: { verbindung: Verbindung }) {
|
||||
const werte = verbindung.einstellungen
|
||||
return (
|
||||
<SektionsKarte
|
||||
id="medienserver"
|
||||
titel="MEDIENSERVER"
|
||||
intro="Nach jedem fertigen Rip sagt Rippy deinem Server Bescheid, damit der Film sofort auftaucht — ohne Warten auf den nächsten Bibliotheks-Scan."
|
||||
>
|
||||
<div className="grid gap-3 sm:grid-cols-3">
|
||||
<label className="block">
|
||||
<span className="text-xs font-semibold text-dunst">System</span>
|
||||
<select value={werte['mediaServer'] ?? 'none'} onChange={(e) => setzen('mediaServer', e.target.value)} className={FELD_KLASSE}>
|
||||
<option value="none">keiner</option>
|
||||
<option value="jellyfin">Jellyfin</option>
|
||||
<option value="emby">Emby</option>
|
||||
<option value="kodi">Kodi</option>
|
||||
<option value="plex">Plex (nur Benennung)</option>
|
||||
</select>
|
||||
</label>
|
||||
<Feld name="Adresse" hinweis="http(s)://…" wert={werte['mediaServerUrl'] ?? ''} aufAendern={(w) => setzen('mediaServerUrl', w)} />
|
||||
<Feld name="API-Key" geheim hinweis="Kodi: benutzer:passwort" wert={werte['mediaServerApiKey'] ?? ''} aufAendern={(w) => setzen('mediaServerApiKey', w)} />
|
||||
</div>
|
||||
<p className="text-[11px] leading-4 text-nebel">Bei Plex benennt Rippy nur nach dessen Regeln — angestoßen wird dort nichts. Die Ordnerstruktur aus „Ablage" passt für alle vier.</p>
|
||||
</SektionsKarte>
|
||||
)
|
||||
}
|
||||
|
||||
export function BenachrichtigungKarte({ verbindung }: { verbindung: Verbindung }) {
|
||||
const werte = verbindung.einstellungen
|
||||
return (
|
||||
<SektionsKarte
|
||||
id="benachrichtigung"
|
||||
titel="BENACHRICHTIGUNG"
|
||||
intro="Rippy meldet sich aufs Handy, wenn ein Rip oder eine Kompression fertig ist oder etwas schiefgeht — über einen Discord-Webhook oder einen Telegram-Bot. Windows-Meldungen kommen immer."
|
||||
>
|
||||
<Schalter an={werte['benachrichtigungen'] !== 'aus'} aufWechsel={(an) => setzen('benachrichtigungen', an ? 'an' : 'aus')} label="Benachrichtigungen verschicken" />
|
||||
<Feld
|
||||
name="Discord-Webhook"
|
||||
hinweis="Discord → Servereinstellungen → Integrationen → Webhooks → URL kopieren"
|
||||
geheim
|
||||
wert={werte['discordWebhook'] ?? ''}
|
||||
aufAendern={(w) => setzen('discordWebhook', w)}
|
||||
/>
|
||||
<div className="grid gap-3 sm:grid-cols-2">
|
||||
<Feld name="Telegram-Bot-Token" hinweis="von @BotFather" geheim wert={werte['telegramToken'] ?? ''} aufAendern={(w) => setzen('telegramToken', w)} />
|
||||
<Feld name="Telegram-Chat-ID" hinweis="deine ID, z. B. von @userinfobot" wert={werte['telegramChatId'] ?? ''} aufAendern={(w) => setzen('telegramChatId', w)} />
|
||||
</div>
|
||||
<button onClick={() => benachrichtigungTesten()} className={KNOPF_LEISE}>
|
||||
Testnachricht schicken
|
||||
</button>
|
||||
</SektionsKarte>
|
||||
)
|
||||
}
|
||||
|
||||
export function AllgemeinKarte({ verbindung, haupt }: { verbindung: Verbindung; haupt: HauptStatus | null }) {
|
||||
const werte = verbindung.einstellungen
|
||||
const kern = verbindung.kern
|
||||
const db = kern?.datenbank ?? null
|
||||
const dbText = db === null ? '—' : db.ok ? db.pfad : `FEHLER — ${db.fehler}`
|
||||
return (
|
||||
<SektionsKarte id="allgemein" titel="ALLGEMEIN" intro="Rippy lebt im Infobereich neben der Uhr: Fenster zu heißt weiterlaufen, beendet wird über das Tray-Menü.">
|
||||
<Schalter an={haupt?.autostart === true} aufWechsel={(an) => void window.rippy.autostartSetzen(an)} label="Rippy mit Windows starten (Autostart im Benutzerkonto — kein Dienst, keine Adminrechte)" />
|
||||
<div className="flex flex-wrap gap-2">
|
||||
<button onClick={() => void window.rippy.protokollOeffnen()} className={KNOPF_LEISE} title="Eine Datei je Tag, 14 Tage aufgehoben — Haupt und Kern schreiben hinein">
|
||||
Protokoll öffnen
|
||||
</button>
|
||||
<button onClick={() => void window.rippy.ordnerOeffnen(werte['ablage'] ?? '')} className={KNOPF_LEISE}>
|
||||
Ablage im Explorer
|
||||
</button>
|
||||
{(werte['arbeitsordner'] ?? '').length > 0 && (
|
||||
<button onClick={() => void window.rippy.ordnerOeffnen(werte['arbeitsordner'] ?? '')} className={KNOPF_LEISE}>
|
||||
Arbeitsordner im Explorer
|
||||
</button>
|
||||
)}
|
||||
</div>
|
||||
<div className="rounded-xl border border-white/8 bg-buehne/60 p-3 font-mono text-[11px] leading-5 text-nebel">
|
||||
<p>
|
||||
Rippy v{haupt?.version ?? '…'}
|
||||
{kern !== null && ` · Kern: Node ${kern.nodeVersion} (PID ${kern.pid})`}
|
||||
{haupt !== null && ` · Leine ${haupt.leine.ok ? 'gesetzt' : 'NICHT gesetzt'}`}
|
||||
{verbindung.pongLatenzMs !== null && ` · Antwortzeit ${verbindung.pongLatenzMs} ms`}
|
||||
</p>
|
||||
<p className="break-all">Datenbank: {dbText}</p>
|
||||
<p className="break-all">Protokoll: {haupt?.protokollOrdner ?? '—'}</p>
|
||||
</div>
|
||||
</SektionsKarte>
|
||||
)
|
||||
}
|
||||
|
||||
export function UpdateKarte({ verbindung, haupt }: { verbindung: Verbindung; haupt: HauptStatus | null }) {
|
||||
// § 6.8: Der Prüf-Knopf ist während eines Rips aus — nicht, weil er
|
||||
// nicht könnte, sondern weil Rippy dann bewusst nicht sucht.
|
||||
const ripLaeuftGerade = Object.values(verbindung.rips).some((r) => LAUFENDE_PHASEN.includes(r.phase))
|
||||
return (
|
||||
<SektionsKarte id="update" titel="UPDATE" intro="Rippy holt neue Fassungen selbst aus dem Gitea — geprüft, geladen, beim nächsten Beenden installiert. Nie mitten in einem Rip oder einer Kompression.">
|
||||
{/* Das Feld „Update-Adresse" ist am 01.09.2026 auf Zuruf des
|
||||
Commanders verschwunden: Updates kommen immer vom Gitea, ein
|
||||
Eingabefeld dafür war nur Ballast. Der Einstellungs-Schlüssel
|
||||
`updateUrl` gilt weiterhin — wer ihn wirklich braucht, setzt
|
||||
ihn in der Datenbank, und § 6.8 prüft ihn wie zuvor (nur
|
||||
https://). */}
|
||||
{haupt !== null && (
|
||||
<div className="rounded-xl border border-white/8 bg-buehne/60 p-3 font-mono text-[11px] leading-5 text-nebel">
|
||||
<p>
|
||||
<span className="text-dunst">Stand:</span> {haupt.update.text}
|
||||
</p>
|
||||
{haupt.update.letzteErfolgreichePruefung.length > 0 && <p>letzte erfolgreiche Prüfung: {haupt.update.letzteErfolgreichePruefung.slice(0, 16).replace('T', ' ')}</p>}
|
||||
{haupt.update.neueVersion.length > 0 && <p className="text-gold-hell">Version {haupt.update.neueVersion} gefunden — die Karte in der Übersicht zeigt, was neu ist.</p>}
|
||||
</div>
|
||||
)}
|
||||
<div className="flex flex-wrap items-center gap-2">
|
||||
<button
|
||||
onClick={() => void window.rippy.updatePruefen()}
|
||||
disabled={ripLaeuftGerade || haupt?.update.laeuft === true}
|
||||
className={KNOPF_LEISE}
|
||||
title={ripLaeuftGerade ? 'Während eines Rips wird nicht gesucht — das ist Absicht (§ 6.8).' : 'Fragt sofort beim Update-Server nach.'}
|
||||
>
|
||||
{haupt?.update.laeuft === true ? 'sucht …' : 'Jetzt auf Updates prüfen'}
|
||||
</button>
|
||||
</div>
|
||||
</SektionsKarte>
|
||||
)
|
||||
}
|
||||
|
||||
function WerkzeugZeile({
|
||||
name,
|
||||
pfad,
|
||||
fehlt,
|
||||
pflicht,
|
||||
schluessel,
|
||||
wert,
|
||||
}: {
|
||||
name: string
|
||||
pfad: string | null
|
||||
fehlt: string
|
||||
pflicht: boolean
|
||||
schluessel: string
|
||||
wert: string
|
||||
}) {
|
||||
return (
|
||||
<div className="rounded-xl border border-white/8 bg-samt/50 p-3">
|
||||
<p className={`break-all font-mono text-xs ${pfad === null ? 'text-nebel' : pfad.length > 0 ? 'text-gruen' : pflicht ? 'text-rot' : 'text-warn'}`}>
|
||||
{name}: {pfad === null ? 'wird gesucht …' : pfad.length > 0 ? pfad : fehlt}
|
||||
</p>
|
||||
<PfadFeld
|
||||
name="Eigener Pfad"
|
||||
hinweis="leer = automatische Suche; ein eingetragener Pfad gilt exakt"
|
||||
wert={wert}
|
||||
art="programm"
|
||||
dialogTitel={`${name} wählen`}
|
||||
aufAendern={(w) => setzen(schluessel, w)}
|
||||
/>
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
export function WerkzeugeKarte({ verbindung }: { verbindung: Verbindung }) {
|
||||
const werte = verbindung.einstellungen
|
||||
const backends = verbindung.werkzeuge?.backends ?? []
|
||||
return (
|
||||
<SektionsKarte
|
||||
id="werkzeuge"
|
||||
titel="WERKZEUGE"
|
||||
intro="Rippy findet seine Werkzeuge von allein: mitgeliefert, selbst geholt, installiert oder im PATH — in dieser Reihenfolge. Wer einen eigenen Pfad einträgt, bekommt genau den."
|
||||
>
|
||||
<WerkzeugZeile
|
||||
name="makemkvcon"
|
||||
pfad={verbindung.werkzeuge === null ? null : verbindung.werkzeuge.makemkvcon}
|
||||
fehlt="NICHT GEFUNDEN — MakeMKV von makemkv.com installieren, Rippy findet es danach von allein"
|
||||
pflicht={true}
|
||||
schluessel="werkzeug.makemkv"
|
||||
wert={werte['werkzeug.makemkv'] ?? ''}
|
||||
/>
|
||||
<WerkzeugZeile
|
||||
name="HandBrakeCLI"
|
||||
pfad={verbindung.werkzeuge === null ? null : verbindung.werkzeuge.handbrake}
|
||||
fehlt="nicht gefunden — Rippen geht, Kompression nicht"
|
||||
pflicht={false}
|
||||
schluessel="werkzeug.handbrake"
|
||||
wert={werte['werkzeug.handbrake'] ?? ''}
|
||||
/>
|
||||
<WerkzeugZeile
|
||||
name="flac"
|
||||
pfad={verbindung.werkzeuge === null ? null : verbindung.werkzeuge.flac}
|
||||
fehlt="nicht gefunden — nur für Audio-CDs nötig"
|
||||
pflicht={false}
|
||||
schluessel="werkzeug.flac"
|
||||
wert={werte['werkzeug.flac'] ?? ''}
|
||||
/>
|
||||
{verbindung.werkzeuge !== null && (
|
||||
<p className="font-mono text-[10.5px] text-nebel">
|
||||
HandBrake gemessen: {verbindung.werkzeuge.presets.length} Presets · Encoder: {backends.length > 0 ? backends.join(', ') : '—'}
|
||||
</p>
|
||||
)}
|
||||
</SektionsKarte>
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,68 @@
|
||||
// Die Sprach-Auswahl (5.5.0, Commander: „bei Tonspuren und Untertiteln
|
||||
// können Dropdowns hin") — gewählte Sprachen als Chips in Wunschreihenfolge,
|
||||
// dazu ein Dropdown zum Hinzufügen. Die erste Tonsprache ist die
|
||||
// Wunschsprache (auftrag.ts sprachwahl). Leer heißt „alle".
|
||||
import { SPRACHEN, sprachName, sprachlisteAus, sprachlisteText } from '../../gemeinsam/sprachen'
|
||||
|
||||
export function SprachAuswahl({
|
||||
name,
|
||||
hinweis,
|
||||
wert,
|
||||
aufAendern,
|
||||
}: {
|
||||
name: string
|
||||
hinweis: string
|
||||
wert: string
|
||||
aufAendern: (wert: string) => void
|
||||
}) {
|
||||
const gewaehlt = sprachlisteAus(wert)
|
||||
const frei = SPRACHEN.filter((s) => !gewaehlt.includes(s.code))
|
||||
const setzen = (codes: string[]): void => aufAendern(sprachlisteText(codes))
|
||||
const verschieben = (code: string, richtung: -1 | 1): void => {
|
||||
const i = gewaehlt.indexOf(code)
|
||||
const j = i + richtung
|
||||
if (i < 0 || j < 0 || j >= gewaehlt.length) return
|
||||
const neu = [...gewaehlt]
|
||||
;[neu[i], neu[j]] = [neu[j], neu[i]]
|
||||
setzen(neu)
|
||||
}
|
||||
return (
|
||||
<div>
|
||||
<span className="text-xs font-semibold text-dunst">{name}</span>
|
||||
<span className="ml-2 text-xs text-nebel">{hinweis}</span>
|
||||
<div className="mt-1 flex min-h-[38px] flex-wrap items-center gap-1.5 rounded-lg border border-white/12 bg-samt px-2 py-1.5">
|
||||
{gewaehlt.length === 0 && <span className="font-mono text-[11px] text-nebel">alle Sprachen der Disc</span>}
|
||||
{gewaehlt.map((code, i) => (
|
||||
<span key={code} className="inline-flex items-center gap-1 rounded-md border border-gold/40 bg-gold/12 px-2 py-0.5 text-[11px] text-gold-hell">
|
||||
<span className="font-mono text-[10px] text-gold/70">{i + 1}.</span>
|
||||
<span>{sprachName(code)}</span>
|
||||
<span className="font-mono text-[10px] text-nebel">{code}</span>
|
||||
<button type="button" onClick={() => verschieben(code, -1)} disabled={i === 0} className="ml-1 text-nebel hover:text-schnee disabled:opacity-30" title="nach vorn">
|
||||
‹
|
||||
</button>
|
||||
<button type="button" onClick={() => verschieben(code, 1)} disabled={i === gewaehlt.length - 1} className="text-nebel hover:text-schnee disabled:opacity-30" title="nach hinten">
|
||||
›
|
||||
</button>
|
||||
<button type="button" onClick={() => setzen(gewaehlt.filter((c) => c !== code))} className="ml-0.5 text-nebel hover:text-rot" title="entfernen">
|
||||
×
|
||||
</button>
|
||||
</span>
|
||||
))}
|
||||
<select
|
||||
value=""
|
||||
onChange={(e) => {
|
||||
if (e.target.value.length > 0) setzen([...gewaehlt, e.target.value])
|
||||
}}
|
||||
className="ml-auto rounded-md border border-white/12 bg-buehne px-2 py-1 font-mono text-[11px] text-dunst"
|
||||
>
|
||||
<option value="">+ Sprache …</option>
|
||||
{frei.map((s) => (
|
||||
<option key={s.code} value={s.code}>
|
||||
{s.name} ({s.code})
|
||||
</option>
|
||||
))}
|
||||
</select>
|
||||
</div>
|
||||
</div>
|
||||
)
|
||||
}
|
||||
+3
@@ -8,6 +8,9 @@ declare global {
|
||||
aufStatus(horcher: (status: unknown) => void): void
|
||||
melden(art: string): void
|
||||
ordnerWaehlen(titel: string): Promise<string | null>
|
||||
dateiWaehlen(titel: string): Promise<string | null>
|
||||
ordnerOeffnen(pfad: string): Promise<string>
|
||||
protokollOeffnen(): Promise<string>
|
||||
autostartSetzen(an: boolean): Promise<boolean>
|
||||
updatePruefen(): Promise<unknown>
|
||||
updateInstallieren(): Promise<{ ok: boolean; grund: string }>
|
||||
|
||||
@@ -8,8 +8,8 @@
|
||||
// Laufwerksliste: Sie ändert sich NUR durch eine neue Liste vom Kern.
|
||||
import {
|
||||
istKernNachricht,
|
||||
type AutomatikStand,
|
||||
type BeschaffungStand,
|
||||
type BibliothekEintrag,
|
||||
type DiscInfoStand,
|
||||
type FensterNachricht,
|
||||
type GeraeteInfo,
|
||||
@@ -19,6 +19,7 @@ import {
|
||||
type RipAuftragOptionen,
|
||||
type RipAuftragTitel,
|
||||
type RipStatus,
|
||||
type SpeicherStand,
|
||||
type TitelStand,
|
||||
type VorgaengeStand,
|
||||
type WerkzeugAuskunft,
|
||||
@@ -46,7 +47,6 @@ export interface Verbindung {
|
||||
ripProtokoll: Record<string, string[]>
|
||||
einstellungen: Record<string, string>
|
||||
werkzeuge: WerkzeugAuskunft | null
|
||||
bibliothek: BibliothekEintrag[]
|
||||
schluessel: {
|
||||
quelle: string
|
||||
angenommen: boolean | null
|
||||
@@ -63,6 +63,12 @@ export interface Verbindung {
|
||||
vorgaenge: VorgaengeStand | null
|
||||
/** Was das Windows-Protokoll je Laufwerk sagt (5.4.0) — bleibt stehen. */
|
||||
gesundheit: Record<string, LaufwerkBericht>
|
||||
/** Freier Platz an Arbeitsordner und Ablage (5.5.0). */
|
||||
speicher: SpeicherStand | null
|
||||
/** Automatik-Countdown je Laufwerk (5.5.0). */
|
||||
automatik: Record<string, AutomatikStand>
|
||||
/** Poster für den Hintergrund der Erst-Einrichtung (5.5.0). */
|
||||
poster: string[]
|
||||
/** Kurze Ereigniszeilen (neueste zuerst): Disc rein/raus, Auswurf, Fehler. */
|
||||
meldungen: string[]
|
||||
}
|
||||
@@ -71,7 +77,7 @@ type Horcher = (stand: Verbindung) => void
|
||||
|
||||
const MAX_MELDUNGEN = 30
|
||||
|
||||
const stand: Verbindung = {
|
||||
export const LEERE_VERBINDUNG: Verbindung = {
|
||||
verbunden: false,
|
||||
kern: null,
|
||||
pongLatenzMs: null,
|
||||
@@ -84,13 +90,17 @@ const stand: Verbindung = {
|
||||
ripProtokoll: {},
|
||||
einstellungen: {},
|
||||
werkzeuge: null,
|
||||
bibliothek: [],
|
||||
schluessel: null,
|
||||
beschaffung: null,
|
||||
vorgaenge: null,
|
||||
gesundheit: {},
|
||||
speicher: null,
|
||||
automatik: {},
|
||||
poster: [],
|
||||
meldungen: [],
|
||||
}
|
||||
|
||||
const stand: Verbindung = { ...LEERE_VERBINDUNG }
|
||||
const horcher = new Set<Horcher>()
|
||||
let gestartet = false
|
||||
let port: MessagePort | null = null
|
||||
@@ -103,8 +113,9 @@ function kopie(): Verbindung {
|
||||
discInfos: { ...stand.discInfos },
|
||||
vorschlaege: { ...stand.vorschlaege },
|
||||
einstellungen: { ...stand.einstellungen },
|
||||
bibliothek: [...stand.bibliothek],
|
||||
gesundheit: { ...stand.gesundheit },
|
||||
automatik: { ...stand.automatik },
|
||||
poster: [...stand.poster],
|
||||
meldungen: [...stand.meldungen],
|
||||
}
|
||||
}
|
||||
@@ -140,6 +151,8 @@ function kernNachricht(nachricht: KernNachricht): void {
|
||||
meldung(`Disc erkannt in ${ereignis.geraet.name} — ${ereignis.geraet.typ}`)
|
||||
} else if (ereignis.art === 'disc-entnommen') {
|
||||
meldung(`Disc entnommen aus ${ereignis.geraet.name}`)
|
||||
const { [ereignis.geraet.id]: _weg, ...rest } = stand.automatik
|
||||
stand.automatik = rest
|
||||
} else if (ereignis.art === 'laufwerk-weg') {
|
||||
meldung(`Laufwerk ${ereignis.id}: nicht mehr da`)
|
||||
}
|
||||
@@ -184,9 +197,6 @@ function kernNachricht(nachricht: KernNachricht): void {
|
||||
case 'werkzeuge':
|
||||
stand.werkzeuge = nachricht.auskunft
|
||||
break
|
||||
case 'bibliothek':
|
||||
stand.bibliothek = nachricht.eintraege
|
||||
break
|
||||
case 'schluessel-status':
|
||||
stand.schluessel = nachricht.stand
|
||||
if (nachricht.stand.angenommen === false) meldung(`⚠ MakeMKV-Schlüssel: ${nachricht.stand.text}`)
|
||||
@@ -207,9 +217,18 @@ function kernNachricht(nachricht: KernNachricht): void {
|
||||
meldung(`Laufwerk ${nachricht.id}: ${nachricht.bericht.text}`)
|
||||
}
|
||||
break
|
||||
case 'speicher':
|
||||
stand.speicher = nachricht.stand
|
||||
break
|
||||
case 'automatik':
|
||||
stand.automatik = { ...stand.automatik, [nachricht.stand.id]: nachricht.stand }
|
||||
break
|
||||
case 'poster-vorschau':
|
||||
stand.poster = nachricht.pfade
|
||||
break
|
||||
case 'rip-status': {
|
||||
stand.rips = { ...stand.rips, [nachricht.status.id]: nachricht.status }
|
||||
const laeuft = ['liest-info', 'rippt', 'komprimiert', 'legt-ab'].includes(nachricht.status.phase)
|
||||
const laeuft = ['liest-info', 'rettet', 'rippt', 'komprimiert', 'legt-ab'].includes(nachricht.status.phase)
|
||||
if (laeuft && stand.ripStart[nachricht.status.id] === undefined) {
|
||||
stand.ripStart = { ...stand.ripStart, [nachricht.status.id]: Date.now() }
|
||||
// Ein NEUER Vorgang beginnt — das Protokoll des alten weicht.
|
||||
@@ -257,8 +276,8 @@ function portAnnehmen(neuerPort: MessagePort): void {
|
||||
senden({ art: 'ping', zeit: Date.now() })
|
||||
senden({ art: 'einstellungen-laden' })
|
||||
senden({ art: 'werkzeuge-laden' })
|
||||
senden({ art: 'bibliothek-laden' })
|
||||
senden({ art: 'vorgaenge-laden' })
|
||||
senden({ art: 'speicher-laden' })
|
||||
melden()
|
||||
}
|
||||
|
||||
@@ -324,6 +343,10 @@ export function ripAbbrechen(id: string): void {
|
||||
anKern({ art: 'rip-abbruch', id }, `Rip-Abbruch ${id}`)
|
||||
}
|
||||
|
||||
export function rettungStarten(id: string): void {
|
||||
anKern({ art: 'rettung-start', id }, `Rettungs-Abbild ${id}`)
|
||||
}
|
||||
|
||||
export function metadatenSuchen(id: string, text: string): void {
|
||||
senden({ art: 'metadaten-suchen', id, text })
|
||||
}
|
||||
@@ -372,3 +395,28 @@ export function fremdenOrdnerLoeschen(ordner: string): void {
|
||||
export function laufwerkPruefen(id: string): void {
|
||||
anKern({ art: 'laufwerk-pruefen', id }, `Laufwerk ${id} prüfen`)
|
||||
}
|
||||
|
||||
// ── 5.5.0 ───────────────────────────────────────────────────────────────
|
||||
export function kompressionPause(an: boolean): void {
|
||||
anKern({ art: 'kompression-pause', an }, an ? 'Kompression anhalten' : 'Kompression weiter')
|
||||
}
|
||||
|
||||
export function automatikStopp(id: string): void {
|
||||
senden({ art: 'automatik-stopp', id })
|
||||
}
|
||||
|
||||
export function automatikJetzt(id: string): void {
|
||||
anKern({ art: 'automatik-jetzt', id }, 'Automatik jetzt')
|
||||
}
|
||||
|
||||
export function benachrichtigungTesten(): void {
|
||||
anKern({ art: 'benachrichtigung-testen' }, 'Testnachricht')
|
||||
}
|
||||
|
||||
export function posterLaden(): void {
|
||||
senden({ art: 'poster-laden' })
|
||||
}
|
||||
|
||||
export function speicherLaden(): void {
|
||||
senden({ art: 'speicher-laden' })
|
||||
}
|
||||
|
||||
@@ -76,3 +76,17 @@
|
||||
::-webkit-scrollbar-thumb { background: oklch(1 0 0 / 0.12); border-radius: 999px; border: 2px solid transparent; background-clip: content-box; }
|
||||
::-webkit-scrollbar-thumb:hover { background-color: oklch(1 0 0 / 0.2); }
|
||||
::-webkit-scrollbar-track { background: transparent; }
|
||||
|
||||
/* Der Poster-Lauf der Erst-Einrichtung (5.5.0): Jede Spalte wandert langsam
|
||||
nach oben; die Liste ist verdoppelt, bei -50 % beginnt sie nahtlos von
|
||||
vorn. Dauer und Versatz setzt die Komponente je Spalte. */
|
||||
@keyframes poster-lauf {
|
||||
from { transform: translateY(0); }
|
||||
to { transform: translateY(-50%); }
|
||||
}
|
||||
.poster-spalte {
|
||||
animation-name: poster-lauf;
|
||||
animation-timing-function: linear;
|
||||
animation-iteration-count: infinite;
|
||||
will-change: transform;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,78 @@
|
||||
// Die Kompressions-Warteschlange in der Übersicht (5.4.0): Rip und
|
||||
// Kompression sind entkoppelt — hier steht, was gerade rechnet und was
|
||||
// noch wartet, mit Abbruch je Auftrag. 5.5.0: Pause — der laufende Film
|
||||
// wird fertig, der nächste wartet.
|
||||
import type { VorgaengeStand } from '../../gemeinsam/nachrichten'
|
||||
import { SegmentBalken } from '../bausteine'
|
||||
import { kompressionAbbrechen, kompressionPause } from '../kernverbindung'
|
||||
|
||||
export function KompressionsKarte({ stand }: { stand: VorgaengeStand['kompression'] }) {
|
||||
if (stand.laeuft === null && stand.wartend.length === 0 && !stand.pausiert) return null
|
||||
const l = stand.laeuft
|
||||
return (
|
||||
<div className="rounded-2xl border border-white/10 bg-karte/50 p-5">
|
||||
<div className="flex flex-wrap items-center gap-2.5 font-mono text-[10.5px] tracking-[0.12em] text-nebel">
|
||||
<span className={`inline-block h-2 w-2 rounded-full ${l !== null ? 'animate-pulse bg-gold' : stand.pausiert ? 'bg-warn' : 'bg-white/25'}`} />
|
||||
<span className="text-dunst">KOMPRESSION</span>
|
||||
<span>·</span>
|
||||
<span>
|
||||
{l !== null ? 'läuft' : stand.pausiert ? 'angehalten' : 'wartet'}
|
||||
{stand.wartend.length > 0 && ` · ${stand.wartend.length} in der Warteschlange`}
|
||||
</span>
|
||||
<button
|
||||
onClick={() => kompressionPause(!stand.pausiert)}
|
||||
className={`ml-auto rounded-lg border px-3 py-1 text-[11px] ${
|
||||
stand.pausiert ? 'border-gold/40 bg-gold/12 font-semibold text-gold-hell hover:bg-gold/20' : 'border-white/15 text-dunst hover:text-schnee'
|
||||
}`}
|
||||
title={stand.pausiert ? 'Die Warteschlange läuft weiter' : 'Der laufende Film wird fertig gerechnet, der nächste wartet — zum Beispiel beim Spielen'}
|
||||
>
|
||||
{stand.pausiert ? '▶ Weiter' : '⏸ Pausieren'}
|
||||
</button>
|
||||
</div>
|
||||
{l !== null && (
|
||||
<div className="mt-3 rounded-xl border border-white/10 bg-samt/80 p-4">
|
||||
<div className="flex items-end justify-between gap-5">
|
||||
<div className="min-w-0 flex-1">
|
||||
<p className="truncate font-display text-[17px] font-bold text-schnee">{l.titel}</p>
|
||||
<div className="mt-2">
|
||||
<SegmentBalken prozent={l.prozent} />
|
||||
</div>
|
||||
<p className="mt-2 truncate font-mono text-[11px] text-nebel" title={l.text}>
|
||||
> {l.text}
|
||||
</p>
|
||||
{stand.pausiert && <p className="mt-1 font-mono text-[10.5px] text-warn">Pause: Dieser Film wird fertig, danach wartet die Schlange.</p>}
|
||||
</div>
|
||||
{l.prozent >= 0 && (
|
||||
<div className="flex-none font-mono text-[42px] font-bold leading-none text-gold-hell">
|
||||
{l.prozent}
|
||||
<span className="text-lg text-gold/70">%</span>
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
<button
|
||||
onClick={() => kompressionAbbrechen(l.vorgangId)}
|
||||
className="mt-3 rounded-lg border border-rot/50 bg-rot/10 px-3 py-1 text-[11px] font-semibold text-rot hover:bg-rot/20"
|
||||
title="Die Roh-Dateien bleiben liegen — unter Einstellungen → Roh-Dateien geht es später weiter"
|
||||
>
|
||||
Kompression abbrechen
|
||||
</button>
|
||||
</div>
|
||||
)}
|
||||
{stand.wartend.length > 0 && (
|
||||
<div className="mt-3 space-y-1">
|
||||
{stand.wartend.map((w, i) => (
|
||||
<div key={w.vorgangId} className="flex items-center justify-between gap-3 rounded-lg border border-white/8 bg-samt/40 px-3 py-1.5">
|
||||
<span className="min-w-0 truncate font-mono text-[11px] text-dunst">
|
||||
Platz {i + 1} · {w.titel}
|
||||
{stand.pausiert ? ' · wartet auf Weiter' : ''}
|
||||
</span>
|
||||
<button onClick={() => kompressionAbbrechen(w.vorgangId)} className="flex-none font-mono text-[10.5px] text-nebel hover:text-rot">
|
||||
aus der Schlange nehmen
|
||||
</button>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,485 @@
|
||||
// Die Bühne: Backdrop als Panorama, Poster mit Goldkante, Plakat-Titel —
|
||||
// und beim Arbeiten die Aussteuerungsanzeige samt Mono-Protokoll.
|
||||
// 5.4.0: Kino-Banner v2 (Logo, Tagline, Meta-Zeile, Darsteller), Laufwerks-
|
||||
// Gesundheit, Stand der Kompression nach dem Rip. 5.5.0: Automatik-Countdown
|
||||
// und das Rettungs-Abbild — nur, wenn Rippy Lesefehler gesehen hat.
|
||||
import { useState } from 'react'
|
||||
import type {
|
||||
AutomatikStand,
|
||||
DiscInfoStand,
|
||||
GeraeteInfo,
|
||||
KompressionStand,
|
||||
LaufwerkBericht,
|
||||
RipStatus,
|
||||
VorgangEintrag,
|
||||
} from '../../gemeinsam/nachrichten'
|
||||
import { DEFAULT_HB_PRESET, presetEmpfehlung } from '../../gemeinsam/preset-empfehlung'
|
||||
import {
|
||||
Badge,
|
||||
IconDisc,
|
||||
IconEject,
|
||||
IconPlay,
|
||||
IconStift,
|
||||
IconStop,
|
||||
InfoKachel,
|
||||
LAUFENDE_PHASEN,
|
||||
PHASEN_MONO,
|
||||
SegmentBalken,
|
||||
TYP_NAMEN,
|
||||
backdropUrl,
|
||||
discHerkunft,
|
||||
gb,
|
||||
logoUrl,
|
||||
metaZeile,
|
||||
posterUrlGross,
|
||||
profilUrl,
|
||||
restzeitText,
|
||||
sicherheitsWort,
|
||||
} from '../bausteine'
|
||||
import {
|
||||
automatikJetzt,
|
||||
automatikStopp,
|
||||
auswerfen,
|
||||
laufwerkPruefen,
|
||||
rettungStarten,
|
||||
ripAbbrechen,
|
||||
ripUeberspringen,
|
||||
type Verbindung,
|
||||
} from '../kernverbindung'
|
||||
|
||||
/** Welches Preset diese Disc bekäme — dieselbe Kette wie im Kern
|
||||
* (eigene Wahl → Empfehlung → Default). */
|
||||
export function presetAnzeige(typ: GeraeteInfo['typ'], verbindung: Verbindung): string {
|
||||
if (typ === 'cd') return 'FLAC (verlustfrei)'
|
||||
if (typ === 'unknown') return 'ISO-Abbild'
|
||||
const werte = verbindung.einstellungen
|
||||
if (werte['transcodeEnabled'] === 'false') return 'ohne Kompression'
|
||||
const schluessel = typ === 'dvd' ? 'transcodePresetDvd' : typ === 'uhd' ? 'transcodePresetUhd' : 'transcodePresetBluray'
|
||||
const eigene = werte[schluessel] ?? ''
|
||||
const empfehlung = presetEmpfehlung(typ, verbindung.werkzeuge?.backends ?? [], verbindung.werkzeuge?.presets ?? [])
|
||||
const gewaehlt = eigene.length > 0 ? eigene : empfehlung.length > 0 ? empfehlung : DEFAULT_HB_PRESET
|
||||
return gewaehlt === 'keine' ? 'ohne Kompression' : gewaehlt
|
||||
}
|
||||
|
||||
export function LaufwerkKachel({
|
||||
geraet,
|
||||
rip,
|
||||
info,
|
||||
ripStartMs,
|
||||
protokoll,
|
||||
verbindung,
|
||||
bericht,
|
||||
vorgang,
|
||||
kompression,
|
||||
wartePlatz,
|
||||
automatik,
|
||||
aufRippen,
|
||||
aufAendern,
|
||||
}: {
|
||||
geraet: GeraeteInfo
|
||||
rip: RipStatus | undefined
|
||||
info: DiscInfoStand | undefined
|
||||
ripStartMs: number | undefined
|
||||
protokoll: string[]
|
||||
verbindung: Verbindung
|
||||
/** Was das Windows-Protokoll zu diesem Laufwerk sagt (5.4.0). */
|
||||
bericht: LaufwerkBericht | undefined
|
||||
/** Der Vorgang des letzten Rips — für den Stand der Kompression (5.4.0). */
|
||||
vorgang: VorgangEintrag | undefined
|
||||
kompression: KompressionStand | null
|
||||
wartePlatz: number
|
||||
/** Der Automatik-Countdown (5.5.0). */
|
||||
automatik: AutomatikStand | undefined
|
||||
/** Die Dialoge leben im App-Zustand (5.4.0): Ein leerer Takt der Wache
|
||||
* räumte sonst Kachel UND Dialog ab. */
|
||||
aufRippen: () => void
|
||||
aufAendern: () => void
|
||||
}) {
|
||||
const [protokollOffen, setProtokollOffen] = useState(false)
|
||||
const [berichtOffen, setBerichtOffen] = useState(false)
|
||||
const ripLaeuft = rip !== undefined && LAUFENDE_PHASEN.includes(rip.phase)
|
||||
const discDa = geraet.status === 'ready'
|
||||
const backdrop = discDa && info !== undefined ? backdropUrl(info.backdropPfad) : ''
|
||||
const poster = discDa && info !== undefined ? posterUrlGross(info.posterPfad) : ''
|
||||
const erkannt = discDa && info !== undefined && info.titel.length > 0
|
||||
const logo = erkannt ? logoUrl(info.logoPfad) : ''
|
||||
const rettungMoeglich = discDa && !ripLaeuft && rip !== undefined && rip.rettungMoeglich === true
|
||||
const berichtTon =
|
||||
bericht === undefined
|
||||
? ''
|
||||
: bericht.urteil === 'ruhig'
|
||||
? 'text-gruen border-gruen/40 bg-gruen/10'
|
||||
: bericht.urteil === 'disc'
|
||||
? 'text-warn border-warn/45 bg-warn/10'
|
||||
: bericht.urteil === 'hardware'
|
||||
? 'text-rot border-rot/45 bg-rot/10'
|
||||
: 'text-dunst border-white/12 bg-samt/60'
|
||||
|
||||
return (
|
||||
<div className="relative overflow-hidden rounded-2xl border border-white/10 bg-karte/50">
|
||||
{backdrop.length > 0 && (
|
||||
<>
|
||||
<img src={backdrop} alt="" className="absolute inset-0 h-full w-full object-cover" />
|
||||
<div className="absolute inset-0 bg-gradient-to-r from-buehne via-buehne/85 to-buehne/45" />
|
||||
<div className="absolute inset-0 bg-gradient-to-t from-buehne via-transparent to-transparent" />
|
||||
</>
|
||||
)}
|
||||
|
||||
<div className="relative p-5">
|
||||
<div className="flex items-start justify-between gap-3">
|
||||
<div className="flex items-center gap-2.5 font-mono text-[10.5px] tracking-[0.12em] text-nebel">
|
||||
<span
|
||||
className={`inline-block h-2 w-2 rounded-full ${
|
||||
ripLaeuft
|
||||
? 'animate-pulse bg-rec shadow-[0_0_9px_oklch(0.72_0.17_45/0.9)]'
|
||||
: discDa
|
||||
? 'bg-gruen'
|
||||
: geraet.status === 'empty'
|
||||
? 'bg-white/25'
|
||||
: 'bg-rot'
|
||||
}`}
|
||||
/>
|
||||
<span className="text-dunst">LAUFWERK {geraet.id}:</span>
|
||||
<span>·</span>
|
||||
<span className="truncate">{geraet.modell.length > 0 ? geraet.modell : 'MODELL UNBEKANNT'}</span>
|
||||
</div>
|
||||
<div className="flex flex-none gap-2">
|
||||
{ripLaeuft ? (
|
||||
<button
|
||||
onClick={() => ripAbbrechen(geraet.id)}
|
||||
className="inline-flex items-center gap-2 rounded-xl border border-rot/60 bg-rot/10 px-4 py-1.5 text-xs font-semibold text-rot hover:bg-rot/20"
|
||||
>
|
||||
<IconStop />
|
||||
Abbrechen
|
||||
</button>
|
||||
) : (
|
||||
<button
|
||||
onClick={aufRippen}
|
||||
disabled={!discDa}
|
||||
className="inline-flex items-center gap-2 rounded-xl bg-gradient-to-b from-gold-hell to-gold-tief px-5 py-1.5 text-xs font-bold text-buehne shadow-[inset_0_1px_0_oklch(1_0_0/0.4),0_8px_24px_oklch(0.75_0.13_60/0.3)] hover:from-gold-hell hover:to-gold disabled:cursor-not-allowed disabled:opacity-35 disabled:shadow-none"
|
||||
title="Titel der Disc lesen und auswaehlen — danach verlustfrei rippen"
|
||||
>
|
||||
<IconPlay />
|
||||
Rippen
|
||||
</button>
|
||||
)}
|
||||
<button
|
||||
onClick={() => auswerfen(geraet.id)}
|
||||
disabled={!discDa || ripLaeuft}
|
||||
className="inline-flex items-center gap-2 rounded-xl border border-white/15 bg-gradient-to-b from-karte/80 to-samt/80 px-4 py-1.5 text-xs text-dunst shadow-[inset_0_1px_0_oklch(1_0_0/0.07)] hover:text-schnee disabled:cursor-not-allowed disabled:opacity-35"
|
||||
title="Entriegeln, auswerfen, nachsehen — in dieser Reihenfolge"
|
||||
>
|
||||
<IconEject />
|
||||
Auswerfen
|
||||
</button>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
{!discDa && (
|
||||
<div className="mt-5 flex items-center gap-5 py-5">
|
||||
<IconDisc groesse={52} farbe={geraet.status === 'empty' ? 'oklch(0.4 0.02 75)' : 'oklch(0.68 0.19 25)'} />
|
||||
<p className={`max-w-2xl font-mono text-xs leading-5 ${geraet.status === 'empty' ? 'text-nebel' : 'text-rot'}`}>
|
||||
{geraet.status === 'empty' ? 'Keine Disc eingelegt — Disc rein genügt, Rippy meldet sich.' : geraet.grund}
|
||||
</p>
|
||||
</div>
|
||||
)}
|
||||
|
||||
{discDa && (
|
||||
<div className="mt-4 flex gap-5">
|
||||
{poster.length > 0 ? (
|
||||
<img src={poster} alt="" className="h-44 w-[118px] flex-none rounded-xl object-cover shadow-2xl shadow-black/60 ring-1 ring-gold/35" />
|
||||
) : (
|
||||
<div className="flex h-44 w-[118px] flex-none items-center justify-center rounded-xl bg-gradient-to-br from-karte to-samt ring-1 ring-white/10">
|
||||
<IconDisc groesse={40} farbe="oklch(0.5 0.05 75)" />
|
||||
</div>
|
||||
)}
|
||||
<div className="min-w-0 flex-1">
|
||||
{/* Kino-Banner v2 (5.4.0): Logo statt Text, wo TMDb eines hat —
|
||||
der größte optische Sprung. Titel und Jahr bleiben lesbar. */}
|
||||
{erkannt ? (
|
||||
logo.length > 0 ? (
|
||||
<div className="flex flex-wrap items-end gap-x-3 gap-y-1">
|
||||
<img src={logo} alt={info.titel} className="max-h-16 max-w-[380px] object-contain object-left drop-shadow-[0_2px_12px_rgba(0,0,0,0.75)]" />
|
||||
<span className="pb-0.5 text-sm text-dunst">
|
||||
{info.titel}
|
||||
{info.jahr !== null && ` (${info.jahr})`}
|
||||
</span>
|
||||
</div>
|
||||
) : (
|
||||
<h3 className="truncate font-display text-[26px] font-bold leading-tight text-schnee drop-shadow">
|
||||
{info.titel}
|
||||
{info.jahr !== null && <span className="ml-2 font-medium text-dunst">({info.jahr})</span>}
|
||||
</h3>
|
||||
)
|
||||
) : (
|
||||
<h3 className="font-display text-[26px] font-bold leading-tight text-schnee">{TYP_NAMEN[geraet.typ]}</h3>
|
||||
)}
|
||||
{erkannt && info.tagline.length > 0 && <p className="mt-1 font-display text-[15px] italic text-gold-hell/90">{info.tagline}</p>}
|
||||
{erkannt && metaZeile(info).length > 0 && <p className="mt-1 font-mono text-[11px] tracking-wide text-dunst">{metaZeile(info)}</p>}
|
||||
{erkannt && info.beschreibung.length > 0 && <p className="mt-1.5 line-clamp-2 max-w-2xl text-xs leading-5 text-dunst">{info.beschreibung}</p>}
|
||||
{!erkannt && (
|
||||
<p className="mt-1.5 font-mono text-xs text-nebel">
|
||||
{geraet.typ === 'cd' ? 'Titel kommen beim Rippen von MusicBrainz.' : 'Noch keine Zuordnung — „Ändern …" hilft nach.'}
|
||||
</p>
|
||||
)}
|
||||
|
||||
{/* Zwei Kacheln nebeneinander im schmalen Fenster, vier im
|
||||
breiten — vorher immer vier, also im schmalen gequetscht. */}
|
||||
<div className="mt-3 grid max-w-3xl grid-cols-2 gap-2.5 sm:grid-cols-4">
|
||||
<InfoKachel label="MEDIUM" wert={TYP_NAMEN[geraet.typ]} />
|
||||
<InfoKachel label="GRÖSSE" wert={geraet.groesseBytes > 0 ? gb(geraet.groesseBytes) : '—'} />
|
||||
<InfoKachel
|
||||
label="ERKENNUNG"
|
||||
wert={erkannt ? `${Math.round(info.confidence * 100)} %${info.quelle.length > 0 ? ` · ${info.quelle}` : ''}` : '—'}
|
||||
farbe={erkannt ? (info.confidence >= 0.8 ? 'text-gruen' : 'text-warn') : undefined}
|
||||
/>
|
||||
<InfoKachel label="PRESET" wert={presetAnzeige(geraet.typ, verbindung)} />
|
||||
</div>
|
||||
|
||||
{/* Darsteller-Streifen (5.4.0) */}
|
||||
{erkannt && info.besetzung.length > 0 && (
|
||||
<div className="mt-3 flex flex-wrap gap-x-4 gap-y-2">
|
||||
{info.besetzung.map((d) => (
|
||||
<div key={`${d.name}-${d.rolle}`} className="flex items-center gap-2" title={d.rolle}>
|
||||
{d.bildPfad.length > 0 ? (
|
||||
<img src={profilUrl(d.bildPfad)} alt="" className="h-9 w-9 rounded-full object-cover ring-1 ring-gold/30" />
|
||||
) : (
|
||||
<span className="flex h-9 w-9 items-center justify-center rounded-full bg-samt font-mono text-[11px] text-nebel ring-1 ring-white/10">
|
||||
{d.name
|
||||
.split(' ')
|
||||
.map((w) => w[0] ?? '')
|
||||
.join('')
|
||||
.slice(0, 2)
|
||||
.toUpperCase()}
|
||||
</span>
|
||||
)}
|
||||
<span className="leading-tight">
|
||||
<span className="block text-[11px] text-schnee">{d.name}</span>
|
||||
{d.rolle.length > 0 && <span className="block text-[10px] text-nebel">{d.rolle}</span>}
|
||||
</span>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
)}
|
||||
|
||||
<div className="mt-3 flex flex-wrap items-center gap-2">
|
||||
<button
|
||||
onClick={aufAendern}
|
||||
disabled={ripLaeuft}
|
||||
className="inline-flex items-center gap-2 rounded-lg border border-white/15 bg-samt/60 px-3 py-1 text-xs text-dunst hover:text-schnee disabled:opacity-35"
|
||||
title="Falsch erkannt? Selbst suchen und wählen — die Ablage folgt deiner Wahl."
|
||||
>
|
||||
<IconStift />
|
||||
Ändern …
|
||||
</button>
|
||||
<button
|
||||
onClick={() => {
|
||||
setBerichtOffen(true)
|
||||
laufwerkPruefen(geraet.id)
|
||||
}}
|
||||
className="inline-flex items-center gap-2 rounded-lg border border-white/15 bg-samt/60 px-3 py-1 text-xs text-dunst hover:text-schnee"
|
||||
title="Liest die cdrom-Ereignisse aus dem Windows-Protokoll: Disc oder Hardware?"
|
||||
>
|
||||
Laufwerk prüfen
|
||||
</button>
|
||||
{rettungMoeglich && (
|
||||
<button
|
||||
onClick={() => rettungStarten(geraet.id)}
|
||||
className="inline-flex items-center gap-2 rounded-lg border border-warn/50 bg-warn/12 px-3 py-1 text-xs font-semibold text-warn hover:bg-warn/20"
|
||||
title="Rippy hat an dieser Disc Lesefehler gesehen: erst ein Abbild Sektor für Sektor (Unlesbares mit Nullen), dann derselbe Rip aus dem Abbild — es kann nicht mehr hängen. Braucht doppelten Platz."
|
||||
>
|
||||
Rettungs-Abbild …
|
||||
</button>
|
||||
)}
|
||||
{erkannt && <Badge text={`${sicherheitsWort(info.confidence)}`} ton={info.confidence >= 0.8 ? 'gruen' : 'gelb'} />}
|
||||
{info !== undefined && discHerkunft(info).length > 0 && <Badge text={discHerkunft(info)} ton="blau" />}
|
||||
{info !== undefined && info.schonGerippt !== null && <Badge text={`schon gerippt am ${info.schonGerippt.slice(0, 10)}`} ton="gelb" />}
|
||||
</div>
|
||||
{/* Was Rippy NACH dem Info-Lauf dazugelernt hat (Erkennung v2). */}
|
||||
{erkannt && info.hinweise.length > 0 && (
|
||||
<div className="mt-2 space-y-0.5">
|
||||
{info.hinweise.map((h) => (
|
||||
<p
|
||||
key={h}
|
||||
className={`font-mono text-[11px] ${h.includes('NICHT') ? 'text-warn' : h.includes('bestätigt') || h.includes('passt') ? 'text-gruen' : 'text-nebel'}`}
|
||||
>
|
||||
{h.includes('NICHT') ? '⚠ ' : h.includes('bestätigt') ? '✓ ' : '· '}
|
||||
{h}
|
||||
</p>
|
||||
))}
|
||||
</div>
|
||||
)}
|
||||
{geraet.grund.length > 0 && <p className="mt-2 font-mono text-xs text-warn">{geraet.grund}</p>}
|
||||
</div>
|
||||
</div>
|
||||
)}
|
||||
|
||||
{/* Automatik (5.5.0): Countdown mit Stopp und Jetzt — oder der
|
||||
Grund, warum Rippy wartet. */}
|
||||
{discDa && !ripLaeuft && automatik !== undefined && automatik.text.length > 0 && (
|
||||
<div className={`mt-4 flex flex-wrap items-center gap-3 rounded-xl border p-3 ${automatik.aktiv ? 'border-gold/45 bg-gold/10' : 'border-white/10 bg-samt/60'}`}>
|
||||
{automatik.aktiv && (
|
||||
<span className="font-mono text-[28px] font-bold leading-none text-gold-hell">
|
||||
{automatik.sekunden}
|
||||
<span className="text-sm text-gold/70"> s</span>
|
||||
</span>
|
||||
)}
|
||||
<p className={`min-w-0 flex-1 font-mono text-[11px] leading-5 ${automatik.aktiv ? 'text-gold-hell' : 'text-nebel'}`}>{automatik.text}</p>
|
||||
{automatik.aktiv && (
|
||||
<div className="flex gap-2">
|
||||
<button onClick={() => automatikJetzt(geraet.id)} className="rounded-lg border border-gold/40 bg-gold/15 px-3 py-1 text-[11px] font-semibold text-gold-hell hover:bg-gold/25">
|
||||
Jetzt
|
||||
</button>
|
||||
<button onClick={() => automatikStopp(geraet.id)} className="rounded-lg border border-white/15 px-3 py-1 text-[11px] text-dunst hover:text-schnee">
|
||||
Stopp
|
||||
</button>
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
)}
|
||||
|
||||
{/* Laufwerks-Gesundheit (5.4.0, Punkt 8): Disc oder Hardware? Kommt
|
||||
von selbst nach einem gescheiterten Rip — oder auf Knopfdruck. */}
|
||||
{bericht !== undefined && (berichtOffen || bericht.urteil !== 'ruhig') && (
|
||||
<div className={`mt-4 rounded-xl border p-3 ${berichtTon}`}>
|
||||
<div className="flex items-start justify-between gap-3">
|
||||
<p className="font-mono text-[11px] leading-5">
|
||||
<span className="font-semibold">
|
||||
{bericht.urteil === 'ruhig' ? 'LAUFWERK RUHIG' : bericht.urteil === 'disc' ? 'VERDACHT: DIE DISC' : bericht.urteil === 'hardware' ? 'VERDACHT: DIE HARDWARE' : 'PROTOKOLL'}
|
||||
</span>{' '}
|
||||
— {bericht.text}
|
||||
</p>
|
||||
<button onClick={() => setBerichtOffen(false)} className="flex-none font-mono text-[10.5px] text-nebel hover:text-dunst">
|
||||
ausblenden
|
||||
</button>
|
||||
</div>
|
||||
{bericht.letzte.length > 0 && (
|
||||
<div className="mt-1.5 space-y-0.5">
|
||||
{bericht.letzte.map((z, i) => (
|
||||
<p key={i} className="font-mono text-[10.5px] text-nebel">
|
||||
{z}
|
||||
</p>
|
||||
))}
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
)}
|
||||
|
||||
{rip !== undefined && (
|
||||
<div className="mt-4 rounded-xl border border-white/10 bg-samt/80 p-4 backdrop-blur">
|
||||
<div className="flex items-end justify-between gap-5">
|
||||
<div className="min-w-0 flex-1">
|
||||
<div className="mb-2 flex items-baseline justify-between gap-3">
|
||||
<span
|
||||
className={`font-mono text-[10.5px] tracking-[0.12em] ${
|
||||
rip.phase === 'fehler' ? 'text-rot' : rip.phase === 'fertig' ? (rip.lesefehler ? 'text-warn' : 'text-gruen') : 'text-gold-hell'
|
||||
}`}
|
||||
>
|
||||
{PHASEN_MONO[rip.phase]}
|
||||
{rip.lesefehler && rip.phase === 'fertig' ? ' — MIT LESEFEHLERN' : ''}
|
||||
</span>
|
||||
{ripLaeuft && <span className="font-mono text-[10.5px] text-nebel">{restzeitText(rip.prozent, ripStartMs)}</span>}
|
||||
</div>
|
||||
{ripLaeuft && <SegmentBalken prozent={rip.prozent} />}
|
||||
{ripLaeuft && (rip.titelGesamt ?? 0) > 1 && (
|
||||
<p className="mt-1.5 font-mono text-[10.5px] text-nebel">
|
||||
Titel {rip.titelNr} von {rip.titelGesamt}
|
||||
</p>
|
||||
)}
|
||||
{rip.rettung !== undefined && (
|
||||
<p className="mt-1.5 font-mono text-[10.5px] text-warn">
|
||||
Rettungs-Abbild: {rip.rettung.unlesbareSektoren} unlesbare Sektoren an {rip.rettung.stellen} Stellen mit Nullen gefüllt
|
||||
</p>
|
||||
)}
|
||||
|
||||
{/* Der Defekt-Waechter (§ 6.2): Dieselbe Stelle wieder und
|
||||
wieder ist kein Fortschritt, sondern ein physischer
|
||||
Defekt. Vorher lief MakeMKV dort stundenlang weiter,
|
||||
waehrend identische Zeilen durchs Protokoll rauschten. */}
|
||||
{rip.haengt != null && (
|
||||
<div className="mt-3 rounded-xl border border-warn/45 bg-warn/10 p-3">
|
||||
<p className="font-mono text-[11px] font-semibold text-warn">Die Disc hat an einer Stelle einen Defekt.</p>
|
||||
<p className="mt-1 font-mono text-[11px] leading-5 text-dunst">
|
||||
MakeMKV versucht es seit {rip.haengt.wiederholungen} Meldungen immer wieder an derselben Stelle (Byte {rip.haengt.offset}). Das wird nicht
|
||||
besser — der Rest der Disc ist davon nicht betroffen. Nach dem Abbruch bietet Rippy das Rettungs-Abbild an.
|
||||
</p>
|
||||
<div className="mt-2 flex flex-wrap items-center gap-2">
|
||||
<button
|
||||
onClick={() => ripUeberspringen(geraet.id)}
|
||||
className="rounded-lg border border-warn/50 bg-warn/15 px-3 py-1 text-[11px] font-semibold text-warn hover:bg-warn/25"
|
||||
title="Diesen Titel aufgeben und mit dem naechsten weitermachen"
|
||||
>
|
||||
Titel ueberspringen
|
||||
</button>
|
||||
<span className="font-mono text-[10.5px] text-nebel">oder weiter versuchen — abbrechen geht oben.</span>
|
||||
</div>
|
||||
</div>
|
||||
)}
|
||||
|
||||
<p className="mt-2 truncate font-mono text-[11px] text-nebel" title={rip.text}>
|
||||
> {rip.text}
|
||||
</p>
|
||||
{rip.dateien.map((datei) => (
|
||||
<p key={datei} className="break-all font-mono text-[11px] text-nebel/80">
|
||||
{datei}
|
||||
</p>
|
||||
))}
|
||||
|
||||
{/* Nach dem Rip (5.4.0): Wo steht die Kompression? Das
|
||||
Laufwerk ist schon frei — die Arbeit läuft im Hintergrund. */}
|
||||
{rip.phase === 'fertig' && vorgang !== undefined && (
|
||||
<div className="mt-3 rounded-lg border border-white/8 bg-buehne/60 p-2.5">
|
||||
{kompression !== null ? (
|
||||
<>
|
||||
<p className="font-mono text-[10.5px] tracking-[0.12em] text-gold-hell">
|
||||
KOMPRESSION LÄUFT{kompression.prozent >= 0 ? ` — ${kompression.prozent} %` : ''}
|
||||
</p>
|
||||
<div className="mt-1.5">
|
||||
<SegmentBalken prozent={kompression.prozent} />
|
||||
</div>
|
||||
<p className="mt-1.5 truncate font-mono text-[11px] text-nebel" title={kompression.text}>
|
||||
> {kompression.text}
|
||||
</p>
|
||||
</>
|
||||
) : wartePlatz > 0 ? (
|
||||
<p className="font-mono text-[11px] text-dunst">Kompression wartet — Platz {wartePlatz} in der Warteschlange.</p>
|
||||
) : vorgang.phase === 'fertig' ? (
|
||||
<p className="break-all font-mono text-[11px] text-gruen">
|
||||
✓ {vorgang.komprimiert ? 'Komprimiert und abgelegt' : 'Verlustfrei abgelegt'}: {vorgang.zielOrdner}
|
||||
{vorgang.fertigBytes > 0 && ` (${gb(vorgang.fertigBytes)})`}
|
||||
</p>
|
||||
) : vorgang.phase === 'fehler' || vorgang.phase === 'abgebrochen' ? (
|
||||
<p className="break-all font-mono text-[11px] text-warn">⚠ {vorgang.fehler.length > 0 ? vorgang.fehler : `Kompression ${vorgang.phase}`}</p>
|
||||
) : (
|
||||
<p className="font-mono text-[11px] text-dunst">Kompression: {vorgang.phase}</p>
|
||||
)}
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
{ripLaeuft && rip.prozent >= 0 && (
|
||||
<div className="flex-none font-mono text-[42px] font-bold leading-none text-gold-hell">
|
||||
{rip.prozent}
|
||||
<span className="text-lg text-gold/70">%</span>
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
{protokoll.length > 1 && (
|
||||
<button onClick={() => setProtokollOffen((o) => !o)} className="mt-2 font-mono text-[10.5px] text-nebel hover:text-dunst">
|
||||
{protokollOffen ? '▾ PROTOKOLL AUSBLENDEN' : `▸ PROTOKOLL (${protokoll.length} ZEILEN)`}
|
||||
</button>
|
||||
)}
|
||||
{protokollOffen && (
|
||||
<div className="mt-1 max-h-40 space-y-0.5 overflow-y-auto rounded-lg bg-buehne p-2">
|
||||
{protokoll.map((zeile, i) => (
|
||||
<p key={i} className="break-all font-mono text-[10.5px] leading-4 text-nebel">
|
||||
> {zeile}
|
||||
</p>
|
||||
))}
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
</div>
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,86 @@
|
||||
// Speicher und Statistik in der Übersicht (5.5.0, Commander: „Ist mir zu
|
||||
// leer … wie viel Speicher noch auf dem Server oder auf dem Arbeitsordner
|
||||
// frei ist"). Gemessen im Kern mit fs.statfs — lokal wie auf der Freigabe.
|
||||
import type { SpeicherPlatz, SpeicherStand, Statistik } from '../../gemeinsam/nachrichten'
|
||||
import { FuellBalken, dauerGrob, gbKurz } from '../bausteine'
|
||||
import { speicherLaden } from '../kernverbindung'
|
||||
|
||||
/** Ab hier wird gewarnt: eine Blu-ray braucht rund 50 GB (Roh + Kompression). */
|
||||
export const WENIG_FREI_BYTES = 60e9
|
||||
export const SEHR_WENIG_FREI_BYTES = 20e9
|
||||
|
||||
function Platz({ name, platz, hinweis }: { name: string; platz: SpeicherPlatz; hinweis: string }) {
|
||||
const ton = !platz.ok ? 'rot' : platz.freiBytes < SEHR_WENIG_FREI_BYTES ? 'rot' : platz.freiBytes < WENIG_FREI_BYTES ? 'warn' : 'gold'
|
||||
const belegt = platz.ok && platz.gesamtBytes > 0 ? 1 - platz.freiBytes / platz.gesamtBytes : 0
|
||||
return (
|
||||
<div className="rounded-xl border border-white/8 bg-samt/50 p-3">
|
||||
<div className="flex items-baseline justify-between gap-3">
|
||||
<span className="font-mono text-[10px] tracking-[0.14em] text-nebel">{name}</span>
|
||||
<span className={`font-mono text-[13px] font-semibold ${ton === 'rot' ? 'text-rot' : ton === 'warn' ? 'text-warn' : 'text-schnee'}`}>
|
||||
{platz.ok ? `${gbKurz(platz.freiBytes)} frei` : 'nicht messbar'}
|
||||
</span>
|
||||
</div>
|
||||
<div className="mt-2">
|
||||
<FuellBalken anteil={belegt} ton={ton} />
|
||||
</div>
|
||||
<p className="mt-1.5 break-all font-mono text-[10.5px] text-nebel" title={platz.pfad}>
|
||||
{platz.pfad}
|
||||
{platz.ok && ` · ${gbKurz(platz.gesamtBytes)} gesamt`}
|
||||
{!platz.ok && platz.fehler.length > 0 && ` · ${platz.fehler}`}
|
||||
</p>
|
||||
<div className="mt-1.5 flex flex-wrap items-center gap-2">
|
||||
<span className="text-[10.5px] text-nebel/80">{hinweis}</span>
|
||||
{platz.ok && (
|
||||
<button onClick={() => void window.rippy.ordnerOeffnen(platz.pfad)} className="ml-auto font-mono text-[10.5px] text-nebel hover:text-dunst" title="Im Explorer zeigen">
|
||||
Ordner öffnen
|
||||
</button>
|
||||
)}
|
||||
</div>
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
export function SpeicherKarte({ speicher, statistik }: { speicher: SpeicherStand | null; statistik: Statistik | null }) {
|
||||
return (
|
||||
<div className="rounded-2xl border border-white/10 bg-karte/50 p-5">
|
||||
<div className="flex items-center gap-2.5 font-mono text-[10.5px] tracking-[0.12em] text-nebel">
|
||||
<span className="text-dunst">SPEICHER UND BILANZ</span>
|
||||
<button onClick={() => speicherLaden()} className="ml-auto font-mono text-[10.5px] text-nebel hover:text-dunst" title="Jetzt neu messen">
|
||||
neu messen
|
||||
</button>
|
||||
</div>
|
||||
{speicher === null ? (
|
||||
<p className="mt-3 font-mono text-xs text-nebel">wird gemessen …</p>
|
||||
) : (
|
||||
<div className={`mt-3 grid gap-3 ${speicher.getrennt ? 'sm:grid-cols-2' : ''}`}>
|
||||
{speicher.getrennt ? (
|
||||
<>
|
||||
<Platz name="ARBEITSORDNER (LOKAL)" platz={speicher.arbeit} hinweis="Roh-Dateien und Kompression — eine Blu-ray braucht rund 50 GB." />
|
||||
<Platz name="ABLAGE (SERVER)" platz={speicher.ablage} hinweis="Fertige Filme, Serien und Musik." />
|
||||
</>
|
||||
) : (
|
||||
<Platz name="ABLAGE UND ARBEIT" platz={speicher.ablage} hinweis="Roh-Dateien, Kompression und Fertiges am selben Ort — ein eigener Arbeitsordner geht unter Einstellungen → Ablage." />
|
||||
)}
|
||||
</div>
|
||||
)}
|
||||
{statistik !== null && statistik.discs > 0 && (
|
||||
<div className="mt-3 grid grid-cols-2 gap-2.5 sm:grid-cols-4">
|
||||
<Zahl label="DISCS" wert={String(statistik.discs)} zusatz={`${statistik.fertige} fertig`} />
|
||||
<Zahl label="VERLUSTFREI GESICHERT" wert={gbKurz(statistik.rohBytes)} zusatz="Summe aller Rips" />
|
||||
<Zahl label="FERTIG ABGELEGT" wert={gbKurz(statistik.fertigBytes)} zusatz="komprimiert oder verschoben" />
|
||||
<Zahl label="JE DISC" wert={statistik.fertige > 0 ? dauerGrob(statistik.dauerS / statistik.fertige) : '—'} zusatz="Rip bis Ablage, im Schnitt" />
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
function Zahl({ label, wert, zusatz }: { label: string; wert: string; zusatz: string }) {
|
||||
return (
|
||||
<div className="rounded-lg border border-white/10 bg-samt/70 px-3 py-2">
|
||||
<div className="font-mono text-[9px] tracking-[0.14em] text-nebel">{label}</div>
|
||||
<div className="mt-0.5 font-display text-[19px] font-bold leading-tight text-gold-hell">{wert}</div>
|
||||
<div className="font-mono text-[10px] text-nebel/80">{zusatz}</div>
|
||||
</div>
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,183 @@
|
||||
// Die Übersicht — Laufwerke, Warteschlange, Speicher und Bilanz, Verlauf,
|
||||
// Ereignisse. Und die Dialoge: Sie leben im Zustand DIESES Bereichs, nicht
|
||||
// in der Kachel (5.4.0: ein leerer Takt der Wache räumte sonst Kachel UND
|
||||
// Dialog ab).
|
||||
import { useState } from 'react'
|
||||
import type { HauptStatus } from '../../gemeinsam/nachrichten'
|
||||
import { IconDisc, LAUFENDE_PHASEN } from '../bausteine'
|
||||
import { AendernDialog } from '../dialoge/AendernDialog'
|
||||
import { TitelWahlDialog } from '../dialoge/TitelWahlDialog'
|
||||
import { automatikStopp, titelLesen, type Verbindung } from '../kernverbindung'
|
||||
import { KompressionsKarte } from './KompressionsKarte'
|
||||
import { LaufwerkKachel } from './LaufwerkKachel'
|
||||
import { SpeicherKarte } from './SpeicherKarte'
|
||||
import { VerlaufKarte } from './VerlaufKarte'
|
||||
|
||||
export function Uebersicht({
|
||||
verbindung,
|
||||
haupt,
|
||||
systemFehler,
|
||||
aufRohDateien,
|
||||
}: {
|
||||
verbindung: Verbindung
|
||||
haupt: HauptStatus | null
|
||||
systemFehler: string[]
|
||||
aufRohDateien: () => void
|
||||
}) {
|
||||
// Sagt ein Update-Knopf NEIN, steht der Grund daneben (R4) — ein Knopf,
|
||||
// der nichts tut und nichts sagt, ist schlimmer als kein Knopf.
|
||||
const [updateHinweis, setUpdateHinweis] = useState('')
|
||||
const [dialog, setDialog] = useState<{ art: 'titel' | 'aendern'; id: string } | null>(null)
|
||||
const einRipLaeuft = Object.values(verbindung.rips).some((r) => LAUFENDE_PHASEN.includes(r.phase))
|
||||
|
||||
return (
|
||||
<>
|
||||
{systemFehler.length > 0 && (
|
||||
<div className="rounded-2xl border border-rot/40 bg-rot/10 p-4">
|
||||
{systemFehler.map((zeile, i) => (
|
||||
<p key={i} className="break-all font-mono text-xs text-rot">
|
||||
✗ {zeile}
|
||||
</p>
|
||||
))}
|
||||
</div>
|
||||
)}
|
||||
|
||||
{/* § 6.8: Ein verfügbares Update ist eine SICHTBARE Karte, kein
|
||||
Satz in den Einstellungen. Der Commander musste es am
|
||||
01.09.2026 suchen — gefunden hat er es nicht. */}
|
||||
{haupt !== null && haupt.update.neueVersion.length > 0 && (
|
||||
<div className="rounded-2xl border border-gold/40 bg-gold/10 p-4">
|
||||
<div className="flex flex-wrap items-baseline gap-x-3 gap-y-1">
|
||||
<span className="font-display text-lg text-gold-hell">Update verfügbar — Version {haupt.update.neueVersion}</span>
|
||||
<span className="font-mono text-xs text-nebel">du hast {haupt.version}</span>
|
||||
</div>
|
||||
<p className="mt-1 font-mono text-xs text-dunst">{haupt.update.text}</p>
|
||||
{haupt.update.fortschritt >= 0 && !haupt.update.bereit && (
|
||||
<div className="mt-2 h-1.5 w-full overflow-hidden rounded-full bg-white/10">
|
||||
<div className="h-full rounded-full bg-gold transition-all" style={{ width: `${Math.max(0, Math.min(100, haupt.update.fortschritt))}%` }} />
|
||||
</div>
|
||||
)}
|
||||
{haupt.update.neuerungen.length > 0 && (
|
||||
<div className="mt-3 rounded-xl border border-white/8 bg-buehne/60 p-3">
|
||||
<p className="text-[11px] uppercase tracking-wider text-nebel">Was neu ist</p>
|
||||
<p className="mt-1 whitespace-pre-wrap font-mono text-xs leading-5 text-dunst">{haupt.update.neuerungen}</p>
|
||||
</div>
|
||||
)}
|
||||
{haupt.update.bereit && (
|
||||
<div className="mt-3 flex flex-wrap items-center gap-2">
|
||||
<button
|
||||
onClick={() => {
|
||||
setUpdateHinweis('')
|
||||
void window.rippy.updateInstallieren().then((urteil) => {
|
||||
if (!urteil.ok) setUpdateHinweis(urteil.grund)
|
||||
})
|
||||
}}
|
||||
disabled={einRipLaeuft}
|
||||
className="rounded-lg border border-gold/40 bg-gold/15 px-3 py-1.5 text-xs font-semibold text-gold-hell hover:bg-gold/25 disabled:opacity-35"
|
||||
title={einRipLaeuft ? 'Erst wenn der Rip fertig ist — Rippy startet dafür neu.' : 'Rippy beendet sich, installiert und startet wieder.'}
|
||||
>
|
||||
Jetzt neu starten und installieren
|
||||
</button>
|
||||
<span className="font-mono text-[11px] text-nebel">… oder einfach nichts tun: Beim nächsten Beenden passiert es von selbst.</span>
|
||||
</div>
|
||||
)}
|
||||
{updateHinweis.length > 0 && <p className="mt-2 font-mono text-xs text-warn">{updateHinweis}</p>}
|
||||
</div>
|
||||
)}
|
||||
|
||||
<section>
|
||||
{verbindung.laufwerke.length === 0 ? (
|
||||
<div className="flex items-center gap-5 rounded-2xl border border-white/10 bg-karte/50 p-6">
|
||||
<IconDisc groesse={44} farbe="oklch(0.4 0.02 75)" />
|
||||
<p className="font-mono text-xs text-nebel">{verbindung.verbunden ? 'Kein optisches Laufwerk gefunden.' : 'Warte auf den Kern …'}</p>
|
||||
</div>
|
||||
) : (
|
||||
<div className="space-y-4">
|
||||
{verbindung.laufwerke.map((geraet) => {
|
||||
const ripVorgangId = verbindung.rips[geraet.id]?.vorgangId ?? ''
|
||||
const laeuft = verbindung.vorgaenge?.kompression.laeuft ?? null
|
||||
const wartend = verbindung.vorgaenge?.kompression.wartend ?? []
|
||||
return (
|
||||
<LaufwerkKachel
|
||||
key={geraet.id}
|
||||
geraet={geraet}
|
||||
rip={verbindung.rips[geraet.id]}
|
||||
info={verbindung.discInfos[geraet.id]}
|
||||
ripStartMs={verbindung.ripStart[geraet.id]}
|
||||
protokoll={verbindung.ripProtokoll[geraet.id] ?? []}
|
||||
verbindung={verbindung}
|
||||
bericht={verbindung.gesundheit[geraet.id]}
|
||||
vorgang={verbindung.vorgaenge?.vorgaenge.find((v) => v.id === ripVorgangId)}
|
||||
kompression={laeuft !== null && laeuft.vorgangId === ripVorgangId ? laeuft : null}
|
||||
wartePlatz={wartend.findIndex((w) => w.vorgangId === ripVorgangId) + 1}
|
||||
automatik={verbindung.automatik[geraet.id]}
|
||||
aufRippen={() => {
|
||||
// Der Nutzer entscheidet selbst — ein Countdown endet.
|
||||
automatikStopp(geraet.id)
|
||||
// Erst die Titel lesen (20-120 s), dann waehlen lassen.
|
||||
setDialog({ art: 'titel', id: geraet.id })
|
||||
titelLesen(geraet.id)
|
||||
}}
|
||||
aufAendern={() => {
|
||||
automatikStopp(geraet.id)
|
||||
setDialog({ art: 'aendern', id: geraet.id })
|
||||
}}
|
||||
/>
|
||||
)
|
||||
})}
|
||||
</div>
|
||||
)}
|
||||
</section>
|
||||
|
||||
{verbindung.vorgaenge !== null && (
|
||||
<section>
|
||||
<KompressionsKarte stand={verbindung.vorgaenge.kompression} />
|
||||
</section>
|
||||
)}
|
||||
|
||||
<section>
|
||||
<SpeicherKarte speicher={verbindung.speicher} statistik={verbindung.vorgaenge?.statistik ?? null} />
|
||||
</section>
|
||||
|
||||
{verbindung.vorgaenge !== null && (
|
||||
<section>
|
||||
<VerlaufKarte vorgaenge={verbindung.vorgaenge.vorgaenge} aufAlle={aufRohDateien} />
|
||||
</section>
|
||||
)}
|
||||
|
||||
{dialog !== null && dialog.art === 'titel' && (
|
||||
<TitelWahlDialog
|
||||
id={dialog.id}
|
||||
typ={verbindung.laufwerke.find((l) => l.id === dialog.id)?.typ ?? 'bluray'}
|
||||
stand={verbindung.discTitel[dialog.id]}
|
||||
info={verbindung.discInfos[dialog.id]}
|
||||
einstellungen={verbindung.einstellungen}
|
||||
regel={verbindung.vorgaenge?.regel ?? ''}
|
||||
speicher={verbindung.speicher}
|
||||
schliessen={() => setDialog(null)}
|
||||
/>
|
||||
)}
|
||||
{dialog !== null && dialog.art === 'aendern' && (
|
||||
<AendernDialog
|
||||
id={dialog.id}
|
||||
startText={verbindung.discInfos[dialog.id]?.titel ?? ''}
|
||||
vorschlaege={verbindung.vorschlaege[dialog.id] ?? []}
|
||||
schliessen={() => setDialog(null)}
|
||||
/>
|
||||
)}
|
||||
|
||||
{verbindung.meldungen.length > 0 && (
|
||||
<section>
|
||||
<div className="mb-2.5 font-mono text-[10px] tracking-[0.22em] text-nebel">EREIGNISSE</div>
|
||||
<div className="max-h-56 space-y-1 overflow-y-auto rounded-2xl border border-white/10 bg-karte/50 p-4">
|
||||
{verbindung.meldungen.map((zeile, i) => (
|
||||
<p key={i} className="break-all font-mono text-[11px] text-dunst">
|
||||
{zeile}
|
||||
</p>
|
||||
))}
|
||||
</div>
|
||||
</section>
|
||||
)}
|
||||
</>
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
// Der Verlauf (5.5.0) — die letzten Vorgänge auf einen Blick, statt der
|
||||
// Bibliothek (Commander: „Brauchen wir die wirklich?" — nein: Jellyfin IST
|
||||
// die Bibliothek; die Wiedererkennung braucht keine Ansicht).
|
||||
import type { GeraeteInfo, VorgangEintrag } from '../../gemeinsam/nachrichten'
|
||||
import { Badge, TYP_NAMEN, datumKurz, gb } from '../bausteine'
|
||||
|
||||
const PHASEN_TEXT: Record<VorgangEintrag['phase'], string> = {
|
||||
rippt: 'rippt',
|
||||
wartet: 'wartet',
|
||||
komprimiert: 'komprimiert',
|
||||
'legt-ab': 'legt ab',
|
||||
fertig: 'fertig',
|
||||
fehler: 'Fehler',
|
||||
abgebrochen: 'abgebrochen',
|
||||
}
|
||||
|
||||
export function phasenTon(p: VorgangEintrag['phase']): 'gruen' | 'gelb' | 'blau' | 'grau' {
|
||||
return p === 'fertig' ? 'gruen' : p === 'fehler' || p === 'abgebrochen' ? 'gelb' : p === 'wartet' ? 'grau' : 'blau'
|
||||
}
|
||||
|
||||
export function VerlaufKarte({ vorgaenge, aufAlle }: { vorgaenge: VorgangEintrag[]; aufAlle: () => void }) {
|
||||
if (vorgaenge.length === 0) return null
|
||||
const letzte = vorgaenge.slice(0, 6)
|
||||
return (
|
||||
<div className="rounded-2xl border border-white/10 bg-karte/50 p-5">
|
||||
<div className="flex items-center gap-2.5 font-mono text-[10.5px] tracking-[0.12em] text-nebel">
|
||||
<span className="text-dunst">VERLAUF</span>
|
||||
<span>·</span>
|
||||
<span>die letzten {letzte.length} Vorgänge</span>
|
||||
<button onClick={aufAlle} className="ml-auto font-mono text-[10.5px] text-nebel hover:text-dunst">
|
||||
alle unter Roh-Dateien →
|
||||
</button>
|
||||
</div>
|
||||
<div className="mt-3 space-y-1">
|
||||
{letzte.map((v) => (
|
||||
<div key={v.id} className="flex flex-wrap items-center gap-x-3 gap-y-1 rounded-lg border border-white/8 bg-samt/40 px-3 py-2">
|
||||
<span className="min-w-0 flex-1 truncate font-display text-[14px] font-bold text-schnee" title={v.titel}>
|
||||
{v.titel}
|
||||
{v.jahr !== null && <span className="ml-1 font-medium text-dunst">({v.jahr})</span>}
|
||||
</span>
|
||||
<Badge text={PHASEN_TEXT[v.phase]} ton={phasenTon(v.phase)} />
|
||||
<span className="font-mono text-[10.5px] text-nebel">
|
||||
{(TYP_NAMEN[v.typ as GeraeteInfo['typ']] ?? v.typ).toUpperCase()} · {datumKurz(v.begonnen)}
|
||||
{v.phase === 'fertig' && v.fertigBytes > 0 && ` · ${gb(v.fertigBytes)}`}
|
||||
{!v.rohGeloescht && v.rohBytes > 0 && ` · Roh ${gb(v.rohBytes)}`}
|
||||
</span>
|
||||
{v.phase === 'fertig' && v.zielOrdner.length > 0 && (
|
||||
<button
|
||||
onClick={() => void window.rippy.ordnerOeffnen(v.zielOrdner)}
|
||||
className="font-mono text-[10.5px] text-nebel hover:text-dunst"
|
||||
title={v.zielOrdner}
|
||||
>
|
||||
Ordner öffnen
|
||||
</button>
|
||||
)}
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
</div>
|
||||
)
|
||||
}
|
||||
@@ -45,6 +45,8 @@ export type AuswurfGrund = 'ok' | 'kein-zugriff' | 'abgelehnt' | 'bleibt-drin'
|
||||
// ── Rippen (Etappe W-2) ─────────────────────────────────────────────────
|
||||
export type RipPhase =
|
||||
| 'liest-info'
|
||||
/** 5.5.0: Das Rettungs-Abbild wird gelesen — Sektor für Sektor, Nullen für Unlesbares. */
|
||||
| 'rettet'
|
||||
| 'rippt'
|
||||
| 'komprimiert'
|
||||
| 'legt-ab'
|
||||
@@ -72,6 +74,12 @@ export interface RipStatus {
|
||||
/** Der Vorgang, zu dem dieser Rip gehört (5.4.0) — die Kompression läuft
|
||||
* danach unter dieser Kennung in der Warteschlange weiter. */
|
||||
vorgangId?: string
|
||||
/** 5.5.0: Rippy hat an dieser Disc Lesefehler GESEHEN (Defekt-Wächter,
|
||||
* Lesefehler-Meldung, Leseabbruch) — erst dann wird das Rettungs-Abbild
|
||||
* angeboten. Eine heile Disc braucht es nicht (Commander 01.09.2026). */
|
||||
rettungMoeglich?: boolean
|
||||
/** 5.5.0: Stand des Rettungs-Abbilds — unlesbare Sektoren und Stellen. */
|
||||
rettung?: { unlesbareSektoren: number; stellen: number }
|
||||
}
|
||||
|
||||
/** Was ein Titel IST — davon hängt ab, WOHIN er abgelegt wird:
|
||||
@@ -195,9 +203,13 @@ export interface DiscInfoStand {
|
||||
/** Was Rippy NACH dem Info-Lauf noch dazugelernt hat („Laufzeit
|
||||
* bestätigt: 124 min"), Klartext-Zeilen. */
|
||||
hinweise: string[]
|
||||
/** 5.5.0 Serien-Merker: Was Rippy von der VORIGEN Disc dieser Serie weiß —
|
||||
* Staffel und die Folge, mit der es weitergeht. null, wenn nichts. */
|
||||
serienMerker: { staffel: number; naechsteFolge: number; wann: string } | null
|
||||
}
|
||||
|
||||
/** Ein Eintrag der Bibliothek (§ 6.6). */
|
||||
/** Ein Eintrag der Bibliothek (§ 6.6) — seit 5.5.0 nur noch die
|
||||
* Wiedererkennung („schon gerippt am …"), keine eigene Ansicht mehr. */
|
||||
export interface BibliothekEintrag {
|
||||
fingerprint: string
|
||||
titel: string
|
||||
@@ -207,7 +219,7 @@ export interface BibliothekEintrag {
|
||||
ablageort: string
|
||||
datum: string
|
||||
dauerS: number
|
||||
/** TMDb-Posterpfad fürs Bibliotheks-Regal — '' wenn keiner bekannt. */
|
||||
/** TMDb-Posterpfad — '' wenn keiner bekannt. */
|
||||
posterPfad: string
|
||||
}
|
||||
|
||||
@@ -247,7 +259,7 @@ export interface BeschaffungStand {
|
||||
export type VorgangPhase = 'rippt' | 'wartet' | 'komprimiert' | 'legt-ab' | 'fertig' | 'fehler' | 'abgebrochen'
|
||||
|
||||
/** Ein Vorgang, wie das Fenster ihn zeigt (Einstellungen → Roh-Dateien,
|
||||
* Übersicht → Kompression). */
|
||||
* Übersicht → Verlauf). */
|
||||
export interface VorgangEintrag {
|
||||
id: string
|
||||
laufwerk: string
|
||||
@@ -289,6 +301,20 @@ export interface FremderOrdner {
|
||||
bytes: number
|
||||
}
|
||||
|
||||
/** 5.5.0: Was Rippy insgesamt geschafft hat (aus den Vorgängen). */
|
||||
export interface Statistik {
|
||||
/** Vorgänge insgesamt (Video-Discs). */
|
||||
discs: number
|
||||
/** Davon fertig abgelegt. */
|
||||
fertige: number
|
||||
/** Verlustfrei gesichert, Summe aller Rips (auch wenn Roh inzwischen weg ist). */
|
||||
rohBytes: number
|
||||
/** Fertig abgelegt, Summe. */
|
||||
fertigBytes: number
|
||||
/** Summe der Dauer je fertigem Vorgang (Rip-Beginn bis Ablage-Ende) in Sekunden. */
|
||||
dauerS: number
|
||||
}
|
||||
|
||||
export interface VorgaengeStand {
|
||||
vorgaenge: VorgangEintrag[]
|
||||
/** Summe aller Roh-Ordner, die noch da sind. */
|
||||
@@ -296,7 +322,8 @@ export interface VorgaengeStand {
|
||||
fremde: FremderOrdner[]
|
||||
/** Die Aufbewahrungs-Regel, die gerade gilt (Einstellung rohAufbewahrung). */
|
||||
regel: string
|
||||
kompression: { laeuft: KompressionStand | null; wartend: KompressionStand[] }
|
||||
kompression: { laeuft: KompressionStand | null; wartend: KompressionStand[]; pausiert: boolean }
|
||||
statistik: Statistik
|
||||
}
|
||||
|
||||
/** Was das Windows-Ereignisprotokoll über ein Laufwerk sagt (5.4.0). */
|
||||
@@ -313,6 +340,33 @@ export interface LaufwerkBericht {
|
||||
stunden: number
|
||||
}
|
||||
|
||||
/** 5.5.0: Freier Platz an EINEM Ort — gemessen mit fs.statfs (Node 24). */
|
||||
export interface SpeicherPlatz {
|
||||
pfad: string
|
||||
ok: boolean
|
||||
freiBytes: number
|
||||
gesamtBytes: number
|
||||
/** '' wenn ok — sonst, warum nicht messbar (Pfad fehlt, Netz weg). */
|
||||
fehler: string
|
||||
}
|
||||
|
||||
export interface SpeicherStand {
|
||||
/** Wo Roh-Dateien und Kompression liegen (Arbeitsordner oder Ablage). */
|
||||
arbeit: SpeicherPlatz
|
||||
/** Wo Fertiges landet (die Ablage — beim Commander der Server). */
|
||||
ablage: SpeicherPlatz
|
||||
/** true, wenn ein eigener Arbeitsordner gesetzt ist. */
|
||||
getrennt: boolean
|
||||
}
|
||||
|
||||
/** 5.5.0 Automatik: Countdown bis zum Rip ohne Klick (KONZEPT § 5 Zero-Click). */
|
||||
export interface AutomatikStand {
|
||||
id: string
|
||||
aktiv: boolean
|
||||
sekunden: number
|
||||
text: string
|
||||
}
|
||||
|
||||
/** Nachrichten, die der Kern verschickt. */
|
||||
export type KernNachricht =
|
||||
| { art: 'kern-bereit'; pid: number; nodeVersion: string; datenbank: DbStatus }
|
||||
@@ -329,7 +383,6 @@ export type KernNachricht =
|
||||
| { art: 'metadaten-vorschlaege'; id: string; vorschlaege: MetaVorschlag[] }
|
||||
| { art: 'einstellungen'; werte: Record<string, string> }
|
||||
| { art: 'werkzeuge'; auskunft: WerkzeugAuskunft }
|
||||
| { art: 'bibliothek'; eintraege: BibliothekEintrag[] }
|
||||
| { art: 'beschaffung-status'; stand: BeschaffungStand }
|
||||
/** Nur fürs Haupt: Der Kern hat einen geprüften Installer abgelegt —
|
||||
* starten kann ihn nur das Haupt (shell/UAC, § 9). */
|
||||
@@ -354,6 +407,12 @@ export type KernNachricht =
|
||||
/** Eine Kompression ist zu Ende — fürs Toast und die Ereignis-Zeile. */
|
||||
| { art: 'kompression-ergebnis'; vorgangId: string; titel: string; ok: boolean; text: string }
|
||||
| { art: 'laufwerk-gesundheit'; id: string; bericht: LaufwerkBericht }
|
||||
/** 5.5.0: freier Platz an Arbeitsordner und Ablage. */
|
||||
| { art: 'speicher'; stand: SpeicherStand }
|
||||
/** 5.5.0: Automatik-Countdown je Laufwerk. */
|
||||
| { art: 'automatik'; stand: AutomatikStand }
|
||||
/** 5.5.0: Poster beliebter Filme für den Hintergrund der Erst-Einrichtung. */
|
||||
| { art: 'poster-vorschau'; pfade: string[] }
|
||||
|
||||
/** Nachrichten, die das Fenster über den MessagePort an den Kern schickt. */
|
||||
export type FensterNachricht =
|
||||
@@ -374,7 +433,6 @@ export type FensterNachricht =
|
||||
| { art: 'zuordnung-setzen'; id: string; vorschlag: MetaVorschlag }
|
||||
| { art: 'einstellungen-laden' }
|
||||
| { art: 'werkzeuge-laden' }
|
||||
| { art: 'bibliothek-laden' }
|
||||
/** § 9: MakeMKV über die Quellenkette holen und installieren lassen. */
|
||||
| { art: 'makemkv-update' }
|
||||
/** Schlüsselkette sofort neu laufen lassen (z. B. nach einer Installation). */
|
||||
@@ -394,6 +452,20 @@ export type FensterNachricht =
|
||||
| { art: 'fremden-ordner-loeschen'; ordner: string }
|
||||
/** Das Windows-Ereignisprotokoll zu diesem Laufwerk lesen. */
|
||||
| { art: 'laufwerk-pruefen'; id: string }
|
||||
// ── 5.5.0 ──
|
||||
/** Die Kompressions-Warteschlange anhalten (an) oder weiterlaufen lassen. */
|
||||
| { art: 'kompression-pause'; an: boolean }
|
||||
/** Den Automatik-Countdown dieses Laufwerks stoppen bzw. sofort rippen. */
|
||||
| { art: 'automatik-stopp'; id: string }
|
||||
| { art: 'automatik-jetzt'; id: string }
|
||||
/** Testnachricht über die eingerichteten Kanäle (Discord, Telegram). */
|
||||
| { art: 'benachrichtigung-testen' }
|
||||
/** Poster beliebter Filme laden (Erst-Einrichtung). */
|
||||
| { art: 'poster-laden' }
|
||||
/** Rettungs-Abbild für eine Disc mit GESEHENEN Lesefehlern. */
|
||||
| { art: 'rettung-start'; id: string }
|
||||
/** Freien Platz neu messen. */
|
||||
| { art: 'speicher-laden' }
|
||||
|
||||
/** Nachrichten, die das Haupt an den Kern schickt. */
|
||||
export type HauptNachricht =
|
||||
@@ -413,6 +485,8 @@ export interface HauptStatus {
|
||||
/** Für die eigene Titelleiste (§ 4.2, seit 5.1.3): Ist das Fenster
|
||||
* gerade maximiert? Entscheidet nur, welches Symbol der Knopf zeigt. */
|
||||
fensterMaximiert: boolean
|
||||
/** 5.5.0: Wo die Protokoll-Dateien liegen — für „Protokoll öffnen". */
|
||||
protokollOrdner: string
|
||||
}
|
||||
|
||||
/** Der Stand des Selbst-Updates (§ 6.8) — EINE Definition, die sich Haupt
|
||||
@@ -489,8 +563,6 @@ export function istKernNachricht(wert: unknown): wert is KernNachricht {
|
||||
return istObjekt(wert.werte)
|
||||
case 'werkzeuge':
|
||||
return istObjekt(wert.auskunft) && Array.isArray((wert.auskunft as Record<string, unknown>).presets)
|
||||
case 'bibliothek':
|
||||
return Array.isArray(wert.eintraege)
|
||||
case 'schluessel-status':
|
||||
return istObjekt(wert.stand) && typeof (wert.stand as Record<string, unknown>).text === 'string'
|
||||
case 'beschaffung-status':
|
||||
@@ -509,7 +581,8 @@ export function istKernNachricht(wert: unknown): wert is KernNachricht {
|
||||
istObjekt(wert.stand) &&
|
||||
Array.isArray((wert.stand as Record<string, unknown>).vorgaenge) &&
|
||||
typeof (wert.stand as Record<string, unknown>).rohGesamtBytes === 'number' &&
|
||||
istObjekt((wert.stand as Record<string, unknown>).kompression)
|
||||
istObjekt((wert.stand as Record<string, unknown>).kompression) &&
|
||||
istObjekt((wert.stand as Record<string, unknown>).statistik)
|
||||
)
|
||||
case 'kompression-ergebnis':
|
||||
return (
|
||||
@@ -526,6 +599,23 @@ export function istKernNachricht(wert: unknown): wert is KernNachricht {
|
||||
typeof (wert.bericht as Record<string, unknown>).text === 'string' &&
|
||||
Array.isArray((wert.bericht as Record<string, unknown>).letzte)
|
||||
)
|
||||
case 'speicher':
|
||||
return (
|
||||
istObjekt(wert.stand) &&
|
||||
istObjekt((wert.stand as Record<string, unknown>).arbeit) &&
|
||||
istObjekt((wert.stand as Record<string, unknown>).ablage) &&
|
||||
typeof (wert.stand as Record<string, unknown>).getrennt === 'boolean'
|
||||
)
|
||||
case 'automatik':
|
||||
return (
|
||||
istObjekt(wert.stand) &&
|
||||
istKennung((wert.stand as Record<string, unknown>).id) &&
|
||||
typeof (wert.stand as Record<string, unknown>).aktiv === 'boolean' &&
|
||||
typeof (wert.stand as Record<string, unknown>).sekunden === 'number' &&
|
||||
typeof (wert.stand as Record<string, unknown>).text === 'string'
|
||||
)
|
||||
case 'poster-vorschau':
|
||||
return Array.isArray(wert.pfade) && wert.pfade.every(istText)
|
||||
default:
|
||||
return false
|
||||
}
|
||||
@@ -597,10 +687,16 @@ export function istFensterNachricht(wert: unknown): wert is FensterNachricht {
|
||||
wert.art === 'titel-lesen' ||
|
||||
wert.art === 'rip-abbruch' ||
|
||||
wert.art === 'rip-ueberspringen' ||
|
||||
wert.art === 'laufwerk-pruefen'
|
||||
wert.art === 'laufwerk-pruefen' ||
|
||||
wert.art === 'automatik-stopp' ||
|
||||
wert.art === 'automatik-jetzt' ||
|
||||
wert.art === 'rettung-start'
|
||||
) {
|
||||
return istKennung(wert.id)
|
||||
}
|
||||
if (wert.art === 'kompression-pause') {
|
||||
return typeof wert.an === 'boolean'
|
||||
}
|
||||
if (wert.art === 'einstellung-setzen') {
|
||||
return istKennung(wert.schluessel) && typeof wert.wert === 'string'
|
||||
}
|
||||
@@ -622,11 +718,13 @@ export function istFensterNachricht(wert: unknown): wert is FensterNachricht {
|
||||
return (
|
||||
wert.art === 'einstellungen-laden' ||
|
||||
wert.art === 'werkzeuge-laden' ||
|
||||
wert.art === 'bibliothek-laden' ||
|
||||
wert.art === 'makemkv-update' ||
|
||||
wert.art === 'schluessel-pruefen' ||
|
||||
wert.art === 'vorgaenge-laden' ||
|
||||
wert.art === 'roh-aufraeumen'
|
||||
wert.art === 'roh-aufraeumen' ||
|
||||
wert.art === 'benachrichtigung-testen' ||
|
||||
wert.art === 'poster-laden' ||
|
||||
wert.art === 'speicher-laden'
|
||||
)
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,33 @@
|
||||
// Die Platz-Prüfung vor dem Rip (5.5.0) — EINE Rechnung für Kern und
|
||||
// Fenster: Roh plus geschätzt 25 % für die Kompression, plus 2 GB Luft.
|
||||
// Der Kern urteilt beim Start (index.ts ripMitPlatz — auch für die
|
||||
// Automatik), der Dialog zeigt dasselbe Urteil schon vor dem Klick
|
||||
// (TitelWahlDialog).
|
||||
export const PLATZ_LUFT_BYTES = 2e9
|
||||
export const KOMPRESSION_ANTEIL = 0.25
|
||||
|
||||
export interface PlatzUrteil {
|
||||
/** Leer, wenn der Platz reicht — sonst der Grund in Klartext. */
|
||||
text: string
|
||||
/** true: nicht einmal der verlustfreie Rip passt — der Start wird verweigert. */
|
||||
hart: boolean
|
||||
}
|
||||
|
||||
export function gbText(bytes: number): string {
|
||||
return `${(bytes / 1e9).toFixed(1).replace('.', ',')} GB`
|
||||
}
|
||||
|
||||
export function platzUrteil(freiBytes: number, rohBytes: number, komprimiert: boolean): PlatzUrteil {
|
||||
const noetig = rohBytes + (komprimiert ? rohBytes * KOMPRESSION_ANTEIL : 0) + PLATZ_LUFT_BYTES
|
||||
if (freiBytes >= noetig) return { text: '', hart: false }
|
||||
if (freiBytes < rohBytes + PLATZ_LUFT_BYTES) {
|
||||
return {
|
||||
text: `Zu wenig Platz: ${gbText(freiBytes)} frei, der Rip braucht ${gbText(rohBytes)} verlustfrei. Das geht schief — erst Platz schaffen (Einstellungen → Roh-Dateien).`,
|
||||
hart: true,
|
||||
}
|
||||
}
|
||||
return {
|
||||
text: `Knapp: ${gbText(freiBytes)} frei, gebraucht werden etwa ${gbText(noetig)} (Roh plus Kompression). Aufräumen unter Roh-Dateien hilft.`,
|
||||
hart: false,
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,84 @@
|
||||
// Die Protokoll-Datei (5.5.0, aus ARM: LOGPATH/LOGLIFE) — reines Node, damit
|
||||
// Haupt UND Kern sie schreiben können. Eine Datei je Tag unter
|
||||
// <Profil>\logs\rippy-JJJJ-MM-TT.log, ältere als 14 Tage werden beim Start
|
||||
// entfernt. Der Grund: Der Datenbank-Befund vom 01.09.2026 (eine Datenbank,
|
||||
// in die seit dem 30.08. niemand geschrieben hatte) wäre mit einer Zeile
|
||||
// „Datenbank geöffnet: <Pfad>" in einer Datei sofort sichtbar gewesen —
|
||||
// die Konsole eines Tray-Programms sieht niemand.
|
||||
//
|
||||
// Schreibfehler werden NICHT geworfen (das Protokoll darf nie den Betrieb
|
||||
// kippen), aber gezählt und beim nächsten Erfolg vermerkt.
|
||||
import { appendFileSync, existsSync, mkdirSync, readdirSync, unlinkSync, statSync } from 'node:fs'
|
||||
import { join } from 'node:path'
|
||||
|
||||
export const PROTOKOLL_TAGE = 14
|
||||
|
||||
export function protokollDateiname(datum: Date): string {
|
||||
const j = datum.getFullYear()
|
||||
const m = String(datum.getMonth() + 1).padStart(2, '0')
|
||||
const t = String(datum.getDate()).padStart(2, '0')
|
||||
return `rippy-${j}-${m}-${t}.log`
|
||||
}
|
||||
|
||||
/** Zeitstempel lokal, sekundengenau — so, wie der Commander die Uhr liest. */
|
||||
export function zeitstempel(datum: Date): string {
|
||||
const z = (n: number): string => String(n).padStart(2, '0')
|
||||
return `${datum.getFullYear()}-${z(datum.getMonth() + 1)}-${z(datum.getDate())} ${z(datum.getHours())}:${z(datum.getMinutes())}:${z(datum.getSeconds())}`
|
||||
}
|
||||
|
||||
/** Welche Dateien älter als `tage` sind (pur, über den Dateinamen). */
|
||||
export function veraltet(namen: readonly string[], jetzt: Date, tage = PROTOKOLL_TAGE): string[] {
|
||||
const grenze = jetzt.getTime() - tage * 24 * 60 * 60 * 1000
|
||||
return namen.filter((n) => {
|
||||
const treffer = /^rippy-(\d{4})-(\d{2})-(\d{2})\.log$/.exec(n)
|
||||
if (treffer === null) return false
|
||||
const datum = new Date(Number(treffer[1]), Number(treffer[2]) - 1, Number(treffer[3]))
|
||||
return datum.getTime() < grenze
|
||||
})
|
||||
}
|
||||
|
||||
export class Protokoll {
|
||||
private fehlschlaege = 0
|
||||
|
||||
constructor(
|
||||
readonly ordner: string,
|
||||
private readonly quelle: string,
|
||||
private readonly jetzt: () => Date = () => new Date(),
|
||||
) {}
|
||||
|
||||
/** Eine Zeile anhängen: „2026-09-02 21:13:05 [kern] Text". */
|
||||
schreiben(text: string): void {
|
||||
try {
|
||||
if (!existsSync(this.ordner)) mkdirSync(this.ordner, { recursive: true })
|
||||
const datum = this.jetzt()
|
||||
const nachtrag = this.fehlschlaege > 0 ? ` (davor ${this.fehlschlaege} Zeilen nicht schreibbar)` : ''
|
||||
this.fehlschlaege = 0
|
||||
appendFileSync(join(this.ordner, protokollDateiname(datum)), `${zeitstempel(datum)} [${this.quelle}] ${text}${nachtrag}\n`)
|
||||
} catch {
|
||||
this.fehlschlaege += 1
|
||||
}
|
||||
}
|
||||
|
||||
/** Dateien älter als PROTOKOLL_TAGE entfernen — beim Start. */
|
||||
aufraeumen(): number {
|
||||
let weg = 0
|
||||
try {
|
||||
if (!existsSync(this.ordner)) return 0
|
||||
for (const name of veraltet(readdirSync(this.ordner), this.jetzt())) {
|
||||
try {
|
||||
const pfad = join(this.ordner, name)
|
||||
if (statSync(pfad).isFile()) {
|
||||
unlinkSync(pfad)
|
||||
weg += 1
|
||||
}
|
||||
} catch {
|
||||
// Eine gesperrte Datei bleibt bis zum nächsten Start liegen.
|
||||
}
|
||||
}
|
||||
} catch {
|
||||
// Nicht lesbar: nichts zu tun, nichts zu melden — das Protokoll ist
|
||||
// Komfort.
|
||||
}
|
||||
return weg
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
// Sprachen für die Auswahl-Felder (5.5.0, Commander: „bei Tonspuren und
|
||||
// Untertiteln können Dropdowns hin") — ISO-639-2-Codes, wie MakeMKV
|
||||
// (SINFO-Attribut 3) und HandBrake (--audio-lang-list) sie sprechen, mit
|
||||
// deutschen Namen. Die REIHENFOLGE der Wahl ist die Wunschreihenfolge: die
|
||||
// erste Tonsprache ist die, deren Fehlen die Untertitel vorwählt
|
||||
// (kern/ablauf/auftrag.ts sprachwahl).
|
||||
export interface Sprache {
|
||||
code: string
|
||||
name: string
|
||||
}
|
||||
|
||||
export const SPRACHEN: readonly Sprache[] = [
|
||||
{ code: 'deu', name: 'Deutsch' },
|
||||
{ code: 'eng', name: 'Englisch' },
|
||||
{ code: 'jpn', name: 'Japanisch' },
|
||||
{ code: 'fra', name: 'Französisch' },
|
||||
{ code: 'ita', name: 'Italienisch' },
|
||||
{ code: 'spa', name: 'Spanisch' },
|
||||
{ code: 'por', name: 'Portugiesisch' },
|
||||
{ code: 'nld', name: 'Niederländisch' },
|
||||
{ code: 'pol', name: 'Polnisch' },
|
||||
{ code: 'tur', name: 'Türkisch' },
|
||||
{ code: 'rus', name: 'Russisch' },
|
||||
{ code: 'kor', name: 'Koreanisch' },
|
||||
{ code: 'zho', name: 'Chinesisch' },
|
||||
{ code: 'swe', name: 'Schwedisch' },
|
||||
{ code: 'dan', name: 'Dänisch' },
|
||||
{ code: 'nor', name: 'Norwegisch' },
|
||||
{ code: 'fin', name: 'Finnisch' },
|
||||
{ code: 'ces', name: 'Tschechisch' },
|
||||
{ code: 'hun', name: 'Ungarisch' },
|
||||
{ code: 'ell', name: 'Griechisch' },
|
||||
{ code: 'heb', name: 'Hebräisch' },
|
||||
{ code: 'ara', name: 'Arabisch' },
|
||||
{ code: 'hin', name: 'Hindi' },
|
||||
{ code: 'tha', name: 'Thai' },
|
||||
]
|
||||
|
||||
/** „deu, eng , ,DEU" → ['deu','eng'] — dieselbe Regel wie im Kern (presets.ts). */
|
||||
export function sprachlisteAus(wert: string): string[] {
|
||||
const sauber: string[] = []
|
||||
for (const teil of wert.split(',')) {
|
||||
const code = teil.trim().toLowerCase()
|
||||
if (code.length > 0 && !sauber.includes(code)) sauber.push(code)
|
||||
}
|
||||
return sauber
|
||||
}
|
||||
|
||||
export function sprachName(code: string): string {
|
||||
return SPRACHEN.find((s) => s.code === code)?.name ?? code
|
||||
}
|
||||
|
||||
/** Die Liste als Einstellung zurück: „deu,eng". */
|
||||
export function sprachlisteText(codes: readonly string[]): string {
|
||||
return codes.join(',')
|
||||
}
|
||||
@@ -1,17 +1,29 @@
|
||||
// Fenster anlegen (KONZEPT § 4.2). Das Fenster zeigt an, sonst nichts —
|
||||
// kein Node-Zugriff, contextIsolation an, alles läuft über die Brücke
|
||||
// (src/bruecke) und den MessagePort zum Kern.
|
||||
// „Zustand merken" (Position/Größe) kommt mit den Einstellungen im UI (W-5).
|
||||
import { BrowserWindow } from 'electron'
|
||||
//
|
||||
// 5.5.0: Die Größe hängt am Bildschirm (fensterlage.ts) — 80 % des
|
||||
// Arbeitsbereichs beim ersten Start, danach die zuletzt gemerkte Lage,
|
||||
// sofern sie noch auf einem Bildschirm liegt.
|
||||
import { BrowserWindow, screen } from 'electron'
|
||||
import { join } from 'node:path'
|
||||
import { fensterrandEntfernen } from './fensterrand'
|
||||
import { anfangsLage, lageLesen, lageSchreiben, MINDEST_BREITE, MINDEST_HOEHE, type Lage } from './fensterlage'
|
||||
|
||||
export function fensterErstellen(): BrowserWindow {
|
||||
export function fensterErstellen(profilOrdner: string): BrowserWindow {
|
||||
const lageDatei = join(profilOrdner, 'fenster-lage.json')
|
||||
const lage = anfangsLage(
|
||||
lageLesen(lageDatei),
|
||||
screen.getPrimaryDisplay().workArea,
|
||||
screen.getAllDisplays().map((d) => d.workArea),
|
||||
)
|
||||
const fenster = new BrowserWindow({
|
||||
width: 1280,
|
||||
height: 820,
|
||||
minWidth: 860,
|
||||
minHeight: 560,
|
||||
x: lage.x,
|
||||
y: lage.y,
|
||||
width: lage.width,
|
||||
height: lage.height,
|
||||
minWidth: Math.min(MINDEST_BREITE, 860),
|
||||
minHeight: Math.min(MINDEST_HOEHE, 560),
|
||||
show: true,
|
||||
autoHideMenuBar: true,
|
||||
// Eigene Titelleiste (Commander-Wunsch 01.09.2026): Der Windows-Rahmen
|
||||
@@ -35,17 +47,37 @@ export function fensterErstellen(): BrowserWindow {
|
||||
sandbox: true,
|
||||
},
|
||||
})
|
||||
if (lage.maximiert) fenster.maximize()
|
||||
|
||||
// Lage merken — verzögert, damit ein Ziehen nicht hundertmal schreibt.
|
||||
let zeiger: NodeJS.Timeout | null = null
|
||||
const merken = (): void => {
|
||||
if (zeiger !== null) clearTimeout(zeiger)
|
||||
zeiger = setTimeout(() => {
|
||||
if (fenster.isDestroyed()) return
|
||||
const maximiert = fenster.isMaximized()
|
||||
// Im maximierten Zustand die NORMALE Lage behalten (getNormalBounds),
|
||||
// sonst würde beim nächsten Start ein riesiges Fenster entmaximiert.
|
||||
const b = maximiert ? fenster.getNormalBounds() : fenster.getBounds()
|
||||
const neu: Lage = { x: b.x, y: b.y, width: b.width, height: b.height, maximiert }
|
||||
lageSchreiben(lageDatei, neu)
|
||||
}, 400)
|
||||
}
|
||||
fenster.on('resize', merken)
|
||||
fenster.on('move', merken)
|
||||
fenster.on('maximize', merken)
|
||||
fenster.on('unmaximize', merken)
|
||||
|
||||
// electron-vite: Im dev-Modus bedient ein Vite-Server das Fenster
|
||||
// (ELECTRON_RENDERER_URL), gebaut wird aus out/fenster geladen.
|
||||
// RIPPY_START_BEREICH öffnet einen bestimmten Bereich (#einstellungen /
|
||||
// #bibliothek) — der Smoke-Beweis fotografiert damit auch diese Seiten.
|
||||
// Der DWM-Rand von Windows 11 (die feine helle Linie ums Fenster) — er
|
||||
// gehört nicht zum Fensterinhalt, mit CSS ist er nicht zu erreichen.
|
||||
// Ein Fehlschlag ist kein Ausfall: Unter Windows 10 gibt es ihn nicht.
|
||||
const rand = fensterrandEntfernen(fenster.getNativeWindowHandle())
|
||||
if (!rand.ok) console.warn(`[haupt] Fensterrand bleibt: ${rand.fehler}`)
|
||||
|
||||
// electron-vite: Im dev-Modus bedient ein Vite-Server das Fenster
|
||||
// (ELECTRON_RENDERER_URL), gebaut wird aus out/fenster geladen.
|
||||
// RIPPY_START_BEREICH öffnet einen bestimmten Bereich (#einstellungen /
|
||||
// #einrichtung) — der Smoke-Beweis fotografiert damit auch diese Seiten.
|
||||
const devUrl = process.env['ELECTRON_RENDERER_URL']
|
||||
const startBereich = process.env['RIPPY_START_BEREICH'] ?? ''
|
||||
if (devUrl !== undefined && devUrl.length > 0) {
|
||||
|
||||
@@ -0,0 +1,85 @@
|
||||
// Die Fensterlage (5.5.0, Commander: „Das Programm sollte immer in einer
|
||||
// angenehmen Größe öffnen, abhängig von der Auflösung des Monitors") —
|
||||
// PUR, damit die Ampel die Rechnung prüft:
|
||||
// * Ohne gemerkte Lage: 80 % des nutzbaren Bildschirms (Arbeitsbereich
|
||||
// ohne Taskleiste), mittig, mindestens 1100 × 720, nie größer als der
|
||||
// Bildschirm.
|
||||
// * Mit gemerkter Lage: wiederherstellen — aber nur, wenn sie auf einem
|
||||
// heutigen Bildschirm liegt (ein abgestöpselter Zweitmonitor darf das
|
||||
// Fenster nicht ins Nirgendwo schieben).
|
||||
// Gemerkt wird in <Profil>\fenster-lage.json — keine Nutzer-Einstellung,
|
||||
// sondern Geometrie; die EINE Einstellungs-Quelle (§ 6.7) bleibt der Kern.
|
||||
import { existsSync, readFileSync, writeFileSync } from 'node:fs'
|
||||
|
||||
export interface Lage {
|
||||
x: number
|
||||
y: number
|
||||
width: number
|
||||
height: number
|
||||
maximiert: boolean
|
||||
}
|
||||
|
||||
export interface Bereich {
|
||||
x: number
|
||||
y: number
|
||||
width: number
|
||||
height: number
|
||||
}
|
||||
|
||||
export const MINDEST_BREITE = 1100
|
||||
export const MINDEST_HOEHE = 720
|
||||
export const ANTEIL = 0.8
|
||||
|
||||
/** Die Startlage aus dem Arbeitsbereich des Hauptbildschirms (pur). */
|
||||
export function startLage(arbeitsbereich: Bereich): Lage {
|
||||
const width = Math.max(Math.min(arbeitsbereich.width, MINDEST_BREITE), Math.round(arbeitsbereich.width * ANTEIL))
|
||||
const height = Math.max(Math.min(arbeitsbereich.height, MINDEST_HOEHE), Math.round(arbeitsbereich.height * ANTEIL))
|
||||
return {
|
||||
x: arbeitsbereich.x + Math.round((arbeitsbereich.width - width) / 2),
|
||||
y: arbeitsbereich.y + Math.round((arbeitsbereich.height - height) / 2),
|
||||
width: Math.min(width, arbeitsbereich.width),
|
||||
height: Math.min(height, arbeitsbereich.height),
|
||||
maximiert: false,
|
||||
}
|
||||
}
|
||||
|
||||
/** Liegt die gemerkte Lage sichtbar auf einem der Bildschirme? (pur) */
|
||||
export function liegtSichtbar(lage: Lage, bildschirme: readonly Bereich[]): boolean {
|
||||
if (lage.width < 400 || lage.height < 300) return false
|
||||
return bildschirme.some((b) => {
|
||||
const rechts = Math.min(lage.x + lage.width, b.x + b.width)
|
||||
const links = Math.max(lage.x, b.x)
|
||||
const unten = Math.min(lage.y + lage.height, b.y + b.height)
|
||||
const oben = Math.max(lage.y, b.y)
|
||||
// Mindestens 200 × 100 sichtbar — genug, um das Fenster anzufassen.
|
||||
return rechts - links >= 200 && unten - oben >= 100
|
||||
})
|
||||
}
|
||||
|
||||
/** Gemerkt oder Start — was das Fenster beim Öffnen bekommt (pur). */
|
||||
export function anfangsLage(gemerkt: Lage | null, arbeitsbereich: Bereich, bildschirme: readonly Bereich[]): Lage {
|
||||
if (gemerkt !== null && liegtSichtbar(gemerkt, bildschirme)) return gemerkt
|
||||
return startLage(arbeitsbereich)
|
||||
}
|
||||
|
||||
export function lageLesen(pfad: string): Lage | null {
|
||||
try {
|
||||
if (!existsSync(pfad)) return null
|
||||
const roh: unknown = JSON.parse(readFileSync(pfad, 'utf8'))
|
||||
if (typeof roh !== 'object' || roh === null) return null
|
||||
const l = roh as Record<string, unknown>
|
||||
if ([l.x, l.y, l.width, l.height].some((v) => typeof v !== 'number' || !Number.isFinite(v))) return null
|
||||
return { x: l.x as number, y: l.y as number, width: l.width as number, height: l.height as number, maximiert: l.maximiert === true }
|
||||
} catch {
|
||||
// Eine kaputte Datei heißt: Startlage. Sie wird beim nächsten Speichern ersetzt.
|
||||
return null
|
||||
}
|
||||
}
|
||||
|
||||
export function lageSchreiben(pfad: string, lage: Lage): void {
|
||||
try {
|
||||
writeFileSync(pfad, JSON.stringify(lage))
|
||||
} catch {
|
||||
// Nicht schreibbar: Das Fenster öffnet beim nächsten Mal in der Startlage — kein Grund für Lärm.
|
||||
}
|
||||
}
|
||||
@@ -13,6 +13,7 @@ import { writeFile } from 'node:fs/promises'
|
||||
import { join, win32 } from 'node:path'
|
||||
import type { HauptStatus, KernNachricht } from '../gemeinsam/nachrichten'
|
||||
import { werkzeugOrdner } from '../kern/werkzeuge/katalog'
|
||||
import { Protokoll } from '../gemeinsam/protokoll'
|
||||
import { autostartAktiv, autostartSetzen } from './autostart'
|
||||
import { fensterErstellen } from './fenster'
|
||||
import { KernVerwaltung } from './kernstart'
|
||||
@@ -47,12 +48,19 @@ if (!app.requestSingleInstanceLock()) {
|
||||
}
|
||||
|
||||
function start(): void {
|
||||
// 5.5.0: Die Protokoll-Datei (aus ARM) — Haupt und Kern schreiben in
|
||||
// denselben Ordner, eine Datei je Tag, 14 Tage aufgehoben.
|
||||
const protokollOrdner = join(app.getPath('userData'), 'logs')
|
||||
const protokoll = new Protokoll(protokollOrdner, 'haupt')
|
||||
protokoll.aufraeumen()
|
||||
protokoll.schreiben(`Rippy ${app.getVersion()} startet (Electron ${process.versions.electron}, Profil ${app.getPath('userData')})`)
|
||||
// Die Leine kommt VOR dem ersten Kindprozess — Mitgliedschaft in der
|
||||
// Arbeitsgruppe wird nur beim Start eines Kindes vererbt (§ 3.3).
|
||||
const leine: LeineStatus = leineSetzen()
|
||||
if (!leine.ok) {
|
||||
// R4: laut, nicht still — zusätzlich steht es im Fenster-Status.
|
||||
console.error(`[haupt] Prozess-Leine NICHT gesetzt: ${leine.fehler}`)
|
||||
protokoll.schreiben(`Prozess-Leine NICHT gesetzt: ${leine.fehler}`)
|
||||
}
|
||||
|
||||
let fenster: BrowserWindow | null = null
|
||||
@@ -80,6 +88,7 @@ function start(): void {
|
||||
smoke.datenbank = nachricht.datenbank.ok
|
||||
if (!nachricht.datenbank.ok) {
|
||||
console.error(`[haupt] Kern meldet Datenbank-Fehler: ${nachricht.datenbank.fehler}`)
|
||||
protokoll.schreiben(`Kern meldet Datenbank-Fehler: ${nachricht.datenbank.fehler}`)
|
||||
}
|
||||
statusSenden()
|
||||
smokePruefen()
|
||||
@@ -93,7 +102,10 @@ function start(): void {
|
||||
updateEinrichten(
|
||||
nachricht.werte['updateUrl'] ?? '',
|
||||
() => aktiveVorgaenge.size > 0,
|
||||
(text) => toast('Rippy-Update', text),
|
||||
(text) => {
|
||||
protokoll.schreiben(`Update: ${text}`)
|
||||
toast('Rippy-Update', text)
|
||||
},
|
||||
// Jede Änderung am Update-Stand geht SOFORT ans Fenster —
|
||||
// vorher lag sie still im Haupt und war erst beim nächsten
|
||||
// Laden zu sehen (Commander-Fund 01.09.2026).
|
||||
@@ -122,7 +134,10 @@ function start(): void {
|
||||
)
|
||||
}
|
||||
},
|
||||
() => statusSenden(),
|
||||
(zustand) => {
|
||||
if (!zustand.laeuft) protokoll.schreiben(`Kern nicht aktiv (Neustarts: ${zustand.neustarts})`)
|
||||
statusSenden()
|
||||
},
|
||||
smokeModus,
|
||||
)
|
||||
|
||||
@@ -222,6 +237,7 @@ function start(): void {
|
||||
// Für die eigene Titelleiste: Das Knopf-Symbol muss wissen, ob das
|
||||
// Fenster gerade maximiert ist.
|
||||
fensterMaximiert: fenster !== null && !fenster.isDestroyed() && fenster.isMaximized(),
|
||||
protokollOrdner,
|
||||
}
|
||||
fenster.webContents.send('haupt-status', status)
|
||||
}
|
||||
@@ -250,7 +266,7 @@ function start(): void {
|
||||
|
||||
function fensterZeigen(): void {
|
||||
if (fenster === null || fenster.isDestroyed()) {
|
||||
fenster = fensterErstellen()
|
||||
fenster = fensterErstellen(app.getPath('userData'))
|
||||
fensterVerdrahten()
|
||||
return
|
||||
}
|
||||
@@ -327,6 +343,33 @@ function start(): void {
|
||||
return ergebnis.canceled || ergebnis.filePaths.length === 0 ? null : ergebnis.filePaths[0]
|
||||
})
|
||||
|
||||
// Echter Windows-Dateidialog (5.5.0: Werkzeuge → Durchsuchen) — nur
|
||||
// Programme, sonst nichts.
|
||||
ipcMain.handle('datei-waehlen', async (_ereignis, titel: unknown) => {
|
||||
if (fenster === null) return null
|
||||
const ergebnis = await dialog.showOpenDialog(fenster, {
|
||||
title: typeof titel === 'string' && titel.length > 0 ? titel : 'Programm wählen',
|
||||
properties: ['openFile'],
|
||||
filters: [
|
||||
{ name: 'Programme', extensions: ['exe'] },
|
||||
{ name: 'Alle Dateien', extensions: ['*'] },
|
||||
],
|
||||
})
|
||||
return ergebnis.canceled || ergebnis.filePaths.length === 0 ? null : ergebnis.filePaths[0]
|
||||
})
|
||||
|
||||
// Einen Ordner im Explorer zeigen (5.5.0, aus ARM) — nur absolute Pfade,
|
||||
// und shell.openPath sagt selbst, wenn es ihn nicht gibt.
|
||||
ipcMain.handle('ordner-oeffnen', async (_ereignis, pfad: unknown) => {
|
||||
if (typeof pfad !== 'string' || !win32.isAbsolute(pfad)) return 'Kein gültiger Pfad.'
|
||||
protokoll.schreiben(`Ordner geöffnet: ${pfad}`)
|
||||
return await shell.openPath(pfad)
|
||||
})
|
||||
|
||||
ipcMain.handle('protokoll-oeffnen', async () => {
|
||||
return await shell.openPath(protokollOrdner)
|
||||
})
|
||||
|
||||
app.on('second-instance', () => {
|
||||
fensterZeigen()
|
||||
})
|
||||
@@ -339,6 +382,7 @@ function start(): void {
|
||||
|
||||
app.on('before-quit', () => {
|
||||
beendenGewollt = true
|
||||
protokoll.schreiben('Rippy beendet sich')
|
||||
kernVerwaltung.beenden()
|
||||
})
|
||||
|
||||
@@ -347,7 +391,7 @@ function start(): void {
|
||||
if (!ohneNebenwirkungen) {
|
||||
trayErstellen(fensterZeigen, beenden)
|
||||
}
|
||||
fenster = fensterErstellen()
|
||||
fenster = fensterErstellen(app.getPath('userData'))
|
||||
fensterVerdrahten()
|
||||
})
|
||||
|
||||
|
||||
@@ -17,12 +17,16 @@
|
||||
// * Folgen von Hand („Staffel 1, ab Folge 3") schlagen die Laufzeit-Raterei;
|
||||
// TMDb gibt dann nur noch eine Warnung.
|
||||
// * Durchgehender Fortschritt, nach Dateigröße gewichtet.
|
||||
// * 5.5.0 Arbeitsordner: Liegt die Ablage auf dem Server, rechnet HandBrake
|
||||
// LOKAL (Arbeitsordner\fertig\<Vorgang>) und erst das Ergebnis wandert
|
||||
// über das Netz — kein Encode gegen eine SMB-Freigabe.
|
||||
import {
|
||||
copyFileSync,
|
||||
existsSync,
|
||||
mkdirSync,
|
||||
readdirSync,
|
||||
renameSync,
|
||||
rmSync,
|
||||
statSync,
|
||||
unlinkSync,
|
||||
writeFileSync,
|
||||
@@ -50,6 +54,9 @@ export interface AblageUmgebung {
|
||||
handbrake: () => string
|
||||
/** Wurzel der Ablage. */
|
||||
ablage: () => string
|
||||
/** 5.5.0: eigener lokaler Arbeitsordner — '' wenn keiner (dann wird
|
||||
* direkt in die Ablage gerechnet, wie bisher). */
|
||||
arbeitsordner?: () => string
|
||||
einstellungen: () => Einstellungen
|
||||
/** Gemessene Preset-Empfehlung (Hardware zuerst) für diesen Disc-Typ. */
|
||||
presetEmpfehlung?: (discTyp: string) => string
|
||||
@@ -60,7 +67,7 @@ export interface AblageUmgebung {
|
||||
) => Promise<ReadonlyArray<readonly [number, number]>>
|
||||
bibliothekEintragen?: (eintrag: BibliothekEintrag) => void
|
||||
jetzt?: () => Date
|
||||
/** Roh-Datei ins Ziel verschieben — injizierbar für Tests. */
|
||||
/** Datei verschieben — injizierbar für Tests. */
|
||||
verschieben?: (von: string, nach: string) => void
|
||||
/** Spuren der Roh-Datei messen — injizierbar (Standard: HandBrake-Scan). */
|
||||
spurenScannen?: (programm: string, datei: string) => Promise<HbSpuren | null>
|
||||
@@ -75,6 +82,9 @@ export interface AblageErgebnis {
|
||||
preset: string
|
||||
fertigBytes: number
|
||||
hinweise: string[]
|
||||
/** 5.5.0: Welche Folgen-Nummern vergeben wurden (leer bei Filmen oder ohne
|
||||
* Zuordnung) — der Serien-Merker zählt daran weiter. */
|
||||
folgenVergeben: number[]
|
||||
}
|
||||
|
||||
export type AblageMeldung = (stand: Pick<KompressionStand, 'phase' | 'prozent' | 'text'>) => void
|
||||
@@ -119,6 +129,17 @@ export async function komprimierenUndAblegen(
|
||||
const zuordnung = auftrag.zuordnung
|
||||
const hinweise: string[] = [...auftrag.hinweise]
|
||||
const dateien = [...auftrag.dateien].sort((a, b) => a.pfad.localeCompare(b.pfad))
|
||||
const fehlschlag = (text: string, statusPreset: string, ist: boolean): AblageErgebnis => ({
|
||||
status: 'fehler',
|
||||
zielOrdner: fertigOrdner,
|
||||
dateien: [],
|
||||
text,
|
||||
komprimiert: ist,
|
||||
preset: statusPreset,
|
||||
fertigBytes: 0,
|
||||
hinweise,
|
||||
folgenVergeben: [],
|
||||
})
|
||||
|
||||
// ── WOHIN? (§ 4.2) ──────────────────────────────────────────────────
|
||||
// Serien gehören NICHT unter Filme/ — sonst sieht Jellyfin lauter
|
||||
@@ -135,7 +156,11 @@ export async function komprimierenUndAblegen(
|
||||
: zuordnung !== null && zuordnung.titel.length > 0
|
||||
? zielordner(join(umgebung.ablage(), 'Filme'), zuordnung.titel, zuordnung.jahr, auftrag.vorgangId)
|
||||
: zielordner(join(umgebung.ablage(), 'Filme'), auftrag.vorgangId, null, auftrag.vorgangId)
|
||||
mkdirSync(fertigOrdner, { recursive: true })
|
||||
try {
|
||||
mkdirSync(fertigOrdner, { recursive: true })
|
||||
} catch (fehler) {
|
||||
return fehlschlag(`Zielordner nicht anlegbar (${fertigOrdner}): ${String(fehler)} — ist die Ablage erreichbar?`, '', komprimiert)
|
||||
}
|
||||
|
||||
// Extras liegen im Unterordner „extras" NEBEN dem Hauptfilm — so lesen
|
||||
// Jellyfin, Emby und Kodi sie als Zugaben und nicht als zweiten Film.
|
||||
@@ -143,6 +168,12 @@ export async function komprimierenUndAblegen(
|
||||
const zielFuer = (rolle: string): string => (rolle === 'extra' ? extrasOrdner : fertigOrdner)
|
||||
if (dateien.some((d) => d.rolle === 'extra')) mkdirSync(extrasOrdner, { recursive: true })
|
||||
|
||||
// 5.5.0: Eigener Arbeitsordner → HandBrake schreibt LOKAL, danach wird
|
||||
// verschoben. Ohne ihn wie bisher direkt ins Ziel.
|
||||
const arbeit = (umgebung.arbeitsordner?.() ?? '').trim()
|
||||
const zwischen = komprimiert && arbeit.length > 0 ? join(arbeit, 'fertig', auftrag.vorgangId) : ''
|
||||
if (zwischen.length > 0) mkdirSync(zwischen, { recursive: true })
|
||||
|
||||
const global = {
|
||||
audio: sprachliste(String(einstellungen['audioSprachen'] ?? '')),
|
||||
untertitel: sprachliste(String(einstellungen['untertitelSprachen'] ?? '')),
|
||||
@@ -152,15 +183,15 @@ export async function komprimierenUndAblegen(
|
||||
const verschieben = umgebung.verschieben ?? dateiVerschieben
|
||||
|
||||
const fertigeDateien: string[] = []
|
||||
/** Lokal gerechnet, noch nicht im Ziel: [von, nach]. */
|
||||
const nachzuziehen: Array<[string, string]> = []
|
||||
// Laufzeiten der FOLGEN in Ablage-Reihenfolge — Grundlage der
|
||||
// Episoden-Zuordnung weiter unten.
|
||||
const folgenSekunden: number[] = []
|
||||
for (let i = 0; i < dateien.length; i++) {
|
||||
const datei = dateien[i]
|
||||
const ausgabe = join(zielFuer(datei.rolle), basename(datei.pfad))
|
||||
if (abbruch.aborted) {
|
||||
return abgebrochen(fertigOrdner, fertigeDateien, preset, komprimiert, hinweise)
|
||||
}
|
||||
const zielDatei = join(zielFuer(datei.rolle), basename(datei.pfad))
|
||||
if (abbruch.aborted) return abgebrochen(fertigOrdner, fertigeDateien, preset, komprimiert, hinweise)
|
||||
if (!komprimiert) {
|
||||
melden({
|
||||
phase: 'legt-ab',
|
||||
@@ -168,20 +199,15 @@ export async function komprimierenUndAblegen(
|
||||
text: `Verschiebe ${i + 1}/${dateien.length}: ${basename(datei.pfad)} (ohne Kompression) …`,
|
||||
})
|
||||
try {
|
||||
verschieben(datei.pfad, ausgabe)
|
||||
verschieben(datei.pfad, zielDatei)
|
||||
} catch (fehler) {
|
||||
return {
|
||||
status: 'fehler',
|
||||
zielOrdner: fertigOrdner,
|
||||
dateien: fertigeDateien,
|
||||
text: `Verschieben fehlgeschlagen: ${String(fehler)} — die Roh-Dateien bleiben stehen (${auftrag.rohOrdner}).`,
|
||||
komprimiert: false,
|
||||
preset: '',
|
||||
fertigBytes: 0,
|
||||
hinweise,
|
||||
}
|
||||
return fehlschlag(
|
||||
`Verschieben fehlgeschlagen: ${String(fehler)} — die Roh-Dateien bleiben stehen (${auftrag.rohOrdner}).`,
|
||||
'',
|
||||
false,
|
||||
)
|
||||
}
|
||||
fertigeDateien.push(ausgabe)
|
||||
fertigeDateien.push(zielDatei)
|
||||
if (datei.rolle === 'folge') folgenSekunden.push(datei.dauerS)
|
||||
continue
|
||||
}
|
||||
@@ -200,15 +226,14 @@ export async function komprimierenUndAblegen(
|
||||
)
|
||||
}
|
||||
if (fehlt.untertitel.length > 0) {
|
||||
hinweise.push(
|
||||
`${basename(datei.pfad)}: Untertitel ${fehlt.untertitel.join(', ')} sind NICHT in der Roh-Datei.`,
|
||||
)
|
||||
hinweise.push(`${basename(datei.pfad)}: Untertitel ${fehlt.untertitel.join(', ')} sind NICHT in der Roh-Datei.`)
|
||||
}
|
||||
} else {
|
||||
hinweise.push(`${basename(datei.pfad)}: Spuren der Roh-Datei ließen sich nicht messen — komprimiert wie gewünscht.`)
|
||||
}
|
||||
}
|
||||
|
||||
const ausgabe = zwischen.length > 0 ? join(zwischen, basename(datei.pfad)) : zielDatei
|
||||
melden({
|
||||
phase: 'komprimiert',
|
||||
prozent: gewichteterFortschritt(gewichte, i, 0),
|
||||
@@ -233,25 +258,44 @@ export async function komprimierenUndAblegen(
|
||||
})
|
||||
},
|
||||
})
|
||||
if (encode.status === 'cancelled') {
|
||||
return abgebrochen(fertigOrdner, fertigeDateien, preset, komprimiert, hinweise)
|
||||
}
|
||||
if (encode.status === 'cancelled') return abgebrochen(fertigOrdner, fertigeDateien, preset, komprimiert, hinweise)
|
||||
if (encode.status === 'error') {
|
||||
return {
|
||||
status: 'fehler',
|
||||
zielOrdner: fertigOrdner,
|
||||
dateien: fertigeDateien,
|
||||
text: `Kompression fehlgeschlagen: ${encode.fehler} — der verlustfreie Rip bleibt stehen (${auftrag.rohOrdner}).`,
|
||||
komprimiert: true,
|
||||
return fehlschlag(
|
||||
`Kompression fehlgeschlagen: ${encode.fehler} — der verlustfreie Rip bleibt stehen (${auftrag.rohOrdner}).`,
|
||||
preset,
|
||||
fertigBytes: 0,
|
||||
hinweise,
|
||||
}
|
||||
true,
|
||||
)
|
||||
}
|
||||
fertigeDateien.push(encode.ausgabe)
|
||||
if (zwischen.length > 0) nachzuziehen.push([encode.ausgabe, zielDatei])
|
||||
fertigeDateien.push(zielDatei)
|
||||
if (datei.rolle === 'folge') folgenSekunden.push(datei.dauerS)
|
||||
}
|
||||
|
||||
// 5.5.0: Lokal Gerechnetes auf die Ablage bringen — erst jetzt, da alle
|
||||
// Encodes gelungen sind. Ein Netzfehler hier kostet keinen Encode: Die
|
||||
// Dateien liegen im Arbeitsordner und der Vorgang sagt, wo.
|
||||
for (let i = 0; i < nachzuziehen.length; i++) {
|
||||
const [von, nach] = nachzuziehen[i]
|
||||
if (abbruch.aborted) return abgebrochen(fertigOrdner, [], preset, komprimiert, hinweise)
|
||||
melden({ phase: 'legt-ab', prozent: 100, text: `Verschiebe auf die Ablage ${i + 1}/${nachzuziehen.length}: ${basename(nach)} …` })
|
||||
try {
|
||||
verschieben(von, nach)
|
||||
} catch (fehler) {
|
||||
return fehlschlag(
|
||||
`Verschieben auf die Ablage fehlgeschlagen: ${String(fehler)} — die fertigen Dateien liegen unter ${zwischen}, die Roh-Dateien unter ${auftrag.rohOrdner}.`,
|
||||
preset,
|
||||
true,
|
||||
)
|
||||
}
|
||||
}
|
||||
if (zwischen.length > 0) {
|
||||
try {
|
||||
rmSync(zwischen, { recursive: true, force: true })
|
||||
} catch {
|
||||
// Ein leerer Zwischenordner, der stehen bleibt, stört nicht.
|
||||
}
|
||||
}
|
||||
|
||||
// ── Wiederholen: die alte Fassung weicht der neuen — JETZT erst, da alle
|
||||
// neuen Dateien da sind. Vorher hätte ein gescheiterter Lauf die
|
||||
// erste Fassung gekostet; danach stünde sie bei Serien der
|
||||
@@ -271,10 +315,10 @@ export async function komprimierenUndAblegen(
|
||||
// Zuordnung; TMDb darf dann nur noch warnen. Ohne Vorgabe wird
|
||||
// umbenannt NUR bei EINDEUTIGER Zuordnung — lieber gar nicht als falsch
|
||||
// (die offene Wunde #395 von ARM war genau dieses Ratespiel).
|
||||
let folgenVergeben: number[] = []
|
||||
if (alsSerie && folgenSekunden.length > 0) {
|
||||
const tmdbId = typeof zuordnung?.meta.id === 'number' ? zuordnung.meta.id : null
|
||||
const laufzeiten =
|
||||
tmdbId !== null ? ((await umgebung.episodenLaufzeiten?.(tmdbId, staffel)) ?? []) : []
|
||||
const laufzeiten = tmdbId !== null ? ((await umgebung.episodenLaufzeiten?.(tmdbId, staffel)) ?? []) : []
|
||||
let episoden: number[] | null = null
|
||||
if (auftrag.ersteFolge !== null && auftrag.ersteFolge > 0) {
|
||||
episoden = folgenNummern(folgenSekunden.length, auftrag.ersteFolge)
|
||||
@@ -285,6 +329,7 @@ export async function komprimierenUndAblegen(
|
||||
}
|
||||
if (episoden !== null) {
|
||||
hinweise.push(...episodenUmbenennen(fertigOrdner, serienTitel, staffel, episoden))
|
||||
folgenVergeben = episoden
|
||||
} else {
|
||||
hinweise.push(
|
||||
laufzeiten.length === 0
|
||||
@@ -368,6 +413,7 @@ export async function komprimierenUndAblegen(
|
||||
preset: komprimiert ? preset : '',
|
||||
fertigBytes,
|
||||
hinweise,
|
||||
folgenVergeben,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -387,6 +433,7 @@ function abgebrochen(
|
||||
preset,
|
||||
fertigBytes: 0,
|
||||
hinweise,
|
||||
folgenVergeben: [],
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -12,6 +12,10 @@
|
||||
// (speicher/db.ts, Tabelle vorgaenge): So weiß Rippy hinterher, welcher
|
||||
// Roh-Ordner zu welchem Film gehört — und kann aufräumen, wiederholen und
|
||||
// nach einem Abbruch nachsehen.
|
||||
//
|
||||
// 5.5.0: das Rettungs-Abbild (rip/rettung.ts) für Discs, an denen Rippy
|
||||
// Lesefehler GESEHEN hat — erst das Abbild mit Nullen, dann derselbe Rip
|
||||
// aus dem Abbild (iso:), das nicht mehr hängen kann.
|
||||
import { mkdirSync, readdirSync, rmSync, statSync, unlinkSync } from 'node:fs'
|
||||
// Plattform-Pfade wie in struktur.ts: Laufzeit-Wurzeln, CI testet auf Linux.
|
||||
import { join } from 'node:path'
|
||||
@@ -29,6 +33,7 @@ import { abfragen, albumOrdner, kennungAusSpuren, tagsJeSpur } from '../metadate
|
||||
import { dateiname, flacBefehl, sauberName, wavKopf, SEKTOR_BYTES, type Spur } from '../rip/audiocd'
|
||||
import { isoSichern } from '../rip/iso'
|
||||
import { rippen } from '../rip/makemkv'
|
||||
import { rettungsAbbildDatei } from '../rip/rettung'
|
||||
import { werkzeugSpawn } from '../werkzeuge/aufruf'
|
||||
import { mkdtempSync, createWriteStream } from 'node:fs'
|
||||
import { tmpdir } from 'node:os'
|
||||
@@ -74,8 +79,10 @@ export interface PipelineUmgebung {
|
||||
) => number
|
||||
/** Aktueller Stand des Laufwerks (für Typ und Vorab-Blick). */
|
||||
geraet: (id: string) => GeraeteInfo | null
|
||||
/** Wurzel der Ablage (Roh-Ordner und fertige Filme liegen darunter). */
|
||||
/** Wurzel der Ablage (fertige Filme, Musik, ISO liegen darunter). */
|
||||
ablage: () => string
|
||||
/** 5.5.0: Wo die Roh-Ordner liegen (Arbeitsordner\roh). Fehlt: Ablage\roh. */
|
||||
rohWurzel?: () => string
|
||||
einstellungen: () => Einstellungen
|
||||
melden: (status: RipStatus) => void
|
||||
/** Die letzte Metadaten-Zuordnung dieses Laufwerks (W-4) — oder null. */
|
||||
@@ -99,10 +106,22 @@ export interface PipelineUmgebung {
|
||||
/** 5.4.0: Nach dem Rip auswerfen (Einstellung autoAuswurf) — die nächste
|
||||
* Disc soll rein, während die Kompression läuft. */
|
||||
nachRipAuswerfen?: (id: string) => void
|
||||
/** 5.5.0: Das Rettungs-Abbild lesen — injizierbar für Tests. */
|
||||
rettungsAbbild?: typeof rettungsAbbildDatei
|
||||
}
|
||||
|
||||
/** Der letzte Auftrag je Laufwerk — die Rettung wiederholt genau ihn. */
|
||||
interface LetzterAuftrag {
|
||||
auftrag: RipAuftragTitel[]
|
||||
optionen: RipAuftragOptionen
|
||||
}
|
||||
|
||||
export class Pipeline {
|
||||
private laufend = new Map<string, LaufenderVorgang>()
|
||||
/** 5.5.0: Rippy hat an diesem Laufwerk Lesefehler GESEHEN — nur dann
|
||||
* wird das Rettungs-Abbild angeboten (Commander: nicht bei heilen Discs). */
|
||||
private fehlerGesehen = new Map<string, string>()
|
||||
private letzterAuftrag = new Map<string, LetzterAuftrag>()
|
||||
|
||||
constructor(private readonly umgebung: PipelineUmgebung) {}
|
||||
|
||||
@@ -110,10 +129,22 @@ export class Pipeline {
|
||||
return this.laufend.has(id)
|
||||
}
|
||||
|
||||
/** Warum eine Rettung angeboten wird — '' wenn keine Fehler gesehen wurden. */
|
||||
rettungGrund(id: string): string {
|
||||
return this.fehlerGesehen.get(id) ?? ''
|
||||
}
|
||||
|
||||
/** Beim Entnehmen der Disc: Was gesehen wurde, gilt nicht mehr. */
|
||||
discEntnommen(id: string): void {
|
||||
this.fehlerGesehen.delete(id)
|
||||
this.letzterAuftrag.delete(id)
|
||||
}
|
||||
|
||||
private melden(status: RipStatus): void {
|
||||
const eintrag = this.laufend.get(status.id)
|
||||
if (eintrag !== undefined) eintrag.status = status
|
||||
this.umgebung.melden(status)
|
||||
const mitRettung: RipStatus = { ...status, rettungMoeglich: this.fehlerGesehen.has(status.id) }
|
||||
if (eintrag !== undefined) eintrag.status = mitRettung
|
||||
this.umgebung.melden(mitRettung)
|
||||
}
|
||||
|
||||
private fehler(id: string, text: string): RipStatus {
|
||||
@@ -131,11 +162,26 @@ export class Pipeline {
|
||||
vorgang.titelAbbruch.abort()
|
||||
}
|
||||
|
||||
/** 5.5.0: Rettungs-Abbild + Rip daraus — mit dem letzten Auftrag dieses
|
||||
* Laufwerks. Nur, wenn Rippy vorher Lesefehler gesehen hat. */
|
||||
async rettungStarten(id: string): Promise<void> {
|
||||
const grund = this.fehlerGesehen.get(id)
|
||||
if (grund === undefined) {
|
||||
this.umgebung.melden(
|
||||
this.fehler(id, 'Rettungs-Abbild nur bei GESEHENEN Lesefehlern — an dieser Disc hat Rippy keine bemerkt. Erst normal rippen.'),
|
||||
)
|
||||
return
|
||||
}
|
||||
const letzter = this.letzterAuftrag.get(id)
|
||||
await this.starten(id, letzter?.auftrag ?? [], letzter?.optionen ?? {}, true)
|
||||
}
|
||||
|
||||
/** Startet die Kette. `auftrag` leer heißt: alles rippen (wie früher). */
|
||||
async starten(
|
||||
id: string,
|
||||
auftrag: readonly RipAuftragTitel[] = [],
|
||||
optionen: RipAuftragOptionen = {},
|
||||
rettung = false,
|
||||
): Promise<void> {
|
||||
if (this.laufend.has(id)) {
|
||||
this.umgebung.melden(this.fehler(id, `Auf Laufwerk ${id}: läuft schon ein Vorgang.`))
|
||||
@@ -190,7 +236,8 @@ export class Pipeline {
|
||||
return
|
||||
}
|
||||
|
||||
const rohOrdner = join(this.umgebung.ablage(), 'roh', vorgangsName)
|
||||
this.letzterAuftrag.set(id, { auftrag: [...auftrag], optionen: { ...optionen } })
|
||||
const rohOrdner = join(this.umgebung.rohWurzel?.() ?? join(this.umgebung.ablage(), 'roh'), vorgangsName)
|
||||
mkdirSync(rohOrdner, { recursive: true })
|
||||
const zuordnung = this.umgebung.zuordnung?.(id) ?? null
|
||||
const anzeigeTitel = zuordnung !== null && zuordnung.titel.length > 0 ? zuordnung.titel : vorgangsName
|
||||
@@ -204,25 +251,9 @@ export class Pipeline {
|
||||
begonnen: startZeit.toISOString(),
|
||||
})
|
||||
|
||||
// TITEL FÜR TITEL statt einem 'all'-Aufruf (Commander-Wunsch
|
||||
// 01.09.2026). Zwei Gründe, und beide brauchen denselben Umbau:
|
||||
// * Auswählen geht nur so — vorher rippte Rippy IMMER alles, samt
|
||||
// Trailer, Werbung und Alterskennzeichen.
|
||||
// * Ein Titel, der an einem Disc-Defekt hängen bleibt, reißt nicht
|
||||
// mehr den ganzen Auftrag mit. Bei der Spartacus-Disc lag der
|
||||
// Defekt in Folge 1 — Folge 2 war heil und ging trotzdem verloren.
|
||||
const laeufe = auftrag.length > 0 ? auftrag.map((a) => String(a.nr)) : ['all']
|
||||
// Durchgehender Balken (5.4.0): nach der Größe der Titel gewichtet —
|
||||
// vorher sprang er je Titel zurück auf null.
|
||||
const gewichte = auftrag.length > 0 ? auftrag.map((a) => a.groesseBytes ?? 0) : [1]
|
||||
// Welche Rolle bekam welche Datei? Die Zuordnung ist EXAKT, weil je
|
||||
// Lauf genau ein Titel dazukommt — nicht aus Dateinamen geraten.
|
||||
const auftragJeDatei = new Map<string, RipAuftragTitel | undefined>()
|
||||
const alleDateien = new Set<string>()
|
||||
let lesefehlerGesamt = false
|
||||
const gescheitert: string[] = []
|
||||
const uebersprungen: string[] = []
|
||||
const aufgeraeumt: string[] = []
|
||||
const hinweise: string[] = []
|
||||
|
||||
this.laufend.set(id, {
|
||||
abbruch,
|
||||
@@ -252,6 +283,81 @@ export class Pipeline {
|
||||
})
|
||||
}
|
||||
|
||||
// ── 5.5.0: Rettungs-Abbild — die Quelle des Rips wird die ISO ────────
|
||||
let quellePfad = geraet.pfad
|
||||
if (rettung) {
|
||||
const isoPfad = join(rohOrdner, 'rettung.iso')
|
||||
this.melden({
|
||||
id,
|
||||
phase: 'rettet',
|
||||
prozent: 0,
|
||||
text: `Rettungs-Abbild: lese die Disc Sektor für Sektor nach ${isoPfad} — Unlesbares wird mit Nullen gefüllt …`,
|
||||
dateien: [],
|
||||
lesefehler: false,
|
||||
vorgangId: vorgangsName,
|
||||
rettung: { unlesbareSektoren: 0, stellen: 0 },
|
||||
})
|
||||
const lesen = this.umgebung.rettungsAbbild ?? rettungsAbbildDatei
|
||||
const ergebnis = await lesen(
|
||||
geraet.pfad,
|
||||
isoPfad,
|
||||
geraet.groesseBytes,
|
||||
(prozent, unlesbar, stellen) => {
|
||||
const alt = this.laufend.get(id)?.status
|
||||
if (alt !== undefined) {
|
||||
this.melden({
|
||||
...alt,
|
||||
phase: 'rettet',
|
||||
prozent,
|
||||
text: `Rettungs-Abbild: ${prozent} % — ${unlesbar} unlesbare Sektoren an ${stellen} Stellen (mit Nullen gefüllt)`,
|
||||
rettung: { unlesbareSektoren: unlesbar, stellen },
|
||||
})
|
||||
}
|
||||
},
|
||||
abbruch.signal,
|
||||
)
|
||||
if (ergebnis.status === 'cancelled') {
|
||||
beenden('abgebrochen', 'Rettungs-Abbild abgebrochen.')
|
||||
return
|
||||
}
|
||||
if (ergebnis.status === 'error') {
|
||||
beenden('fehler', `Rettungs-Abbild gescheitert: ${ergebnis.fehler}`)
|
||||
return
|
||||
}
|
||||
hinweise.push(
|
||||
`Rettungs-Abbild: ${ergebnis.unlesbareSektoren} unlesbare Sektoren an ${ergebnis.stellen.length} Stellen mit Nullen gefüllt (Bericht: rettung.iso.rettung.txt).`,
|
||||
)
|
||||
quellePfad = isoPfad
|
||||
this.melden({
|
||||
id,
|
||||
phase: 'rippt',
|
||||
prozent: -1,
|
||||
text: `Rettungs-Abbild fertig (${ergebnis.unlesbareSektoren} Sektoren genullt) — rippe jetzt aus dem Abbild …`,
|
||||
dateien: [],
|
||||
lesefehler: false,
|
||||
vorgangId: vorgangsName,
|
||||
rettung: { unlesbareSektoren: ergebnis.unlesbareSektoren, stellen: ergebnis.stellen.length },
|
||||
})
|
||||
}
|
||||
|
||||
// TITEL FÜR TITEL statt einem 'all'-Aufruf (Commander-Wunsch
|
||||
// 01.09.2026). Zwei Gründe, und beide brauchen denselben Umbau:
|
||||
// * Auswählen geht nur so — vorher rippte Rippy IMMER alles, samt
|
||||
// Trailer, Werbung und Alterskennzeichen.
|
||||
// * Ein Titel, der an einem Disc-Defekt hängen bleibt, reißt nicht
|
||||
// mehr den ganzen Auftrag mit. Bei der Spartacus-Disc lag der
|
||||
// Defekt in Folge 1 — Folge 2 war heil und ging trotzdem verloren.
|
||||
const laeufe = auftrag.length > 0 ? auftrag.map((a) => String(a.nr)) : ['all']
|
||||
// Durchgehender Balken (5.4.0): nach der Größe der Titel gewichtet —
|
||||
// vorher sprang er je Titel zurück auf null.
|
||||
const gewichte = auftrag.length > 0 ? auftrag.map((a) => a.groesseBytes ?? 0) : [1]
|
||||
// Welche Rolle bekam welche Datei? Die Zuordnung ist EXAKT, weil je
|
||||
// Lauf genau ein Titel dazukommt — nicht aus Dateinamen geraten.
|
||||
const auftragJeDatei = new Map<string, RipAuftragTitel | undefined>()
|
||||
const gescheitert: string[] = []
|
||||
const uebersprungen: string[] = []
|
||||
const aufgeraeumt: string[] = []
|
||||
|
||||
for (let i = 0; i < laeufe.length; i++) {
|
||||
const welcher = laeufe[i]
|
||||
// Eigener Abbruch je Titel: „überspringen" beendet NUR diesen Lauf,
|
||||
@@ -271,7 +377,7 @@ export class Pipeline {
|
||||
id,
|
||||
phase: 'rippt',
|
||||
prozent: gewichteterFortschritt(gewichte, i, -1),
|
||||
text: `Rippe ${beschriftung} verlustfrei nach ${rohOrdner} …`,
|
||||
text: `Rippe ${beschriftung} verlustfrei nach ${rohOrdner} …${rettung ? ' (aus dem Rettungs-Abbild)' : ''}`,
|
||||
dateien: [...alleDateien],
|
||||
lesefehler: lesefehlerGesamt,
|
||||
titelNr: i + 1,
|
||||
@@ -285,7 +391,7 @@ export class Pipeline {
|
||||
const vorher = dateienIn(rohOrdner)
|
||||
const rip = await rippen({
|
||||
programm,
|
||||
geraetepfad: geraet.pfad,
|
||||
geraetepfad: quellePfad,
|
||||
zielOrdner: rohOrdner,
|
||||
titel: welcher,
|
||||
abbruch: titelAbbruch.signal,
|
||||
@@ -298,6 +404,9 @@ export class Pipeline {
|
||||
if (alt !== undefined) this.melden({ ...alt, text })
|
||||
},
|
||||
aufHaengt: (klemmt) => {
|
||||
// Der Defekt-Wächter hat angeschlagen: Ab jetzt ist die Rettung
|
||||
// eine Option (5.5.0).
|
||||
if (klemmt !== null && !rettung) this.fehlerGesehen.set(id, `Defekt-Wächter: hängt an Byte ${klemmt.offset}`)
|
||||
const alt = this.laufend.get(id)?.status
|
||||
if (alt !== undefined) this.melden({ ...alt, haengt: klemmt })
|
||||
},
|
||||
@@ -305,7 +414,7 @@ export class Pipeline {
|
||||
abbruch.signal.removeEventListener('abort', weiterreichen)
|
||||
|
||||
if (rip.status === 'cancelled') {
|
||||
aufgeraeumt.push(...halbeDateienEntfernen(rohOrdner, vorher))
|
||||
aufgeraeumt.push(...halbeDateienEntfernen(rohOrdner, vorher, rettung ? ['rettung.iso', 'rettung.iso.rettung.txt'] : []))
|
||||
// Nur dieser Titel — oder der ganze Auftrag?
|
||||
if (this.laufend.get(id)?.uebersprungen !== true) {
|
||||
beenden(
|
||||
@@ -321,18 +430,20 @@ export class Pipeline {
|
||||
}
|
||||
|
||||
lesefehlerGesamt = lesefehlerGesamt || rip.lesefehler
|
||||
if (rip.lesefehler && !rettung) this.fehlerGesehen.set(id, 'MakeMKV meldete Lesefehler')
|
||||
if (rip.status === 'error') {
|
||||
// EIN kaputter Titel beendet den Auftrag nicht — die anderen sind
|
||||
// vielleicht heil. Der Grund wird gesammelt und am Ende genannt.
|
||||
// Was dieser Lauf hinterlassen hat, ist nicht vertrauenswürdig.
|
||||
aufgeraeumt.push(...halbeDateienEntfernen(rohOrdner, vorher))
|
||||
if (!rettung) this.fehlerGesehen.set(id, `Titel gescheitert: ${rip.fehler.slice(0, 80)}`)
|
||||
aufgeraeumt.push(...halbeDateienEntfernen(rohOrdner, vorher, rettung ? ['rettung.iso', 'rettung.iso.rettung.txt'] : []))
|
||||
gescheitert.push(`${beschriftung}: ${rip.fehler}`)
|
||||
continue
|
||||
}
|
||||
// rippen() liefert den ganzen Zielordner zurück, also auch die
|
||||
// Dateien der vorigen Titel — neu ist, was noch nicht bekannt war.
|
||||
const neu = rip.dateien.filter((d) => !alleDateien.has(d))
|
||||
for (const d of rip.dateien) alleDateien.add(d)
|
||||
const neu = rip.dateien.filter((d) => !alleDateien.has(d) && d.toLowerCase().endsWith('.mkv'))
|
||||
for (const d of rip.dateien) if (d.toLowerCase().endsWith('.mkv')) alleDateien.add(d)
|
||||
for (const d of neu) auftragJeDatei.set(d, auftrag[i])
|
||||
if (neu.length === 0) {
|
||||
// MakeMKV kann mit Code 0 enden und trotzdem nichts abgelegt haben
|
||||
@@ -349,7 +460,6 @@ export class Pipeline {
|
||||
return
|
||||
}
|
||||
|
||||
const hinweise: string[] = []
|
||||
if (uebersprungen.length > 0) hinweise.push(`Übersprungen: ${uebersprungen.join(', ')}.`)
|
||||
if (gescheitert.length > 0) hinweise.push(`Nicht gesichert: ${gescheitert.join(' · ')}`)
|
||||
if (aufgeraeumt.length > 0) hinweise.push(`Halbe Dateien entfernt: ${aufgeraeumt.join(', ')}.`)
|
||||
@@ -397,7 +507,7 @@ export class Pipeline {
|
||||
phase: 'fertig',
|
||||
prozent: 100,
|
||||
text:
|
||||
`Verlustfrei gesichert: ${dateien.length} ${dateien.length === 1 ? 'Titel' : 'Titel'}, ${(rohBytes / 1e9).toFixed(2).replace('.', ',')} GB — ` +
|
||||
`Verlustfrei gesichert: ${dateien.length} Titel, ${(rohBytes / 1e9).toFixed(2).replace('.', ',')} GB — ` +
|
||||
(platz > 0
|
||||
? `Kompression eingereiht${platz > 1 ? ` (Platz ${platz})` : ''}, das Laufwerk ist frei.`
|
||||
: 'Kompression nicht eingereiht (kein Empfänger) — die Roh-Dateien liegen unter ' + rohOrdner + '.') +
|
||||
@@ -587,11 +697,12 @@ function dateienIn(ordner: string): Set<string> {
|
||||
}
|
||||
|
||||
/** Entfernt, was seit `vorher` im Ordner dazukam — die halbe Datei eines
|
||||
* abgebrochenen oder gescheiterten Titels. Liefert die Namen. */
|
||||
export function halbeDateienEntfernen(ordner: string, vorher: ReadonlySet<string>): string[] {
|
||||
* abgebrochenen oder gescheiterten Titels. `schonen` bleibt immer liegen
|
||||
* (das Rettungs-Abbild). Liefert die Namen. */
|
||||
export function halbeDateienEntfernen(ordner: string, vorher: ReadonlySet<string>, schonen: readonly string[] = []): string[] {
|
||||
const entfernt: string[] = []
|
||||
for (const name of dateienIn(ordner)) {
|
||||
if (vorher.has(name)) continue
|
||||
if (vorher.has(name) || schonen.includes(name)) continue
|
||||
try {
|
||||
unlinkSync(join(ordner, name))
|
||||
entfernt.push(name)
|
||||
|
||||
@@ -6,6 +6,9 @@
|
||||
// EINE zur Zeit, denn zwei HandBrakes teilen sich dieselbe Grafikkarte und
|
||||
// werden zusammen nicht schneller.
|
||||
//
|
||||
// 5.5.0: Pause (Commander: „zum Beispiel beim Spielen") — der laufende
|
||||
// Film wird fertig gerechnet, der nächste wartet, bis es weitergeht.
|
||||
//
|
||||
// PUR: Was ausgeführt wird, kommt injiziert (ablegen.ts) — die Ampel
|
||||
// prüft das Verhalten der Schlange auf Linux ohne HandBrake.
|
||||
import type { KompressionStand } from '../../gemeinsam/nachrichten'
|
||||
@@ -34,6 +37,7 @@ export class KompressionsWarteschlange {
|
||||
private laufend: Eintrag | null = null
|
||||
private laufendStand: KompressionStand | null = null
|
||||
private arbeitet = false
|
||||
private pausiert = false
|
||||
|
||||
constructor(
|
||||
private readonly ausfuehren: Ausfuehren,
|
||||
@@ -71,6 +75,7 @@ export class KompressionsWarteschlange {
|
||||
preset: '',
|
||||
fertigBytes: 0,
|
||||
hinweise: [],
|
||||
folgenVergeben: [],
|
||||
})
|
||||
return true
|
||||
}
|
||||
@@ -81,6 +86,17 @@ export class KompressionsWarteschlange {
|
||||
return false
|
||||
}
|
||||
|
||||
/** Pause: Der laufende Auftrag wird fertig, der nächste startet erst nach
|
||||
* `pausieren(false)`. */
|
||||
pausieren(an: boolean): void {
|
||||
this.pausiert = an
|
||||
if (!an) void this.schleife()
|
||||
}
|
||||
|
||||
istPausiert(): boolean {
|
||||
return this.pausiert
|
||||
}
|
||||
|
||||
stand(): WarteschlangenStand {
|
||||
return {
|
||||
laeuft: this.laufendStand === null ? null : { ...this.laufendStand },
|
||||
@@ -88,7 +104,7 @@ export class KompressionsWarteschlange {
|
||||
vorgangId: e.auftrag.vorgangId,
|
||||
titel: e.titel,
|
||||
prozent: -1,
|
||||
text: 'wartet',
|
||||
text: this.pausiert ? 'wartet (Pause)' : 'wartet',
|
||||
phase: 'wartet',
|
||||
})),
|
||||
}
|
||||
@@ -107,7 +123,7 @@ export class KompressionsWarteschlange {
|
||||
if (this.arbeitet) return
|
||||
this.arbeitet = true
|
||||
try {
|
||||
while (this.wartend.length > 0) {
|
||||
while (this.wartend.length > 0 && !this.pausiert) {
|
||||
const eintrag = this.wartend.shift()!
|
||||
this.laufend = eintrag
|
||||
this.laufendStand = {
|
||||
@@ -141,6 +157,7 @@ export class KompressionsWarteschlange {
|
||||
preset: '',
|
||||
fertigBytes: 0,
|
||||
hinweise: [],
|
||||
folgenVergeben: [],
|
||||
}
|
||||
}
|
||||
this.laufend = null
|
||||
|
||||
@@ -0,0 +1,178 @@
|
||||
// Die Automatik (5.5.0, aus ARM: Auto-Modus; KONZEPT § 5 Schritt 4:
|
||||
// „sicher genug → sofort losrippen, nur Bescheid sagen — Zero-Click").
|
||||
//
|
||||
// Ablauf: Disc rein → Erkennung sicher (≥ 90 %) und nicht schon gerippt →
|
||||
// Rippy liest die Titel von selbst → ist die Vorauswahl eindeutig, läuft
|
||||
// ein Countdown (Vorgabe 30 s, Einstellung automatikSekunden) → dann der
|
||||
// Rip mit Rippys Vorschlag. Ein Klick auf „Stopp" oder das Öffnen des
|
||||
// Dialogs beendet den Countdown; „Jetzt" überspringt ihn. Wo Rippy unsicher
|
||||
// ist, passiert NICHTS von selbst — es sagt nur, warum.
|
||||
//
|
||||
// PUR bis auf die Uhr: Die Abhängigkeiten kommen injiziert, die Ampel
|
||||
// prüft den Ablauf mit einer Fake-Uhr.
|
||||
import type { AutomatikStand, GeraeteInfo, RipAuftragOptionen, RipAuftragTitel, TitelStand } from '../../gemeinsam/nachrichten'
|
||||
import type { KernKontext } from '../kontext'
|
||||
import { ABGELOEST } from '../rip/makemkv'
|
||||
import type { Zuordnung } from '../metadaten/zuordnung'
|
||||
|
||||
export const AUTOMATIK_SICHER = 0.9
|
||||
|
||||
export interface AutomatikAbhaengigkeiten {
|
||||
an(): boolean
|
||||
sekunden(): number
|
||||
ripLaeuft(id: string): boolean
|
||||
titelLesen(id: string): Promise<TitelStand>
|
||||
ripStarten(id: string, auftrag: RipAuftragTitel[], optionen: RipAuftragOptionen): void
|
||||
discAngaben(id: string): { staffel: number | null; discNr: number | null } | null
|
||||
serienMerker(zuordnung: Zuordnung): { staffel: number; naechsteFolge: number } | null
|
||||
benachrichtigen(titel: string, text: string): void
|
||||
/** Uhr — injizierbar. */
|
||||
takt?: (fn: () => void, ms: number) => NodeJS.Timeout
|
||||
taktStoppen?: (zeiger: NodeJS.Timeout) => void
|
||||
}
|
||||
|
||||
/** Rippys Vorschlag als Rip-Auftrag (pur): die vorausgewählten Titel mit
|
||||
* ihren Rollen; Sprachen leer = die globale Einstellung gilt. */
|
||||
export function auftragAusVorschlag(stand: TitelStand): RipAuftragTitel[] {
|
||||
return stand.titel
|
||||
.filter((t) => t.gewaehlt)
|
||||
.map((t) => ({ nr: t.nr, rolle: t.rolle, dauerS: t.dauerS, groesseBytes: t.groesseBytes }))
|
||||
}
|
||||
|
||||
/** Staffel und erste Folge für den Automatik-Rip (pur): Disc-Angabe vor
|
||||
* Merker; „ab Folge" nur vom Merker, und nur, wenn die Disc nicht die
|
||||
* erste ihrer Ausgabe ist (sonst würde Disc 1 bei Folge 3 anfangen). */
|
||||
export function optionenAus(
|
||||
angaben: { staffel: number | null; discNr: number | null } | null,
|
||||
merker: { staffel: number; naechsteFolge: number } | null,
|
||||
): RipAuftragOptionen {
|
||||
const staffel = angaben?.staffel ?? merker?.staffel ?? null
|
||||
const ersteFolge = merker !== null && (angaben?.discNr === null || angaben === null || angaben.discNr > 1) ? merker.naechsteFolge : null
|
||||
return { staffel, ersteFolge }
|
||||
}
|
||||
|
||||
export class AutomatikDienst {
|
||||
private zeiger = new Map<string, NodeJS.Timeout>()
|
||||
private staende = new Map<string, AutomatikStand>()
|
||||
|
||||
constructor(
|
||||
private readonly kontext: KernKontext,
|
||||
private readonly abh: AutomatikAbhaengigkeiten,
|
||||
) {}
|
||||
|
||||
stand(id: string): AutomatikStand | null {
|
||||
return this.staende.get(id) ?? null
|
||||
}
|
||||
|
||||
private melden(id: string, aktiv: boolean, sekunden: number, text: string): void {
|
||||
const stand = { id, aktiv, sekunden, text }
|
||||
this.staende.set(id, stand)
|
||||
this.kontext.anFenster({ art: 'automatik', stand })
|
||||
}
|
||||
|
||||
/** Disc rein, Erkennung fertig — soll die Automatik übernehmen? */
|
||||
async pruefen(geraet: GeraeteInfo, zuordnung: Zuordnung | null, schonGerippt: string | null): Promise<void> {
|
||||
const id = geraet.id
|
||||
if (!this.abh.an()) return
|
||||
if (geraet.typ === 'cd' || geraet.typ === 'unknown') return
|
||||
if (this.abh.ripLaeuft(id)) return
|
||||
if (zuordnung === null || zuordnung.confidence < AUTOMATIK_SICHER) {
|
||||
this.melden(id, false, 0, 'Automatik wartet: Die Erkennung ist nicht sicher genug — bitte selbst starten oder „Ändern …".')
|
||||
return
|
||||
}
|
||||
if (schonGerippt !== null) {
|
||||
this.melden(id, false, 0, `Automatik wartet: Diese Disc wurde schon gerippt (${schonGerippt.slice(0, 10)}).`)
|
||||
return
|
||||
}
|
||||
this.melden(id, false, 0, 'Automatik: liest die Titel …')
|
||||
const titel = await this.abh.titelLesen(id)
|
||||
if (titel.fehler === ABGELOEST) return
|
||||
if (this.abh.ripLaeuft(id)) return
|
||||
if (titel.fehler.length > 0) {
|
||||
this.melden(id, false, 0, `Automatik wartet: ${titel.fehler}`)
|
||||
return
|
||||
}
|
||||
if (titel.unsicher || !titel.titel.some((t) => t.gewaehlt)) {
|
||||
this.melden(id, false, 0, `Automatik wartet: ${titel.einordnung}`)
|
||||
return
|
||||
}
|
||||
this.countdown(id, titel)
|
||||
}
|
||||
|
||||
private countdown(id: string, titel: TitelStand): void {
|
||||
this.stopp(id, '')
|
||||
let rest = this.abh.sekunden()
|
||||
const n = titel.titel.filter((t) => t.gewaehlt).length
|
||||
const text = (s: number): string => `Automatik: Rip von ${n} ${n === 1 ? 'Titel' : 'Titeln'} startet in ${s} s — Rippys Vorschlag.`
|
||||
this.melden(id, true, rest, text(rest))
|
||||
const takt = this.abh.takt ?? ((fn, ms) => setInterval(fn, ms))
|
||||
const zeiger = takt(() => {
|
||||
rest -= 1
|
||||
if (rest > 0) {
|
||||
this.melden(id, true, rest, text(rest))
|
||||
return
|
||||
}
|
||||
this.stopp(id, '')
|
||||
this.starten(id, titel)
|
||||
}, 1000)
|
||||
this.zeiger.set(id, zeiger)
|
||||
}
|
||||
|
||||
private starten(id: string, titel: TitelStand): void {
|
||||
if (this.abh.ripLaeuft(id)) return
|
||||
const auftrag = auftragAusVorschlag(titel)
|
||||
if (auftrag.length === 0) return
|
||||
const zuordnungTitel = titel.titel.some((t) => t.gewaehlt && t.rolle === 'folge')
|
||||
const optionen = optionenAus(this.abh.discAngaben(id), zuordnungTitel ? this.merkerFuer(id) : null)
|
||||
this.melden(id, false, 0, `Automatik: Rip gestartet (${auftrag.length} ${auftrag.length === 1 ? 'Titel' : 'Titel'}).`)
|
||||
this.kontext.hinweis(`Automatik: Rip auf ${id} gestartet — Rippys Vorschlag, ${auftrag.length} Titel.`)
|
||||
this.abh.benachrichtigen('Rippy rippt', `Automatik hat auf Laufwerk ${id} gestartet: ${auftrag.length} Titel.`)
|
||||
this.abh.ripStarten(id, auftrag, optionen)
|
||||
}
|
||||
|
||||
private merkerZuordnung = new Map<string, Zuordnung>()
|
||||
|
||||
/** Die Zuordnung merken, damit der Serien-Merker beim Start gefragt werden kann. */
|
||||
zuordnungMerken(id: string, zuordnung: Zuordnung | null): void {
|
||||
if (zuordnung === null) this.merkerZuordnung.delete(id)
|
||||
else this.merkerZuordnung.set(id, zuordnung)
|
||||
}
|
||||
|
||||
private merkerFuer(id: string): { staffel: number; naechsteFolge: number } | null {
|
||||
const z = this.merkerZuordnung.get(id)
|
||||
return z === undefined ? null : this.abh.serienMerker(z)
|
||||
}
|
||||
|
||||
/** Countdown beenden — vom Nutzer (Grund wird gesagt) oder intern (leer). */
|
||||
stopp(id: string, grund: string): void {
|
||||
const zeiger = this.zeiger.get(id)
|
||||
if (zeiger !== undefined) {
|
||||
;(this.abh.taktStoppen ?? ((z) => clearInterval(z)))(zeiger)
|
||||
this.zeiger.delete(id)
|
||||
}
|
||||
if (grund.length > 0) this.melden(id, false, 0, grund)
|
||||
}
|
||||
|
||||
/** „Jetzt": den Countdown überspringen. */
|
||||
jetzt(id: string): void {
|
||||
const stand = this.staende.get(id)
|
||||
if (stand === undefined || !stand.aktiv) return
|
||||
this.stopp(id, '')
|
||||
const titel = this.letzteTitel.get(id)
|
||||
if (titel !== undefined) this.starten(id, titel)
|
||||
}
|
||||
|
||||
private letzteTitel = new Map<string, TitelStand>()
|
||||
|
||||
/** Der Titel-Stand, aus dem gestartet wird — die Erkennung reicht ihn durch. */
|
||||
titelMerken(id: string, stand: TitelStand): void {
|
||||
this.letzteTitel.set(id, stand)
|
||||
}
|
||||
|
||||
discEntnommen(id: string): void {
|
||||
this.stopp(id, '')
|
||||
this.staende.delete(id)
|
||||
this.letzteTitel.delete(id)
|
||||
this.merkerZuordnung.delete(id)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,94 @@
|
||||
// Benachrichtigung aufs Handy (5.5.0, aus ARM: Apprise/Pushover/…) — zwei
|
||||
// Wege, beide ohne Bibliothek, beide dokumentiert (Regel D):
|
||||
// Discord-Webhook: POST <webhook-url> mit JSON { content } —
|
||||
// discord.com/developers/docs/resources/webhook („Execute Webhook":
|
||||
// content ist eine Zeichenkette bis 2000 Zeichen).
|
||||
// Telegram-Bot: POST https://api.telegram.org/bot<TOKEN>/sendMessage mit
|
||||
// JSON { chat_id, text } — core.telegram.org/bots/api#sendmessage.
|
||||
// Ein Fehlschlag wird GESAGT (Ereignis-Zeile), kippt aber nie den Vorgang,
|
||||
// der ihn ausgelöst hat.
|
||||
import type { KernKontext } from '../kontext'
|
||||
import type { EinstellungsDienst } from './einstellungen'
|
||||
|
||||
export interface Kanaele {
|
||||
discordWebhook: string
|
||||
telegramToken: string
|
||||
telegramChatId: string
|
||||
}
|
||||
|
||||
/** Was an Discord geht (pur, testbar). */
|
||||
export function discordAnfrage(webhook: string, titel: string, text: string): { url: string; body: string } {
|
||||
const inhalt = `**${titel}**\n${text}`.slice(0, 1990)
|
||||
return { url: webhook, body: JSON.stringify({ content: inhalt, username: 'Rippy' }) }
|
||||
}
|
||||
|
||||
/** Was an Telegram geht (pur, testbar). */
|
||||
export function telegramAnfrage(token: string, chatId: string, titel: string, text: string): { url: string; body: string } {
|
||||
return {
|
||||
url: `https://api.telegram.org/bot${token}/sendMessage`,
|
||||
body: JSON.stringify({ chat_id: chatId, text: `${titel}\n${text}`.slice(0, 4000) }),
|
||||
}
|
||||
}
|
||||
|
||||
export function kanaeleAus(lesen: (schluessel: string) => string): Kanaele {
|
||||
return {
|
||||
discordWebhook: lesen('discordWebhook').trim(),
|
||||
telegramToken: lesen('telegramToken').trim(),
|
||||
telegramChatId: lesen('telegramChatId').trim(),
|
||||
}
|
||||
}
|
||||
|
||||
export function kanaeleEingerichtet(k: Kanaele): boolean {
|
||||
return k.discordWebhook.length > 0 || (k.telegramToken.length > 0 && k.telegramChatId.length > 0)
|
||||
}
|
||||
|
||||
export class BenachrichtigungsDienst {
|
||||
constructor(
|
||||
private readonly kontext: KernKontext,
|
||||
private readonly einstellungen: EinstellungsDienst,
|
||||
private readonly holen: typeof fetch = fetch,
|
||||
) {}
|
||||
|
||||
eingeschaltet(): boolean {
|
||||
return this.einstellungen.lesen('benachrichtigungen', 'an') !== 'aus'
|
||||
}
|
||||
|
||||
/** Schickt über alle eingerichteten Kanäle. Liefert die Fehler (leer = alles gut). */
|
||||
async senden(titel: string, text: string, erzwingen = false): Promise<string[]> {
|
||||
if (!erzwingen && !this.eingeschaltet()) return []
|
||||
const k = kanaeleAus((s) => this.einstellungen.lesen(s))
|
||||
const fehler: string[] = []
|
||||
const anfragen: Array<{ name: string; url: string; body: string }> = []
|
||||
if (k.discordWebhook.length > 0) anfragen.push({ name: 'Discord', ...discordAnfrage(k.discordWebhook, titel, text) })
|
||||
if (k.telegramToken.length > 0 && k.telegramChatId.length > 0) {
|
||||
anfragen.push({ name: 'Telegram', ...telegramAnfrage(k.telegramToken, k.telegramChatId, titel, text) })
|
||||
}
|
||||
for (const a of anfragen) {
|
||||
try {
|
||||
const antwort = await this.holen(a.url, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: a.body,
|
||||
signal: AbortSignal.timeout(15_000),
|
||||
})
|
||||
if (antwort.status >= 300) fehler.push(`${a.name}: HTTP ${antwort.status}`)
|
||||
} catch (e) {
|
||||
fehler.push(`${a.name}: ${String((e as Error).message ?? e).slice(0, 120)}`)
|
||||
}
|
||||
}
|
||||
for (const f of fehler) this.kontext.fehler(`Benachrichtigung ${f}`)
|
||||
if (anfragen.length > 0 && fehler.length === 0) this.kontext.protokoll.schreiben(`Benachrichtigt (${anfragen.map((a) => a.name).join(', ')}): ${titel}`)
|
||||
return fehler
|
||||
}
|
||||
|
||||
/** Der Knopf „Testnachricht" — antwortet IMMER etwas. */
|
||||
async testen(): Promise<void> {
|
||||
const k = kanaeleAus((s) => this.einstellungen.lesen(s))
|
||||
if (!kanaeleEingerichtet(k)) {
|
||||
this.kontext.fehler('Benachrichtigung: kein Kanal eingerichtet — Discord-Webhook oder Telegram-Bot eintragen.')
|
||||
return
|
||||
}
|
||||
const fehler = await this.senden('Rippy meldet sich', 'Testnachricht — die Verbindung steht.', true)
|
||||
if (fehler.length === 0) this.kontext.hinweis('Testnachricht verschickt.')
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,137 @@
|
||||
// Einstellungen (§ 6.7): Das Fenster liest und schreibt NUR über den Kern;
|
||||
// erlaubt sind genau die Schlüssel hier. Dazu die Pfad-Regeln: Ablage
|
||||
// (Fertiges — beim Commander der Server) und seit 5.5.0 der Arbeitsordner
|
||||
// (Roh-Dateien und Kompression — lokal, schnell; Vorgabe: unter der Ablage,
|
||||
// also wie bisher).
|
||||
import { join } from 'node:path'
|
||||
import { AUFBEWAHRUNG_SCHLUESSEL } from '../ablage/rohaufraeumen'
|
||||
import { einstellung, type KernKontext } from '../kontext'
|
||||
|
||||
export const ERLAUBTE_EINSTELLUNGEN: ReadonlySet<string> = new Set([
|
||||
'ablage',
|
||||
'arbeitsordner',
|
||||
'transcodeEnabled',
|
||||
'transcodePresetDvd',
|
||||
'transcodePresetBluray',
|
||||
'transcodePresetUhd',
|
||||
'audioSprachen',
|
||||
'untertitelSprachen',
|
||||
'mediaServer',
|
||||
'mediaServerUrl',
|
||||
'mediaServerApiKey',
|
||||
'tmdbApiKey',
|
||||
'omdbApiKey',
|
||||
'makemkvAppKey',
|
||||
'updateUrl',
|
||||
'setup.done',
|
||||
'autoAuswurf',
|
||||
'werkzeug.makemkv',
|
||||
'werkzeug.handbrake',
|
||||
'werkzeug.flac',
|
||||
AUFBEWAHRUNG_SCHLUESSEL,
|
||||
// 5.5.0
|
||||
'automatik',
|
||||
'automatikSekunden',
|
||||
'benachrichtigungen',
|
||||
'discordWebhook',
|
||||
'telegramToken',
|
||||
'telegramChatId',
|
||||
])
|
||||
|
||||
/** Die Schlüssel, die Rip und Kompression lesen (Pipeline/Ablage). Das
|
||||
* frühere „Allgemeine Preset" (transcodePreset) ist seit 5.5.0 raus —
|
||||
* Commander-Wunsch: je Disc-Typ reicht, ein unsichtbarer Übersteuerer
|
||||
* verwirrt nur. */
|
||||
const PIPELINE_EINSTELLUNGEN = [
|
||||
'transcodeEnabled',
|
||||
'transcodePresetDvd',
|
||||
'transcodePresetBluray',
|
||||
'transcodePresetUhd',
|
||||
'audioSprachen',
|
||||
'untertitelSprachen',
|
||||
'mediaServer',
|
||||
'mediaServerUrl',
|
||||
'mediaServerApiKey',
|
||||
] as const
|
||||
|
||||
export const AUTOMATIK_SEKUNDEN_VORGABE = 30
|
||||
|
||||
export class EinstellungsDienst {
|
||||
constructor(private readonly kontext: KernKontext) {}
|
||||
|
||||
lesen(schluessel: string, vorgabe = ''): string {
|
||||
return einstellung(this.kontext, schluessel, vorgabe)
|
||||
}
|
||||
|
||||
/** Wurzel der Ablage — Fertiges, Musik, ISO. */
|
||||
ablageOrdner(): string {
|
||||
const eingestellt = this.lesen('ablage')
|
||||
if (eingestellt.length > 0) return eingestellt
|
||||
return join(process.env['USERPROFILE'] ?? '.', 'Videos', 'Rippy')
|
||||
}
|
||||
|
||||
/** Ein eigener Arbeitsordner — '' wenn keiner gesetzt ist. */
|
||||
arbeitsordnerEigen(): string {
|
||||
return this.lesen('arbeitsordner').trim()
|
||||
}
|
||||
|
||||
/** Wo gearbeitet wird: der eigene Arbeitsordner, sonst die Ablage. */
|
||||
arbeitsordner(): string {
|
||||
const eigen = this.arbeitsordnerEigen()
|
||||
return eigen.length > 0 ? eigen : this.ablageOrdner()
|
||||
}
|
||||
|
||||
/** Wo die Roh-Ordner liegen. */
|
||||
rohWurzel(): string {
|
||||
return join(this.arbeitsordner(), 'roh')
|
||||
}
|
||||
|
||||
/** Was Pipeline und Ablage brauchen. */
|
||||
fuerPipeline(): Record<string, string> {
|
||||
const werte: Record<string, string> = {}
|
||||
for (const schluessel of PIPELINE_EINSTELLUNGEN) {
|
||||
const wert = this.kontext.db?.einstellungLesen(schluessel)
|
||||
if (wert !== null && wert !== undefined) werte[schluessel] = wert
|
||||
}
|
||||
return werte
|
||||
}
|
||||
|
||||
automatikAn(): boolean {
|
||||
return this.lesen('automatik', 'an') !== 'aus'
|
||||
}
|
||||
|
||||
automatikSekunden(): number {
|
||||
const n = Number(this.lesen('automatikSekunden', String(AUTOMATIK_SEKUNDEN_VORGABE)))
|
||||
return Number.isInteger(n) && n >= 5 && n <= 600 ? n : AUTOMATIK_SEKUNDEN_VORGABE
|
||||
}
|
||||
|
||||
/** Alle erlaubten Werte ans Fenster — AUCH ans Haupt (Update-Adresse, § 6.8). */
|
||||
senden(): void {
|
||||
const werte: Record<string, string> = { ablage: this.ablageOrdner() }
|
||||
for (const schluessel of ERLAUBTE_EINSTELLUNGEN) {
|
||||
const wert = this.kontext.db?.einstellungLesen(schluessel)
|
||||
if (wert !== null && wert !== undefined) werte[schluessel] = wert
|
||||
}
|
||||
this.kontext.anHauptUndFenster({ art: 'einstellungen', werte })
|
||||
}
|
||||
|
||||
/** Schreiben — nur erlaubte Schlüssel, nur mit Datenbank. Liefert, ob es klappte. */
|
||||
setzen(schluessel: string, wert: string): boolean {
|
||||
if (!ERLAUBTE_EINSTELLUNGEN.has(schluessel)) {
|
||||
this.kontext.fehler(`Unbekannter Einstellungs-Schlüssel: ${schluessel}`)
|
||||
return false
|
||||
}
|
||||
if (this.kontext.db === null) {
|
||||
this.kontext.fehler('Einstellung nicht gespeichert — die Datenbank ist nicht da.')
|
||||
return false
|
||||
}
|
||||
this.kontext.db.einstellungSchreiben(schluessel, wert)
|
||||
this.kontext.protokoll.schreiben(`Einstellung ${schluessel} gesetzt${istGeheim(schluessel) ? '' : `: ${wert.slice(0, 120)}`}`)
|
||||
this.senden()
|
||||
return true
|
||||
}
|
||||
}
|
||||
|
||||
function istGeheim(schluessel: string): boolean {
|
||||
return /key|token|webhook|passwort/i.test(schluessel)
|
||||
}
|
||||
@@ -0,0 +1,408 @@
|
||||
// Die Erkennung (W-4, § 5 Schritt 3): Was liegt da drin? Disc-Merkmale,
|
||||
// TMDb/OMDb-Zuordnung mit Sicherheitsgrad, die Nachprüfung nach dem
|
||||
// Info-Lauf (Erkennung v2, 5.4.0), der Titel-Lauf für den Auswahl-Dialog,
|
||||
// die Metadaten-Suche des Ändern-Dialogs — und seit 5.5.0 der Serien-Merker
|
||||
// (welche Folge auf der nächsten Disc weitergeht) und die Poster für den
|
||||
// Hintergrund der Erst-Einrichtung.
|
||||
import type {
|
||||
DiscInfoStand,
|
||||
DiscTitelVorschlag,
|
||||
GeraeteInfo,
|
||||
MetaVorschlag,
|
||||
TitelStand,
|
||||
} from '../../gemeinsam/nachrichten'
|
||||
import { einstellung, type KernKontext } from '../kontext'
|
||||
import { discFingerprint, discTitel, type DiscTitel } from '../metadaten/discmerkmale'
|
||||
import { OmdbClient } from '../metadaten/omdb'
|
||||
import { TmdbClient } from '../metadaten/tmdb'
|
||||
import { LEERER_TREFFER, ausDetails, nachpruefen, zuordnen, type Zuordnung } from '../metadaten/zuordnung'
|
||||
import { ABGELOEST, titelInfoLesen } from '../rip/makemkv'
|
||||
import { sprachenFuerTitel, type TitelInfo } from '../rip/parser'
|
||||
import { strukturHinweis, titelVorauswahl } from '../rip/titelwahl'
|
||||
|
||||
export interface ErkennungAbhaengigkeiten {
|
||||
ripLaeuft(id: string): boolean
|
||||
geraetInfoVon(id: string): GeraeteInfo | null
|
||||
makemkvcon(): string
|
||||
}
|
||||
|
||||
/** Der Serien-Merker (5.5.0): je TMDb-Serie, was die vorige Disc hinterließ. */
|
||||
export interface SerienMerker {
|
||||
titel: string
|
||||
staffel: number
|
||||
naechsteFolge: number
|
||||
wann: string
|
||||
}
|
||||
|
||||
export const SERIEN_MERKER_SCHLUESSEL = 'serienMerker'
|
||||
|
||||
/** Liest den Merker-Speicher (pur, robust gegen Unsinn). */
|
||||
export function serienMerkerAusJson(text: string | null): Record<string, SerienMerker> {
|
||||
if (text === null || text.length === 0) return {}
|
||||
try {
|
||||
const roh: unknown = JSON.parse(text)
|
||||
if (typeof roh !== 'object' || roh === null) return {}
|
||||
const ergebnis: Record<string, SerienMerker> = {}
|
||||
for (const [id, wert] of Object.entries(roh as Record<string, unknown>)) {
|
||||
if (typeof wert !== 'object' || wert === null) continue
|
||||
const m = wert as Record<string, unknown>
|
||||
if (typeof m.staffel !== 'number' || typeof m.naechsteFolge !== 'number') continue
|
||||
ergebnis[id] = {
|
||||
titel: typeof m.titel === 'string' ? m.titel : '',
|
||||
staffel: m.staffel,
|
||||
naechsteFolge: m.naechsteFolge,
|
||||
wann: typeof m.wann === 'string' ? m.wann : '',
|
||||
}
|
||||
}
|
||||
return ergebnis
|
||||
} catch {
|
||||
// Ein kaputter Merker ist kein Grund, nicht zu erkennen — er ist dann leer.
|
||||
return {}
|
||||
}
|
||||
}
|
||||
|
||||
function jahrAus(datum: string | undefined): number | null {
|
||||
if (datum === undefined || datum.length < 4) return null
|
||||
const jahr = Number(datum.slice(0, 4))
|
||||
return Number.isFinite(jahr) && jahr > 0 ? jahr : null
|
||||
}
|
||||
|
||||
export class ErkennungDienst {
|
||||
private zuordnungen = new Map<string, Zuordnung>()
|
||||
private fingerprints = new Map<string, string>()
|
||||
/** Was die Disc über sich selbst sagt (Disc-Nummer, Staffel, Folgenzahl) —
|
||||
* das bleibt wahr, auch wenn der Commander den Titel selbst neu wählt. */
|
||||
private merkmale = new Map<string, DiscTitel>()
|
||||
/** Der letzte Titel-Stand je Laufwerk — die Automatik (5.5.0) rippt daraus. */
|
||||
readonly letzteTitel = new Map<string, TitelStand>()
|
||||
// Je Laufwerk höchstens EIN Titel-Lauf, und nur der NEUESTE darf
|
||||
// antworten. Der Commander-Fund vom 01.09.2026: Die Titelliste kam
|
||||
// korrekt an — und 300 s später legte ein ÄLTERER, längst überholter Lauf
|
||||
// seinen Timeout darüber („keine Antwort nach 300 s"). Zwei makemkvcon
|
||||
// auf derselben Disc bremsen sich außerdem gegenseitig aus.
|
||||
private titelAbbrueche = new Map<string, AbortController>()
|
||||
private titelLaufZaehler = 0
|
||||
private titelLaufNummern = new Map<string, number>()
|
||||
|
||||
constructor(
|
||||
private readonly kontext: KernKontext,
|
||||
private readonly abh: ErkennungAbhaengigkeiten,
|
||||
) {}
|
||||
|
||||
private tmdb(): TmdbClient {
|
||||
return new TmdbClient(einstellung(this.kontext, 'tmdbApiKey'))
|
||||
}
|
||||
|
||||
private omdb(): OmdbClient {
|
||||
return new OmdbClient(einstellung(this.kontext, 'omdbApiKey'))
|
||||
}
|
||||
|
||||
zuordnung(id: string): Zuordnung | null {
|
||||
return this.zuordnungen.get(id) ?? null
|
||||
}
|
||||
|
||||
fingerprint(id: string): string | null {
|
||||
return this.fingerprints.get(id) ?? null
|
||||
}
|
||||
|
||||
discAngaben(id: string): { staffel: number | null; discNr: number | null } | null {
|
||||
const m = this.merkmale.get(id)
|
||||
return m === undefined ? null : { staffel: m.staffel, discNr: m.discNr }
|
||||
}
|
||||
|
||||
// ── Serien-Merker (5.5.0) ───────────────────────────────────────────────
|
||||
private alleMerker(): Record<string, SerienMerker> {
|
||||
return serienMerkerAusJson(this.kontext.db?.einstellungLesen(SERIEN_MERKER_SCHLUESSEL) ?? null)
|
||||
}
|
||||
|
||||
serienMerkerFuer(tmdbId: number | string | null): SerienMerker | null {
|
||||
if (tmdbId === null) return null
|
||||
return this.alleMerker()[String(tmdbId)] ?? null
|
||||
}
|
||||
|
||||
/** Nach einer fertigen Serien-Ablage: Mit welcher Folge geht es weiter? */
|
||||
serienMerkerSetzen(tmdbId: number | string, titel: string, staffel: number, naechsteFolge: number): void {
|
||||
if (this.kontext.db === null) return
|
||||
const alle = this.alleMerker()
|
||||
alle[String(tmdbId)] = { titel, staffel, naechsteFolge, wann: new Date().toISOString() }
|
||||
this.kontext.db.einstellungSchreiben(SERIEN_MERKER_SCHLUESSEL, JSON.stringify(alle))
|
||||
this.kontext.protokoll.schreiben(`Serien-Merker: „${titel}" Staffel ${staffel}, weiter mit Folge ${naechsteFolge}`)
|
||||
}
|
||||
|
||||
/** EINE Stelle, die aus Zuordnung + Disc-Merkmalen den Stand fürs Fenster
|
||||
* baut (5.4.0) — vorher stand dieselbe Struktur dreimal im Code. */
|
||||
discInfoStand(id: string, zuordnung: Zuordnung | null, quelle?: string): DiscInfoStand {
|
||||
const m = this.merkmale.get(id)
|
||||
const meta = zuordnung?.meta
|
||||
const merker = meta?.typ === 'tv' ? this.serienMerkerFuer(meta.id) : null
|
||||
return {
|
||||
id,
|
||||
titel: zuordnung?.titel ?? '',
|
||||
jahr: zuordnung?.jahr ?? null,
|
||||
confidence: zuordnung?.confidence ?? 0,
|
||||
quelle: quelle ?? meta?.quelle ?? '',
|
||||
posterPfad: meta?.posterPfad ?? '',
|
||||
backdropPfad: meta?.backdropPfad ?? '',
|
||||
beschreibung: meta?.beschreibung ?? '',
|
||||
// § 6.6: Rippy erkennt beim Einlegen, wenn eine Disc schon einmal
|
||||
// durchgelaufen ist — und fragt nach, statt stumm zu doppeln.
|
||||
schonGerippt:
|
||||
zuordnung === null ? null : (this.kontext.db?.bibliothekSchonGerippt(this.fingerprints.get(id) ?? '') ?? null),
|
||||
discNr: m?.discNr ?? null,
|
||||
staffel: m?.staffel ?? null,
|
||||
folgen: m?.folgen ?? 0,
|
||||
typ: meta?.typ === 'movie' || meta?.typ === 'tv' ? meta.typ : '',
|
||||
logoPfad: meta?.logoPfad ?? '',
|
||||
tagline: meta?.tagline ?? '',
|
||||
bewertung: meta?.bewertung ?? 0,
|
||||
fsk: meta?.fsk ?? '',
|
||||
laufzeitMinuten: meta?.laufzeitMinuten ?? 0,
|
||||
genres: meta?.genres ?? [],
|
||||
besetzung: meta?.besetzung ?? [],
|
||||
hinweise: zuordnung?.hinweise ?? [],
|
||||
serienMerker: merker === null ? null : { staffel: merker.staffel, naechsteFolge: merker.naechsteFolge, wann: merker.wann },
|
||||
}
|
||||
}
|
||||
|
||||
schonGerippt(id: string): string | null {
|
||||
return this.kontext.db?.bibliothekSchonGerippt(this.fingerprints.get(id) ?? '') ?? null
|
||||
}
|
||||
|
||||
/** § 5 Schritt 3: Disc rein → was ist das? Liefert die Zuordnung (für die
|
||||
* Automatik) — null, wenn die Erkennung scheiterte. */
|
||||
async discErmitteln(geraet: GeraeteInfo): Promise<Zuordnung | null> {
|
||||
try {
|
||||
const gefunden = discTitel(geraet.pfad)
|
||||
this.fingerprints.set(geraet.id, discFingerprint(geraet.pfad, geraet.groesseBytes))
|
||||
this.merkmale.set(geraet.id, gefunden)
|
||||
// Der Hinweis kommt von der Disc selbst (bdmt-Inhaltsverzeichnis) —
|
||||
// trägt sie Folgen, kann kein Filmtreffer mehr gewinnen. Und jede
|
||||
// Titel-Variante der Disc (bdmt_deu) wird mitgefragt (5.4.0).
|
||||
const zuordnung = await zuordnen(gefunden.titel, this.tmdb(), this.omdb(), {
|
||||
istSerie: gefunden.istSerie,
|
||||
alternativen: gefunden.alternativen,
|
||||
})
|
||||
this.zuordnungen.set(geraet.id, zuordnung)
|
||||
this.kontext.protokoll.schreiben(
|
||||
`Erkennung ${geraet.id}: „${gefunden.titel}" (${gefunden.quelle || 'kein Titel'}) → „${zuordnung.titel}" ${Math.round(zuordnung.confidence * 100)} % ${zuordnung.meta.typ}`,
|
||||
)
|
||||
this.kontext.anHauptUndFenster({ art: 'disc-info', info: this.discInfoStand(geraet.id, zuordnung) })
|
||||
return zuordnung
|
||||
} catch (fehler) {
|
||||
// R4: Eine gescheiterte Erkennung ist eine laute Zeile — gerippt
|
||||
// werden kann trotzdem (die Zuordnung ist Komfort, kein Torwächter).
|
||||
this.kontext.fehler(`Disc-Erkennung ${geraet.id}: ${String(fehler)}`)
|
||||
return null
|
||||
}
|
||||
}
|
||||
|
||||
discVergessen(id: string): void {
|
||||
this.zuordnungen.delete(id)
|
||||
this.fingerprints.delete(id)
|
||||
this.merkmale.delete(id)
|
||||
this.letzteTitel.delete(id)
|
||||
this.titelAbbrueche.get(id)?.abort()
|
||||
this.kontext.anHauptUndFenster({ art: 'disc-info', info: this.discInfoStand(id, null) })
|
||||
}
|
||||
|
||||
// § 5 Schritt 4: „nein → fragen" — der Nutzer sucht und WÄHLT selbst.
|
||||
async metadatenSuchen(id: string, text: string): Promise<void> {
|
||||
try {
|
||||
const tmdb = this.tmdb()
|
||||
if (!tmdb.verfuegbar) {
|
||||
this.kontext.fehler('Metadaten-Suche braucht einen TMDb-Key (Einstellungen → Metadaten).')
|
||||
this.kontext.anFenster({ art: 'metadaten-vorschlaege', id, vorschlaege: [] })
|
||||
return
|
||||
}
|
||||
const [filme, serien] = await Promise.all([tmdb.searchMovie(text), tmdb.searchTv(text)])
|
||||
const vorschlaege: MetaVorschlag[] = [
|
||||
...(filme ?? []).slice(0, 6).map((f) => ({
|
||||
typ: 'movie' as const,
|
||||
tmdbId: f.id,
|
||||
titel: f.title ?? '',
|
||||
jahr: jahrAus(f.release_date),
|
||||
posterPfad: f.poster_path ?? '',
|
||||
})),
|
||||
...(serien ?? []).slice(0, 6).map((s) => ({
|
||||
typ: 'tv' as const,
|
||||
tmdbId: s.id,
|
||||
titel: s.name ?? '',
|
||||
jahr: jahrAus(s.first_air_date),
|
||||
posterPfad: s.poster_path ?? '',
|
||||
})),
|
||||
].filter((v) => v.titel.length > 0)
|
||||
this.kontext.anFenster({ art: 'metadaten-vorschlaege', id, vorschlaege })
|
||||
} catch (fehler) {
|
||||
this.kontext.fehler(`Metadaten-Suche: ${String(fehler)}`)
|
||||
this.kontext.anFenster({ art: 'metadaten-vorschlaege', id, vorschlaege: [] })
|
||||
}
|
||||
}
|
||||
|
||||
async zuordnungSetzen(id: string, vorschlag: MetaVorschlag): Promise<void> {
|
||||
try {
|
||||
const tmdb = this.tmdb()
|
||||
const details =
|
||||
vorschlag.typ === 'movie' ? await tmdb.movieDetails(vorschlag.tmdbId) : await tmdb.tvDetails(vorschlag.tmdbId)
|
||||
const meta =
|
||||
details !== null
|
||||
? ausDetails(vorschlag.typ, vorschlag.tmdbId, details)
|
||||
: {
|
||||
...LEERER_TREFFER,
|
||||
typ: vorschlag.typ,
|
||||
id: vorschlag.tmdbId,
|
||||
titel: vorschlag.titel,
|
||||
jahr: vorschlag.jahr,
|
||||
posterPfad: vorschlag.posterPfad,
|
||||
quelle: 'tmdb' as const,
|
||||
}
|
||||
const zuordnung: Zuordnung = {
|
||||
titel: meta.titel.length > 0 ? meta.titel : vorschlag.titel,
|
||||
jahr: meta.jahr ?? vorschlag.jahr,
|
||||
// Vom Nutzer gewählt = sicher. Genau dafür ist die Frage da (§ 5).
|
||||
confidence: 1,
|
||||
meta,
|
||||
}
|
||||
this.zuordnungen.set(id, zuordnung)
|
||||
this.kontext.protokoll.schreiben(`Zuordnung ${id} vom Nutzer: „${zuordnung.titel}" (${meta.typ} ${String(meta.id)})`)
|
||||
this.kontext.anHauptUndFenster({ art: 'disc-info', info: this.discInfoStand(id, zuordnung, 'deine Wahl') })
|
||||
} catch (fehler) {
|
||||
this.kontext.fehler(`Zuordnung übernehmen: ${String(fehler)}`)
|
||||
}
|
||||
}
|
||||
|
||||
// ── Titel der Disc lesen (§ 6.2) ────────────────────────────────────────
|
||||
// Der Info-Lauf dauert 20–120 s — deshalb geschieht er erst auf Zuruf und
|
||||
// nicht schon beim Einlegen (der 30.08.-Fund: „das Erkennen dauert sehr
|
||||
// sehr lange"). Das Fenster bekommt sofort `laeuft: true`, damit es in der
|
||||
// Zeit nicht stumm dasteht (R2). Liefert den End-Stand zurück (Automatik).
|
||||
async titelLesen(id: string): Promise<TitelStand> {
|
||||
const leer: TitelStand = { id, laeuft: false, titel: [], einordnung: '', unsicher: false, fehler: '' }
|
||||
const senden = (stand: TitelStand): TitelStand => {
|
||||
if (!stand.laeuft) this.letzteTitel.set(id, stand)
|
||||
this.kontext.anFenster({ art: 'disc-titel', stand })
|
||||
return stand
|
||||
}
|
||||
if (this.abh.ripLaeuft(id)) return senden({ ...leer, fehler: 'Auf diesem Laufwerk läuft schon ein Vorgang.' })
|
||||
const geraet = this.abh.geraetInfoVon(id)
|
||||
if (geraet === null) return senden({ ...leer, fehler: `Laufwerk ${id}: gibt es nicht.` })
|
||||
const programm = this.abh.makemkvcon()
|
||||
if (programm.length === 0) {
|
||||
return senden({ ...leer, fehler: 'makemkvcon wurde nicht gefunden — ist MakeMKV installiert?' })
|
||||
}
|
||||
// Einen noch laufenden Lauf ablösen: Er gibt das Laufwerk sofort frei,
|
||||
// und seine Antwort wird verworfen (nur die neueste Nummer zählt).
|
||||
this.titelAbbrueche.get(id)?.abort()
|
||||
const abbruch = new AbortController()
|
||||
this.titelAbbrueche.set(id, abbruch)
|
||||
const meineNummer = ++this.titelLaufZaehler
|
||||
this.titelLaufNummern.set(id, meineNummer)
|
||||
const nochAktuell = (): boolean => this.titelLaufNummern.get(id) === meineNummer
|
||||
|
||||
senden({ ...leer, laeuft: true })
|
||||
const start = Date.now()
|
||||
try {
|
||||
const info = await titelInfoLesen(programm, geraet.pfad, 300_000, abbruch.signal)
|
||||
if (!nochAktuell()) return { ...leer, fehler: ABGELOEST }
|
||||
const merkmale = this.merkmale.get(id)
|
||||
const wahl = titelVorauswahl(info.titel, {
|
||||
istSerie: merkmale?.istSerie ?? false,
|
||||
folgen: merkmale?.folgen ?? 0,
|
||||
})
|
||||
// Kam nichts heraus UND MakeMKV hat einen Grund genannt, dann ist der
|
||||
// Grund die Nachricht — nicht „keine Titel gefunden". Am 01.09.2026
|
||||
// gemessen: Beim 5042-Zustand antwortet der Info-Lauf nach 0,7 s mit
|
||||
// TCOUNT:0, und ohne diesen Zweig stünde im Fenster, die DISC gäbe
|
||||
// nichts her — dabei sieht MakeMKV das LAUFWERK nicht.
|
||||
const ohneErgebnis = info.titel.length === 0 && info.ursachen.length > 0
|
||||
this.kontext.protokoll.schreiben(
|
||||
`Titel-Lauf ${id}: ${((Date.now() - start) / 1000).toFixed(1)} s, ${info.titel.length} Titel — ${wahl.einordnung}${info.ursachen.length > 0 ? ` · ${info.ursachen.join(' · ')}` : ''}`,
|
||||
)
|
||||
const titel: DiscTitelVorschlag[] = wahl.titel.map((t) => ({
|
||||
...t,
|
||||
// Die Sprachen JE TITEL reisen mit (5.4.0) — der Dialog bietet sie zum Anhaken an.
|
||||
sprachen: sprachenFuerTitel(info.streams.get(t.nr)),
|
||||
}))
|
||||
const stand = senden({
|
||||
id,
|
||||
laeuft: false,
|
||||
titel,
|
||||
einordnung: wahl.einordnung,
|
||||
unsicher: wahl.unsicher,
|
||||
fehler: ohneErgebnis ? info.ursachen.join(' · ') : '',
|
||||
})
|
||||
// Erkennung v2 (5.4.0): Jetzt liegt die Laufzeit vor — nachprüfen.
|
||||
if (info.titel.length > 0) await this.nachpruefen(id, titel, info.titel)
|
||||
return stand
|
||||
} catch (fehler) {
|
||||
// Ein ABGELÖSTER Lauf schweigt: Ihn hat ein neuerer ersetzt, das ist
|
||||
// Absicht und kein Fehlschlag. Genau hier lag der Commander-Fund —
|
||||
// der alte Lauf überschrieb sonst die längst gelieferte Titelliste.
|
||||
if (String(fehler).includes(ABGELOEST) || !nochAktuell()) return { ...leer, fehler: ABGELOEST }
|
||||
// R4: sonst laut scheitern. „Konnte nicht nachsehen" ist etwas anderes
|
||||
// als „die Disc hat keine Titel" — beides zu vermischen erzeugt Unsinn.
|
||||
const grund = String(fehler).includes('keine Antwort nach')
|
||||
? 'MakeMKV hat die Titel nach fünf Minuten nicht gelesen. Bei einer beschädigten Disc kann das passieren — Rippy hat den Versuch beendet und das Laufwerk freigegeben.'
|
||||
: `Titel lesen: ${String(fehler).slice(0, 200)}`
|
||||
this.kontext.protokoll.schreiben(`Titel-Lauf ${id} gescheitert: ${grund}`)
|
||||
return senden({ ...leer, fehler: grund })
|
||||
} finally {
|
||||
// Nur aufräumen, wenn ICH noch der aktuelle Lauf bin.
|
||||
if (nochAktuell()) {
|
||||
this.titelAbbrueche.delete(id)
|
||||
this.titelLaufNummern.delete(id)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Erkennung v2 (5.4.0): Erkannt wird beim EINLEGEN, vor jeder Messung.
|
||||
* Nach dem Info-Lauf wird noch einmal gerechnet — Laufzeit gegen TMDb,
|
||||
* Titel-Struktur gegen den Treffer-Typ. Aus „wahrscheinlich" wird
|
||||
* „bestätigt", oder Rippy merkt selbst, dass es danebenlag. */
|
||||
private async nachpruefen(id: string, vorschlag: readonly DiscTitelVorschlag[], titel: readonly TitelInfo[]): Promise<void> {
|
||||
const bisher = this.zuordnungen.get(id)
|
||||
if (bisher === undefined) return
|
||||
const gewaehlt = vorschlag.filter((t) => t.gewaehlt)
|
||||
const folgen = gewaehlt.filter((t) => t.rolle === 'folge').map((t) => t.dauerS)
|
||||
const laengster = [...titel].sort((a, b) => b.dauerS - a.dauerS)[0]?.dauerS ?? 0
|
||||
const messung = {
|
||||
hauptS: folgen.length > 0 ? 0 : (gewaehlt[0]?.dauerS ?? laengster),
|
||||
folgenS: folgen,
|
||||
struktur: strukturHinweis(titel),
|
||||
}
|
||||
let zuordnung = bisher
|
||||
// Sagt die Struktur „Serie", der Treffer aber „Film" (und der Nutzer hat
|
||||
// nicht selbst gewählt): einmal als Serie fragen — das ist der
|
||||
// Fingerabdruck, der Serien auch ohne bdmt erkennt.
|
||||
if (messung.struktur === 'serie' && bisher.meta.typ !== 'tv' && bisher.confidence < 1) {
|
||||
const merkmale = this.merkmale.get(id)
|
||||
if (merkmale !== undefined && merkmale.titel.length > 0) {
|
||||
const nochmal = await zuordnen(merkmale.titel, this.tmdb(), this.omdb(), {
|
||||
istSerie: true,
|
||||
alternativen: merkmale.alternativen,
|
||||
})
|
||||
if (nochmal.meta.typ === 'tv') {
|
||||
zuordnung = { ...nochmal, hinweise: ['Serie erkannt an der Titel-Struktur (mehrere gleich lange Titel).'] }
|
||||
}
|
||||
}
|
||||
}
|
||||
const geprueft = nachpruefen(zuordnung, messung)
|
||||
const hinweise = [...(zuordnung.hinweise ?? []), ...(geprueft.hinweise ?? [])]
|
||||
const neu = { ...geprueft, hinweise }
|
||||
this.zuordnungen.set(id, neu)
|
||||
if (hinweise.length > 0) this.kontext.protokoll.schreiben(`Nachprüfung ${id}: ${hinweise.join(' · ')} → ${Math.round(neu.confidence * 100)} %`)
|
||||
this.kontext.anHauptUndFenster({ art: 'disc-info', info: this.discInfoStand(id, neu) })
|
||||
}
|
||||
|
||||
// ── Poster für die Erst-Einrichtung (5.5.0, Commander-Wunsch) ──────────
|
||||
// TMDb /movie/popular (de-DE) — dieselbe Schnittstelle wie die Suche,
|
||||
// die Antwort trägt poster_path je Film (gemessen: results[].poster_path).
|
||||
async posterLaden(): Promise<void> {
|
||||
const tmdb = this.tmdb()
|
||||
if (!tmdb.verfuegbar) {
|
||||
this.kontext.anFenster({ art: 'poster-vorschau', pfade: [] })
|
||||
return
|
||||
}
|
||||
const pfade = await tmdb.beliebtePoster(40)
|
||||
this.kontext.anFenster({ art: 'poster-vorschau', pfade })
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,202 @@
|
||||
// Die Laufwerke (W-1, § 5 Schritt 1): Disc-Wache im 3-Sekunden-Takt,
|
||||
// Auswerfen mit Nachsehen (R3), Audio-CD-Zugriffe, die Laufwerks-Gesundheit
|
||||
// aus dem Windows-Protokoll (5.4.0) — und das nachgebaute Laufwerk des
|
||||
// Klick-Beweises.
|
||||
//
|
||||
// koffi wird erst HIER geladen, über einen echten dynamischen import():
|
||||
// Rollup legt win32.ts damit als eigenen Chunk neben kern.js (ein
|
||||
// wörtliches require überlebte das Bündeln nicht — im Smoke-Lauf am
|
||||
// 30.08.2026 sichtbar geworden). Scheitert das Laden (falsche Plattform,
|
||||
// kaputtes Paket), läuft der Kern weiter und der Grund steht im Fenster (R4).
|
||||
import type { GeraeteInfo, WacheEreignis } from '../../gemeinsam/nachrichten'
|
||||
import type { KernKontext } from '../kontext'
|
||||
import type { LaufwerkApi } from '../laufwerk/codes'
|
||||
import {
|
||||
audioSpurLesen,
|
||||
audioToc,
|
||||
auswerfenMitGrund,
|
||||
geraeteInfo,
|
||||
kennung,
|
||||
listOptischeLaufwerke,
|
||||
} from '../laufwerk/disc'
|
||||
import { beurteilen, ereignisseLesen } from '../laufwerk/ereignisse'
|
||||
import { DiscWache } from '../laufwerk/wache'
|
||||
import type { Spur } from '../rip/audiocd'
|
||||
|
||||
const GESUNDHEIT_STUNDEN = 24
|
||||
|
||||
export interface LaufwerkHorcher {
|
||||
discEingelegt(geraet: GeraeteInfo): void
|
||||
discEntnommen(geraet: GeraeteInfo): void
|
||||
}
|
||||
|
||||
export class LaufwerkDienst {
|
||||
private api: LaufwerkApi | null = null
|
||||
private wache: DiscWache | null = null
|
||||
fehler: string | null = null
|
||||
/** Das nachgebaute Laufwerk des Klick-Beweises (bau/klick-smoke.mjs): Ein
|
||||
* Buchstabe, den es nicht gibt (Q) — die Disc-Merkmale finden dann
|
||||
* nichts, und makemkvcon/HandBrake sind Node-Skripte (werkzeuge/aufruf.ts).
|
||||
* Leer im normalen Betrieb; die Win32-Schicht bleibt dann der einzige Weg. */
|
||||
readonly fake: string
|
||||
readonly bereit: Promise<void>
|
||||
|
||||
constructor(
|
||||
private readonly kontext: KernKontext,
|
||||
private readonly horcher: LaufwerkHorcher,
|
||||
/** Läuft auf diesem Laufwerk gerade ein Rip? (Auswurf wird dann abgelehnt.) */
|
||||
private readonly ripLaeuft: (id: string) => boolean,
|
||||
umgebung: NodeJS.ProcessEnv = process.env,
|
||||
) {
|
||||
this.fake = (umgebung['RIPPY_FAKE_LAUFWERK'] ?? '').replace(/:$/, '').toUpperCase()
|
||||
this.bereit = this.starten()
|
||||
}
|
||||
|
||||
private fakeGeraet(): GeraeteInfo {
|
||||
return {
|
||||
id: this.fake,
|
||||
name: `Laufwerk ${this.fake}:`,
|
||||
typ: 'bluray',
|
||||
pfad: `\\\\.\\${this.fake}:`,
|
||||
status: 'ready',
|
||||
modell: 'NACHGEBAUT (KLICK-BEWEIS)',
|
||||
seriennummer: 'KLICK',
|
||||
groesseBytes: 33_759_100_928,
|
||||
grund: '',
|
||||
}
|
||||
}
|
||||
|
||||
private wacheMeldung(meldung: { laufwerke: GeraeteInfo[]; ereignisse: WacheEreignis[] }): void {
|
||||
this.kontext.anHauptUndFenster({ art: 'laufwerke', liste: meldung.laufwerke, ereignisse: meldung.ereignisse })
|
||||
for (const ereignis of meldung.ereignisse) {
|
||||
if (ereignis.art === 'disc-eingelegt') {
|
||||
this.kontext.protokoll.schreiben(`Disc eingelegt in ${ereignis.geraet.id}: ${ereignis.geraet.typ}, ${ereignis.geraet.groesseBytes} Bytes`)
|
||||
this.horcher.discEingelegt(ereignis.geraet)
|
||||
} else if (ereignis.art === 'disc-entnommen') {
|
||||
this.kontext.protokoll.schreiben(`Disc entnommen aus ${ereignis.geraet.id}`)
|
||||
this.horcher.discEntnommen(ereignis.geraet)
|
||||
} else if (ereignis.art === 'laufwerk-weg') {
|
||||
this.kontext.protokoll.schreiben(`Laufwerk ${ereignis.id} nicht mehr da`)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private async starten(): Promise<void> {
|
||||
const wacheFehler = (fehler: unknown): void => {
|
||||
// R4: Eine gescheiterte Runde ist eine laute Zeile — der letzte
|
||||
// Stand im Fenster bleibt stehen (R2), die Wache läuft weiter.
|
||||
this.kontext.fehler(`Disc-Wache: ${String(fehler)}`)
|
||||
}
|
||||
try {
|
||||
if (this.fake.length > 0) {
|
||||
this.wache = new DiscWache(() => [this.fakeGeraet()], (m) => this.wacheMeldung(m), wacheFehler)
|
||||
this.wache.starten()
|
||||
return
|
||||
}
|
||||
if (process.platform !== 'win32') {
|
||||
throw new Error('Die Laufwerks-Schicht läuft nur unter Windows (KONZEPT § 14).')
|
||||
}
|
||||
const { win32Api } = await import('../laufwerk/win32')
|
||||
this.api = win32Api()
|
||||
this.wache = new DiscWache(
|
||||
() => listOptischeLaufwerke(this.api!).map((g) => geraeteInfo(this.api!, g)),
|
||||
(m) => this.wacheMeldung(m),
|
||||
wacheFehler,
|
||||
)
|
||||
this.wache.starten()
|
||||
} catch (fehler) {
|
||||
this.fehler = String(fehler)
|
||||
this.kontext.protokoll.schreiben(`Laufwerke: ${this.fehler}`)
|
||||
console.error(`[kern] Laufwerke: ${this.fehler}`)
|
||||
}
|
||||
}
|
||||
|
||||
aktuellerStand(): GeraeteInfo[] {
|
||||
return this.wache?.aktuellerStand() ?? []
|
||||
}
|
||||
|
||||
/** Der Geräte-Name zu einer Kennung — oder null. */
|
||||
geraetVon(id: string): string | null {
|
||||
if (this.api === null) return null
|
||||
return listOptischeLaufwerke(this.api).find((g) => kennung(g) === id) ?? null
|
||||
}
|
||||
|
||||
/** Der Geräte-Stand zu einer Kennung — echt oder nachgebaut. */
|
||||
geraetInfoVon(id: string): GeraeteInfo | null {
|
||||
if (this.fake.length > 0) return id === this.fake ? this.fakeGeraet() : null
|
||||
const geraet = this.geraetVon(id)
|
||||
if (geraet === null || this.api === null) return null
|
||||
return geraeteInfo(this.api, geraet)
|
||||
}
|
||||
|
||||
audioToc(id: string): Spur[] {
|
||||
const geraet = this.geraetVon(id)
|
||||
if (this.api === null || geraet === null) throw new Error(`Laufwerk ${id}: gibt es nicht`)
|
||||
return audioToc(this.api, geraet)
|
||||
}
|
||||
|
||||
audioSpurLesen(
|
||||
id: string,
|
||||
start: number,
|
||||
sektoren: number,
|
||||
schreiben: (daten: Buffer) => void,
|
||||
fortschritt?: (anteil: number) => void,
|
||||
): number {
|
||||
const geraet = this.geraetVon(id)
|
||||
if (this.api === null || geraet === null) throw new Error(`Laufwerk ${id}: gibt es nicht`)
|
||||
return audioSpurLesen(this.api, geraet, start, sektoren, schreiben, fortschritt)
|
||||
}
|
||||
|
||||
async auswerfen(id: string): Promise<void> {
|
||||
await this.bereit
|
||||
if (this.ripLaeuft(id)) {
|
||||
this.kontext.anFenster({
|
||||
art: 'auswurf-ergebnis',
|
||||
id,
|
||||
grund: 'abgelehnt',
|
||||
fehler: `Auf Laufwerk ${id} läuft ein Rip — erst abbrechen oder abwarten.`,
|
||||
})
|
||||
return
|
||||
}
|
||||
if (this.api === null) {
|
||||
this.kontext.anFenster({ art: 'auswurf-ergebnis', id, grund: 'kein-zugriff', fehler: this.fehler })
|
||||
return
|
||||
}
|
||||
const geraet = this.geraetVon(id)
|
||||
if (geraet === null) {
|
||||
this.kontext.anFenster({ art: 'auswurf-ergebnis', id, grund: 'kein-zugriff', fehler: `Laufwerk ${id}: gibt es nicht` })
|
||||
return
|
||||
}
|
||||
const { grund, fehler } = await auswerfenMitGrund(this.api, geraet)
|
||||
this.kontext.protokoll.schreiben(`Auswurf ${id}: ${grund}${fehler !== null ? ` (${fehler})` : ''}`)
|
||||
this.kontext.anFenster({ art: 'auswurf-ergebnis', id, grund, fehler })
|
||||
// Die Wache merkt den neuen Zustand spätestens in der nächsten Runde;
|
||||
// eine sofortige Runde macht das Fenster ohne 3-Sekunden-Wartezeit frisch.
|
||||
this.wache?.runde()
|
||||
}
|
||||
|
||||
// ── Laufwerks-Gesundheit (5.4.0, Punkt 8) ─────────────────────────────
|
||||
async pruefen(id: string): Promise<void> {
|
||||
if (process.platform !== 'win32') return
|
||||
const ergebnis = await ereignisseLesen(GESUNDHEIT_STUNDEN)
|
||||
if ('fehler' in ergebnis) {
|
||||
this.kontext.anFenster({
|
||||
art: 'laufwerk-gesundheit',
|
||||
id,
|
||||
bericht: {
|
||||
urteil: 'nicht-lesbar',
|
||||
text: `Das Windows-Protokoll ließ sich nicht lesen: ${ergebnis.fehler}`,
|
||||
fehlerhafteBloecke: 0,
|
||||
controllerfehler: 0,
|
||||
sonstige: 0,
|
||||
letzte: [],
|
||||
stunden: GESUNDHEIT_STUNDEN,
|
||||
},
|
||||
})
|
||||
return
|
||||
}
|
||||
const bericht = beurteilen(ergebnis.ereignisse, GESUNDHEIT_STUNDEN)
|
||||
this.kontext.protokoll.schreiben(`Laufwerk ${id} geprüft: ${bericht.urteil} — ${bericht.text}`)
|
||||
this.kontext.anFenster({ art: 'laufwerk-gesundheit', id, bericht })
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,87 @@
|
||||
// Freier Platz (5.5.0, Commander: „Wie viel Speicher noch auf dem Server
|
||||
// oder auf dem Arbeitsordner frei ist") — GEMESSEN am 01.09.2026 mit Node
|
||||
// 24 (Regel D): fs.statfsSync liefert für Laufwerke (C:\, F:\), Ordner
|
||||
// und UNC-Freigaben (\\192.168.178.62\rippy) bavail/bsize/blocks; ein
|
||||
// Pfad, den es nicht gibt (Q:\), wirft ENOENT. Deshalb wird zum nächsten
|
||||
// vorhandenen Elternpfad hochgegangen: Die Ablage darf noch fehlen, ihr
|
||||
// Laufwerk gibt es trotzdem.
|
||||
import { existsSync, statfsSync } from 'node:fs'
|
||||
import { dirname } from 'node:path'
|
||||
import type { SpeicherPlatz, SpeicherStand } from '../../gemeinsam/nachrichten'
|
||||
import type { KernKontext } from '../kontext'
|
||||
import type { EinstellungsDienst } from './einstellungen'
|
||||
|
||||
export type Messen = (pfad: string) => { bavail: number; bsize: number; blocks: number }
|
||||
|
||||
const echtMessen: Messen = (pfad) => {
|
||||
const s = statfsSync(pfad)
|
||||
return { bavail: Number(s.bavail), bsize: Number(s.bsize), blocks: Number(s.blocks) }
|
||||
}
|
||||
|
||||
/** Der nächste Pfad, den es gibt — der Ordner selbst, sonst sein Elternpfad. */
|
||||
export function vorhandenerPfad(pfad: string, existiert: (p: string) => boolean = existsSync): string {
|
||||
let p = pfad
|
||||
for (let i = 0; i < 40; i++) {
|
||||
if (existiert(p)) return p
|
||||
const eltern = dirname(p)
|
||||
if (eltern === p) return p
|
||||
p = eltern
|
||||
}
|
||||
return p
|
||||
}
|
||||
|
||||
export function platzMessen(pfad: string, messen: Messen = echtMessen, existiert: (p: string) => boolean = existsSync): SpeicherPlatz {
|
||||
if (pfad.trim().length === 0) return { pfad, ok: false, freiBytes: 0, gesamtBytes: 0, fehler: 'kein Pfad' }
|
||||
try {
|
||||
const s = messen(vorhandenerPfad(pfad, existiert))
|
||||
return { pfad, ok: true, freiBytes: s.bavail * s.bsize, gesamtBytes: s.blocks * s.bsize, fehler: '' }
|
||||
} catch (fehler) {
|
||||
// R2: „konnte nicht messen" ist etwas anderes als „0 frei" — das
|
||||
// Fenster zeigt den Grund, nie eine erfundene Null.
|
||||
return { pfad, ok: false, freiBytes: 0, gesamtBytes: 0, fehler: String((fehler as Error).message ?? fehler).slice(0, 120) }
|
||||
}
|
||||
}
|
||||
|
||||
export { platzUrteil } from '../../gemeinsam/platz'
|
||||
|
||||
export class SpeicherDienst {
|
||||
private zeiger: NodeJS.Timeout | null = null
|
||||
private letzter: SpeicherStand | null = null
|
||||
|
||||
constructor(
|
||||
private readonly kontext: KernKontext,
|
||||
private readonly einstellungen: EinstellungsDienst,
|
||||
private readonly messen: Messen = echtMessen,
|
||||
) {}
|
||||
|
||||
stand(): SpeicherStand {
|
||||
const arbeit = this.einstellungen.arbeitsordner()
|
||||
const ablage = this.einstellungen.ablageOrdner()
|
||||
const s: SpeicherStand = {
|
||||
arbeit: platzMessen(arbeit, this.messen),
|
||||
ablage: platzMessen(ablage, this.messen),
|
||||
getrennt: this.einstellungen.arbeitsordnerEigen().length > 0,
|
||||
}
|
||||
this.letzter = s
|
||||
return s
|
||||
}
|
||||
|
||||
letzterStand(): SpeicherStand | null {
|
||||
return this.letzter
|
||||
}
|
||||
|
||||
senden(): void {
|
||||
try {
|
||||
this.kontext.anFenster({ art: 'speicher', stand: this.stand() })
|
||||
} catch (fehler) {
|
||||
this.kontext.fehler(`Speicher messen: ${String(fehler)}`)
|
||||
}
|
||||
}
|
||||
|
||||
/** Jede Minute neu messen — ohne den Prozess-Exit aufzuhalten. */
|
||||
taktStarten(ms = 60_000): void {
|
||||
if (this.zeiger !== null) return
|
||||
this.zeiger = setInterval(() => this.senden(), ms)
|
||||
this.zeiger.unref?.()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,420 @@
|
||||
// Vorgänge (5.4.0): jeder Rip als Datensatz, die Kompressions-Warteschlange,
|
||||
// das Roh-Aufräumen, Wiederholen ab Kompression, Wiederaufnahme nach dem
|
||||
// Neustart — und seit 5.5.0: Pause, Statistik, Serien-Merker und die
|
||||
// Benachrichtigung, wenn eine Kompression zu Ende ist.
|
||||
import { existsSync, rmSync } from 'node:fs'
|
||||
import type { KompressionStand, Statistik, VorgaengeStand, VorgangEintrag } from '../../gemeinsam/nachrichten'
|
||||
import { komprimierenUndAblegen, type AblageErgebnis, type AblageUmgebung } from '../ablauf/ablegen'
|
||||
import { auftragAusJson, auftragZuJson, type KompressionsAuftrag } from '../ablauf/auftrag'
|
||||
import type { VorgangBeginn } from '../ablauf/pipeline'
|
||||
import { KompressionsWarteschlange } from '../ablauf/warteschlange'
|
||||
import {
|
||||
AUFBEWAHRUNG_SCHLUESSEL,
|
||||
aufraeumen,
|
||||
faelligAm,
|
||||
fremdeOrdner,
|
||||
istUnterRohWurzel,
|
||||
ordnerGroesse,
|
||||
regelLesen,
|
||||
regelText,
|
||||
} from '../ablage/rohaufraeumen'
|
||||
import { presetEmpfehlung } from '../../gemeinsam/preset-empfehlung'
|
||||
import type { KernKontext } from '../kontext'
|
||||
import { TmdbClient } from '../metadaten/tmdb'
|
||||
import type { Vorgang } from '../speicher/db'
|
||||
import type { BenachrichtigungsDienst } from './benachrichtigung'
|
||||
import type { EinstellungsDienst } from './einstellungen'
|
||||
import type { ErkennungDienst } from './erkennung'
|
||||
import type { WerkzeugDienst } from './werkzeuge'
|
||||
|
||||
/** Statistik aus den Vorgängen (pur). */
|
||||
export function statistikAus(liste: readonly Pick<Vorgang, 'phase' | 'rohBytes' | 'fertigBytes' | 'begonnen' | 'beendet'>[]): Statistik {
|
||||
let fertige = 0
|
||||
let rohBytes = 0
|
||||
let fertigBytes = 0
|
||||
let dauerS = 0
|
||||
for (const v of liste) {
|
||||
rohBytes += v.rohBytes
|
||||
if (v.phase !== 'fertig') continue
|
||||
fertige += 1
|
||||
fertigBytes += v.fertigBytes
|
||||
if (v.beendet !== null) {
|
||||
const d = (new Date(v.beendet).getTime() - new Date(v.begonnen).getTime()) / 1000
|
||||
if (Number.isFinite(d) && d > 0) dauerS += d
|
||||
}
|
||||
}
|
||||
return { discs: liste.length, fertige, rohBytes, fertigBytes, dauerS: Math.round(dauerS) }
|
||||
}
|
||||
|
||||
export function dateienAusJson(text: string, melden?: (grund: string) => void): string[] {
|
||||
const liste: string[] = []
|
||||
try {
|
||||
const roh: unknown = JSON.parse(text)
|
||||
if (Array.isArray(roh)) liste.push(...roh.map(String))
|
||||
} catch (fehler) {
|
||||
// R4: Ein unlesbarer Eintrag wird gesagt — und zählt als „keine
|
||||
// fertigen Dateien bekannt", womit das Aufräumen ihn nie anfasst.
|
||||
melden?.(`fertige Dateien nicht lesbar: ${String(fehler)}`)
|
||||
}
|
||||
return liste
|
||||
}
|
||||
|
||||
export class VorgangDienst {
|
||||
readonly warteschlange: KompressionsWarteschlange
|
||||
/** Nur bei einer PHASEN-Änderung in die Datenbank — nicht bei jedem Prozent-Tick. */
|
||||
private letztePhase = new Map<string, string>()
|
||||
|
||||
constructor(
|
||||
private readonly kontext: KernKontext,
|
||||
private readonly einstellungen: EinstellungsDienst,
|
||||
private readonly werkzeuge: WerkzeugDienst,
|
||||
private readonly erkennung: ErkennungDienst,
|
||||
private readonly benachrichtigung: BenachrichtigungsDienst,
|
||||
/** Nach Änderungen an Vorgängen auch den Speicher neu messen. */
|
||||
private readonly speicherSenden: () => void,
|
||||
) {
|
||||
this.warteschlange = new KompressionsWarteschlange(
|
||||
(auftrag, melden, abbruch) => komprimierenUndAblegen(auftrag, this.ablageUmgebung(), melden, abbruch),
|
||||
(stand) => this.standGeaendert(stand.laeuft),
|
||||
(auftrag, ergebnis) => this.ergebnis(auftrag, ergebnis),
|
||||
)
|
||||
}
|
||||
|
||||
private get db() {
|
||||
return this.kontext.db
|
||||
}
|
||||
|
||||
ablageUmgebung(): AblageUmgebung {
|
||||
return {
|
||||
handbrake: () => this.werkzeuge.handbrake(),
|
||||
ablage: () => this.einstellungen.ablageOrdner(),
|
||||
arbeitsordner: () => this.einstellungen.arbeitsordnerEigen(),
|
||||
einstellungen: () => this.einstellungen.fuerPipeline(),
|
||||
presetEmpfehlung: (typ) => presetEmpfehlung(typ, this.werkzeuge.auskunft.backends, this.werkzeuge.auskunft.presets),
|
||||
// Staffel-Laufzeiten von TMDb — Grundlage der Episoden-Zuordnung (§ 4.2).
|
||||
episodenLaufzeiten: async (tmdbId, staffel) => {
|
||||
const tmdb = new TmdbClient(this.einstellungen.lesen('tmdbApiKey'))
|
||||
if (!tmdb.verfuegbar) return []
|
||||
const antwort = await tmdb.tvStaffel(tmdbId, staffel)
|
||||
const paare: Array<[number, number]> = []
|
||||
for (const ep of antwort?.episodes ?? []) {
|
||||
if (typeof ep.runtime === 'number' && ep.runtime > 0) paare.push([ep.episode_number, ep.runtime * 60])
|
||||
}
|
||||
return paare
|
||||
},
|
||||
bibliothekEintragen: (eintrag) => this.bibliothekEintragen(eintrag),
|
||||
}
|
||||
}
|
||||
|
||||
bibliothekEintragen(eintrag: Parameters<NonNullable<AblageUmgebung['bibliothekEintragen']>>[0]): void {
|
||||
try {
|
||||
this.db?.bibliothekEintragen(eintrag)
|
||||
} catch (fehler) {
|
||||
// R4: Ein Bibliotheks-Fehler kippt keinen gelungenen Rip, wird aber gesagt.
|
||||
this.kontext.fehler(`Bibliothek: ${String(fehler)}`)
|
||||
}
|
||||
}
|
||||
|
||||
private standGeaendert(laeuft: KompressionStand | null): void {
|
||||
if (laeuft !== null && this.letztePhase.get(laeuft.vorgangId) !== laeuft.phase) {
|
||||
this.letztePhase.set(laeuft.vorgangId, laeuft.phase)
|
||||
this.db?.vorgangAktualisieren(laeuft.vorgangId, { phase: laeuft.phase === 'legt-ab' ? 'legt-ab' : 'komprimiert' })
|
||||
}
|
||||
this.senden()
|
||||
}
|
||||
|
||||
private async ergebnis(auftrag: KompressionsAuftrag, ergebnis: AblageErgebnis): Promise<void> {
|
||||
this.letztePhase.delete(auftrag.vorgangId)
|
||||
const jetzt = new Date().toISOString()
|
||||
this.db?.vorgangAktualisieren(auftrag.vorgangId, {
|
||||
phase: ergebnis.status,
|
||||
beendet: jetzt,
|
||||
zielOrdner: ergebnis.zielOrdner,
|
||||
fertigBytes: ergebnis.fertigBytes,
|
||||
komprimiert: ergebnis.komprimiert,
|
||||
preset: ergebnis.preset,
|
||||
fehler: ergebnis.status === 'fertig' ? '' : ergebnis.text,
|
||||
fertigeDateien: JSON.stringify(ergebnis.dateien),
|
||||
})
|
||||
const vorgang = this.db?.vorgangLesen(auftrag.vorgangId)
|
||||
const titel = vorgang?.titel ?? auftrag.vorgangId
|
||||
const text = ergebnis.text + (ergebnis.hinweise.length > 0 ? ` · ${ergebnis.hinweise.join(' · ')}` : '')
|
||||
this.kontext.protokoll.schreiben(`Kompression „${titel}": ${ergebnis.status} — ${text}`)
|
||||
this.kontext.anHauptUndFenster({
|
||||
art: 'kompression-ergebnis',
|
||||
vorgangId: auftrag.vorgangId,
|
||||
titel,
|
||||
ok: ergebnis.status === 'fertig',
|
||||
text,
|
||||
})
|
||||
// Serien-Merker (5.5.0): Mit welcher Folge geht die nächste Disc weiter?
|
||||
const tv = auftrag.zuordnung?.meta.typ === 'tv' ? auftrag.zuordnung.meta : null
|
||||
if (ergebnis.status === 'fertig' && tv !== null && tv.id !== null && ergebnis.folgenVergeben.length > 0) {
|
||||
const letzte = Math.max(...ergebnis.folgenVergeben)
|
||||
this.erkennung.serienMerkerSetzen(tv.id, auftrag.zuordnung?.titel ?? titel, auftrag.staffel ?? 1, letzte + 1)
|
||||
}
|
||||
if (ergebnis.status !== 'abgebrochen') {
|
||||
void this.benachrichtigung.senden(
|
||||
ergebnis.status === 'fertig' ? 'Rippy: fertig' : 'Rippy: Kompression fehlgeschlagen',
|
||||
`${titel}: ${ergebnis.text.slice(0, 300)}`,
|
||||
)
|
||||
}
|
||||
// Regel „sofort": direkt nach der gelungenen Kompression aufräumen.
|
||||
if (ergebnis.status === 'fertig') this.rohAufraeumenLauf()
|
||||
else this.senden()
|
||||
}
|
||||
|
||||
// ── Pipeline-Haken ──────────────────────────────────────────────────────
|
||||
vorgangBeginnt(v: VorgangBeginn): void {
|
||||
const vorgang: Vorgang = {
|
||||
id: v.id,
|
||||
laufwerk: v.laufwerk,
|
||||
typ: v.typ,
|
||||
titel: v.titel,
|
||||
jahr: v.jahr,
|
||||
phase: 'rippt',
|
||||
begonnen: v.begonnen,
|
||||
beendet: null,
|
||||
rohOrdner: v.rohOrdner,
|
||||
rohBytes: 0,
|
||||
rohGeloeschtAm: null,
|
||||
zielOrdner: '',
|
||||
fertigBytes: 0,
|
||||
komprimiert: false,
|
||||
preset: '',
|
||||
fehler: '',
|
||||
auftrag: '{}',
|
||||
lesefehler: false,
|
||||
fertigeDateien: '[]',
|
||||
}
|
||||
this.db?.vorgangAnlegen(vorgang)
|
||||
this.kontext.protokoll.schreiben(`Vorgang ${v.id} beginnt: „${v.titel}" auf ${v.laufwerk} → ${v.rohOrdner}`)
|
||||
this.senden()
|
||||
}
|
||||
|
||||
vorgangEinreihen(auftrag: KompressionsAuftrag, titel: string): number {
|
||||
this.db?.vorgangAktualisieren(auftrag.vorgangId, {
|
||||
phase: 'wartet',
|
||||
titel,
|
||||
jahr: auftrag.zuordnung?.jahr ?? null,
|
||||
rohBytes: auftrag.dateien.reduce((s, d) => s + d.groesseBytes, 0),
|
||||
lesefehler: auftrag.lesefehler,
|
||||
auftrag: auftragZuJson(auftrag),
|
||||
})
|
||||
const platz = this.warteschlange.einreihen(auftrag, titel)
|
||||
this.kontext.protokoll.schreiben(`Vorgang ${auftrag.vorgangId}: ${auftrag.dateien.length} Roh-Dateien, Kompression eingereiht (Platz ${platz})`)
|
||||
this.senden()
|
||||
return platz
|
||||
}
|
||||
|
||||
vorgangEndet(id: string, phase: 'fehler' | 'abgebrochen', text: string): void {
|
||||
this.db?.vorgangAktualisieren(id, { phase, beendet: new Date().toISOString(), fehler: text })
|
||||
this.kontext.protokoll.schreiben(`Vorgang ${id} ${phase}: ${text}`)
|
||||
this.senden()
|
||||
}
|
||||
|
||||
// ── Stand fürs Fenster ──────────────────────────────────────────────────
|
||||
stand(): VorgaengeStand {
|
||||
const regel = regelLesen(this.einstellungen.lesen(AUFBEWAHRUNG_SCHLUESSEL, ''))
|
||||
const liste = this.db?.vorgangListe() ?? []
|
||||
let rohGesamtBytes = 0
|
||||
const vorgaenge: VorgangEintrag[] = liste.map((v) => {
|
||||
const rohDa = v.rohGeloeschtAm === null && existsSync(v.rohOrdner)
|
||||
const rohBytes = rohDa ? ordnerGroesse(v.rohOrdner) : 0
|
||||
rohGesamtBytes += rohBytes
|
||||
const auftrag = auftragAusJson(v.auftrag)
|
||||
const ruhig = v.phase === 'fertig' || v.phase === 'fehler' || v.phase === 'abgebrochen'
|
||||
return {
|
||||
id: v.id,
|
||||
laufwerk: v.laufwerk,
|
||||
typ: v.typ,
|
||||
titel: v.titel,
|
||||
jahr: v.jahr,
|
||||
phase: v.phase,
|
||||
begonnen: v.begonnen,
|
||||
beendet: v.beendet,
|
||||
rohOrdner: v.rohOrdner,
|
||||
rohBytes,
|
||||
rohGeloescht: !rohDa,
|
||||
zielOrdner: v.zielOrdner,
|
||||
fertigBytes: v.fertigBytes,
|
||||
komprimiert: v.komprimiert,
|
||||
preset: v.preset,
|
||||
fehler: v.fehler,
|
||||
titelZahl: auftrag?.dateien.length ?? 0,
|
||||
neuKomprimierbar: rohDa && ruhig && auftrag !== null && auftrag.dateien.length > 0 && !this.warteschlange.kennt(v.id),
|
||||
faelligAm: v.phase === 'fertig' && v.komprimiert && rohDa ? faelligAm(v.beendet, regel) : '',
|
||||
}
|
||||
})
|
||||
const bekannte = new Set(liste.map((v) => v.rohOrdner))
|
||||
const fremde = fremdeOrdner(this.einstellungen.rohWurzel(), bekannte)
|
||||
for (const f of fremde) rohGesamtBytes += f.bytes
|
||||
return {
|
||||
vorgaenge,
|
||||
rohGesamtBytes,
|
||||
fremde,
|
||||
regel: regelText(regel),
|
||||
kompression: { ...this.warteschlange.stand(), pausiert: this.warteschlange.istPausiert() },
|
||||
statistik: statistikAus(liste),
|
||||
}
|
||||
}
|
||||
|
||||
senden(): void {
|
||||
try {
|
||||
this.kontext.anHauptUndFenster({ art: 'vorgaenge', stand: this.stand() })
|
||||
} catch (fehler) {
|
||||
this.kontext.fehler(`Vorgänge: ${String(fehler)}`)
|
||||
}
|
||||
this.speicherSenden()
|
||||
}
|
||||
|
||||
// ── Pause (5.5.0) ───────────────────────────────────────────────────────
|
||||
pause(an: boolean): void {
|
||||
this.warteschlange.pausieren(an)
|
||||
this.kontext.hinweis(an ? 'Kompression angehalten — der laufende Film wird fertig, danach wartet die Schlange.' : 'Kompression läuft weiter.')
|
||||
this.senden()
|
||||
}
|
||||
|
||||
// ── Roh-Aufräumen ───────────────────────────────────────────────────────
|
||||
rohAufraeumenLauf(): void {
|
||||
if (this.db === null) return
|
||||
try {
|
||||
const regel = regelLesen(this.einstellungen.lesen(AUFBEWAHRUNG_SCHLUESSEL, ''))
|
||||
const kandidaten = this.db.vorgangListe().map((v) => ({
|
||||
id: v.id,
|
||||
phase: v.phase,
|
||||
komprimiert: v.komprimiert,
|
||||
rohOrdner: v.rohOrdner,
|
||||
rohGeloeschtAm: v.rohGeloeschtAm,
|
||||
beendet: v.beendet,
|
||||
fertigeDateien: dateienAusJson(v.fertigeDateien, (g) => this.kontext.protokoll.schreiben(`${v.id}: ${g}`)),
|
||||
}))
|
||||
const ergebnis = aufraeumen(kandidaten, regel, new Date())
|
||||
const jetzt = new Date().toISOString()
|
||||
for (const id of ergebnis.geloescht) {
|
||||
this.db.vorgangAktualisieren(id, { rohGeloeschtAm: jetzt, rohBytes: this.db.vorgangLesen(id)?.rohBytes ?? 0 })
|
||||
this.kontext.hinweis(`Roh-Dateien von „${this.db.vorgangLesen(id)?.titel ?? id}" gelöscht (${regelText(regel)})`)
|
||||
}
|
||||
for (const f of ergebnis.fehler) this.kontext.fehler(`Roh-Ordner von ${f.id} nicht gelöscht: ${f.grund}`)
|
||||
} catch (fehler) {
|
||||
this.kontext.fehler(`Roh-Aufräumen: ${String(fehler)}`)
|
||||
}
|
||||
this.senden()
|
||||
}
|
||||
|
||||
rohLoeschen(vorgangId: string): void {
|
||||
const v = this.db?.vorgangLesen(vorgangId)
|
||||
if (v === null || v === undefined) {
|
||||
this.kontext.fehler(`Vorgang ${vorgangId}: unbekannt.`)
|
||||
return
|
||||
}
|
||||
if (v.phase === 'rippt' || v.phase === 'wartet' || v.phase === 'komprimiert' || v.phase === 'legt-ab' || this.warteschlange.kennt(vorgangId)) {
|
||||
this.kontext.fehler(`„${v.titel}" läuft noch (${v.phase}) — erst abbrechen, dann löschen.`)
|
||||
return
|
||||
}
|
||||
// Ein alter Roh-Ordner darf auch unter einer FRÜHEREN Roh-Wurzel liegen
|
||||
// (Arbeitsordner gewechselt) — geprüft wird nur, dass er ein Ordner
|
||||
// direkt unter irgendeinem roh\ ist.
|
||||
if (!/[\\/]roh[\\/][^\\/]+$/i.test(v.rohOrdner)) {
|
||||
this.kontext.fehler(`Roh-Ordner von „${v.titel}" liegt nicht unter einem roh\\-Ordner — nicht angefasst.`)
|
||||
return
|
||||
}
|
||||
try {
|
||||
rmSync(v.rohOrdner, { recursive: true, force: true })
|
||||
this.db?.vorgangAktualisieren(vorgangId, { rohGeloeschtAm: new Date().toISOString() })
|
||||
this.kontext.hinweis(`Roh-Dateien von „${v.titel}" gelöscht (von Hand).`)
|
||||
} catch (fehler) {
|
||||
this.kontext.fehler(`Roh-Ordner von „${v.titel}" nicht gelöscht: ${String(fehler)}`)
|
||||
}
|
||||
this.senden()
|
||||
}
|
||||
|
||||
fremdenOrdnerLoeschen(ordner: string): void {
|
||||
if (!istUnterRohWurzel(this.einstellungen.rohWurzel(), ordner)) {
|
||||
this.kontext.fehler(`„${ordner}" liegt nicht direkt unter ${this.einstellungen.rohWurzel()} — nicht angefasst.`)
|
||||
return
|
||||
}
|
||||
const bekannt = (this.db?.vorgangListe() ?? []).some((v) => v.rohOrdner.toLowerCase() === ordner.toLowerCase())
|
||||
if (bekannt) {
|
||||
this.kontext.fehler(`„${ordner}" gehört zu einem Vorgang — dort löschen.`)
|
||||
return
|
||||
}
|
||||
try {
|
||||
rmSync(ordner, { recursive: true, force: true })
|
||||
this.kontext.hinweis(`Ordner „${ordner}" gelöscht (von Hand).`)
|
||||
} catch (fehler) {
|
||||
this.kontext.fehler(`„${ordner}" nicht gelöscht: ${String(fehler)}`)
|
||||
}
|
||||
this.senden()
|
||||
}
|
||||
|
||||
/** „Wiederholen ab Kompression": Die Roh-Dateien liegen genau dafür da. */
|
||||
neuKomprimieren(vorgangId: string, preset: string): void {
|
||||
const v = this.db?.vorgangLesen(vorgangId)
|
||||
if (v === null || v === undefined) {
|
||||
this.kontext.fehler(`Vorgang ${vorgangId}: unbekannt.`)
|
||||
return
|
||||
}
|
||||
if (this.warteschlange.kennt(vorgangId)) {
|
||||
this.kontext.fehler(`„${v.titel}" ist schon in der Warteschlange.`)
|
||||
return
|
||||
}
|
||||
const auftrag = auftragAusJson(v.auftrag)
|
||||
if (auftrag === null) {
|
||||
this.kontext.fehler(`„${v.titel}": Der Auftrag ist nicht mehr lesbar — nur ein neuer Rip hilft.`)
|
||||
return
|
||||
}
|
||||
const vorhandene = auftrag.dateien.filter((d) => existsSync(d.pfad))
|
||||
if (vorhandene.length === 0) {
|
||||
this.kontext.fehler(`„${v.titel}": Die Roh-Dateien sind nicht mehr da (${v.rohOrdner}).`)
|
||||
return
|
||||
}
|
||||
if (vorhandene.length < auftrag.dateien.length) {
|
||||
this.kontext.hinweis(`„${v.titel}": ${auftrag.dateien.length - vorhandene.length} Roh-Datei(en) fehlen — der Rest wird komprimiert.`)
|
||||
}
|
||||
const alteFassung = v.phase === 'fertig' && v.zielOrdner.length > 0 && existsSync(v.zielOrdner)
|
||||
const neu: KompressionsAuftrag = {
|
||||
...auftrag,
|
||||
dateien: vorhandene,
|
||||
preset,
|
||||
// Die neue Fassung ersetzt die alte im selben Ordner — die alten
|
||||
// Dateien fallen erst, wenn die neuen fertig sind (ablegen.ts).
|
||||
zielOrdner: alteFassung ? v.zielOrdner : '',
|
||||
ersetzt: alteFassung ? dateienAusJson(v.fertigeDateien) : [],
|
||||
}
|
||||
this.db?.vorgangAktualisieren(vorgangId, { phase: 'wartet', fehler: '', auftrag: auftragZuJson(neu) })
|
||||
const platz = this.warteschlange.einreihen(neu, v.titel)
|
||||
this.kontext.hinweis(`„${v.titel}": Kompression eingereiht${platz > 1 ? ` (Platz ${platz})` : ''}${preset.length > 0 ? ` mit Preset „${preset}"` : ''}.`)
|
||||
this.senden()
|
||||
}
|
||||
|
||||
/** Nach einem Neustart: Was wartete noch? Was war mitten im Rip? */
|
||||
wiederaufnehmen(): void {
|
||||
if (this.db === null) return
|
||||
const jetzt = new Date().toISOString()
|
||||
for (const v of this.db.vorgangListe()) {
|
||||
if (v.phase === 'rippt') {
|
||||
this.db.vorgangAktualisieren(v.id, {
|
||||
phase: 'abgebrochen',
|
||||
beendet: jetzt,
|
||||
fehler: 'Rippy wurde beendet, bevor der Rip fertig war — die Roh-Dateien können unvollständig sein.',
|
||||
})
|
||||
this.kontext.protokoll.schreiben(`Vorgang ${v.id}: war beim letzten Beenden mitten im Rip — als abgebrochen vermerkt`)
|
||||
continue
|
||||
}
|
||||
if (v.phase === 'wartet' || v.phase === 'komprimiert' || v.phase === 'legt-ab') {
|
||||
const auftrag = auftragAusJson(v.auftrag)
|
||||
if (auftrag !== null && existsSync(v.rohOrdner) && auftrag.dateien.some((d) => existsSync(d.pfad))) {
|
||||
this.warteschlange.einreihen({ ...auftrag, dateien: auftrag.dateien.filter((d) => existsSync(d.pfad)) }, v.titel)
|
||||
this.kontext.hinweis(`„${v.titel}": Kompression nach dem Neustart wieder aufgenommen.`)
|
||||
} else {
|
||||
this.db.vorgangAktualisieren(v.id, {
|
||||
phase: 'fehler',
|
||||
beendet: jetzt,
|
||||
fehler: 'Nach dem Neustart fehlen die Roh-Dateien — die Kompression kann nicht wieder aufgenommen werden.',
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,198 @@
|
||||
// Die Werkzeuge (§ 9): wo makemkvcon, HandBrakeCLI und flac liegen, die
|
||||
// gemessenen HandBrake-Listen (Presets, Encoder), die MakeMKV-Schlüsselkette
|
||||
// (§ 9.1) samt Auswahlregel (5.4.0) und das MakeMKV-Selbst-Update.
|
||||
import type { KernNachricht } from '../../gemeinsam/nachrichten'
|
||||
import type { KernKontext } from '../kontext'
|
||||
import { finden } from '../werkzeuge/katalog'
|
||||
import type { EinstellungsDienst } from './einstellungen'
|
||||
|
||||
export type SchluesselStand = Extract<KernNachricht, { art: 'schluessel-status' }>['stand']
|
||||
|
||||
export class WerkzeugDienst {
|
||||
/** Die gemessene Auskunft bleibt liegen — die Pipeline braucht sie für die
|
||||
* Preset-Empfehlung, auch wenn gerade kein Fenster offen ist. */
|
||||
auskunft: { presets: string[]; backends: string[] } = { presets: [], backends: [] }
|
||||
schluesselStand: SchluesselStand | null = null
|
||||
private beschaffungLaeuft = false
|
||||
private installerAntwort: ((fehler: string | null) => void) | null = null
|
||||
|
||||
constructor(
|
||||
private readonly kontext: KernKontext,
|
||||
private readonly einstellungen: EinstellungsDienst,
|
||||
) {}
|
||||
|
||||
makemkvcon(): string {
|
||||
return finden('makemkv', this.einstellungen.lesen('werkzeug.makemkv'))
|
||||
}
|
||||
|
||||
handbrake(): string {
|
||||
return finden('handbrake', this.einstellungen.lesen('werkzeug.handbrake'))
|
||||
}
|
||||
|
||||
flac(): string {
|
||||
return finden('flac', this.einstellungen.lesen('werkzeug.flac'))
|
||||
}
|
||||
|
||||
/** Werkzeuge suchen, HandBrake messen, ans Fenster. */
|
||||
async senden(): Promise<void> {
|
||||
const makemkvcon = this.makemkvcon()
|
||||
const handbrake = this.handbrake()
|
||||
const flac = this.flac()
|
||||
const { encoderMessen } = await import('../komprimieren/encoder')
|
||||
const gemessen = await encoderMessen(handbrake)
|
||||
this.auskunft = { presets: gemessen.presets, backends: gemessen.backends }
|
||||
this.kontext.anFenster({
|
||||
art: 'werkzeuge',
|
||||
auskunft: { makemkvcon, handbrake, flac, presets: gemessen.presets, backends: gemessen.backends },
|
||||
})
|
||||
this.kontext.protokoll.schreiben(
|
||||
`Werkzeuge: makemkvcon=${makemkvcon || 'FEHLT'} handbrake=${handbrake || 'FEHLT'} flac=${flac || 'FEHLT'} · ${gemessen.presets.length} Presets · Encoder ${gemessen.backends.join(',') || '—'}`,
|
||||
)
|
||||
}
|
||||
|
||||
// ── MakeMKV-Schlüsselkette (§ 9.1): beim Start und täglich ──────────────
|
||||
async schluesselLauf(): Promise<void> {
|
||||
if (process.platform !== 'win32') return
|
||||
try {
|
||||
const { schluesselKette } = await import('../werkzeuge/schluessel')
|
||||
this.schluesselStand = await schluesselKette(
|
||||
this.makemkvcon(),
|
||||
this.einstellungen.lesen('makemkvAppKey'),
|
||||
new Date().toISOString(),
|
||||
)
|
||||
this.kontext.anHauptUndFenster({ art: 'schluessel-status', stand: this.schluesselStand })
|
||||
this.kontext.protokoll.schreiben(`Schlüssel: ${this.schluesselStand.text}`)
|
||||
} catch (fehler) {
|
||||
// R4: Der Schlüssel-Lauf ist Komfort — sein Scheitern wird gesagt.
|
||||
this.kontext.fehler(`Schlüsselkette: ${String(fehler)}`)
|
||||
}
|
||||
}
|
||||
|
||||
/** MakeMKVs Spur-Auswahlregel sicherstellen (5.4.0) — sonst fehlen
|
||||
* Sprachen in der Roh-Datei, die der Dialog anbot. */
|
||||
async spurauswahlLauf(): Promise<void> {
|
||||
if (process.platform !== 'win32') return
|
||||
try {
|
||||
const { spurauswahlSicherstellen } = await import('../werkzeuge/spurauswahl')
|
||||
const stand = spurauswahlSicherstellen()
|
||||
if (stand.stand === 'eigen' || stand.stand === 'fehler') {
|
||||
this.kontext.fehler(`MakeMKV-Auswahlregel: ${stand.text}`)
|
||||
} else if (stand.stand === 'gesetzt') {
|
||||
this.kontext.hinweis(stand.text)
|
||||
} else {
|
||||
this.kontext.protokoll.schreiben(stand.text)
|
||||
}
|
||||
} catch (fehler) {
|
||||
this.kontext.fehler(`MakeMKV-Auswahlregel: ${String(fehler)}`)
|
||||
}
|
||||
}
|
||||
|
||||
/** Antwort des Haupts auf 'installer-starten'. */
|
||||
installerErgebnis(fehler: string | null): void {
|
||||
this.installerAntwort?.(fehler ?? '')
|
||||
this.installerAntwort = null
|
||||
}
|
||||
|
||||
private beschaffungMelden(text: string, anteil: number | null, laeuft: boolean, fehler = false): void {
|
||||
this.kontext.anFenster({ art: 'beschaffung-status', stand: { werkzeug: 'makemkv', laeuft, text, anteil, fehler } })
|
||||
this.kontext.protokoll.schreiben(`MakeMKV-Update: ${text}`)
|
||||
}
|
||||
|
||||
// ── MakeMKV-Update (§ 9): holen, prüfen, installieren lassen ────────────
|
||||
// Der Kern lädt und PRÜFT die Datei; STARTEN kann sie nur das Haupt
|
||||
// (shell → UAC-Abfrage; der erhöhte Installer hängt dadurch nicht an der
|
||||
// Prozess-Leine und überlebt ein geschlossenes Rippy).
|
||||
async makemkvUpdateLauf(): Promise<void> {
|
||||
if (this.beschaffungLaeuft) {
|
||||
this.beschaffungMelden('Ein MakeMKV-Update läuft bereits.', null, true)
|
||||
return
|
||||
}
|
||||
this.beschaffungLaeuft = true
|
||||
try {
|
||||
const { istNeuer, makemkvNeuesteVersion, makemkvInstallerHolen, versionsangaben } = await import(
|
||||
'../werkzeuge/beschaffen'
|
||||
)
|
||||
this.beschaffungMelden('Nach der neuesten MakeMKV-Fassung wird gesucht …', null, true)
|
||||
const neueste = await makemkvNeuesteVersion()
|
||||
if (neueste.length === 0) {
|
||||
this.beschaffungMelden(
|
||||
'Keine der Quellen konnte sagen, welche Fassung aktuell ist (Hersteller-Seite, Forum, Archiv). ' +
|
||||
'Ausweg: MakeMKV von Hand von makemkv.com laden und installieren; Rippy findet es danach von allein.',
|
||||
null,
|
||||
false,
|
||||
true,
|
||||
)
|
||||
this.beschaffungLaeuft = false
|
||||
return
|
||||
}
|
||||
const installiert = this.schluesselStand?.version ?? ''
|
||||
if (installiert.length > 0 && !istNeuer(neueste, installiert)) {
|
||||
// Ehrlich bleiben (31.08.2026 gemessen: 1.18.4 ist installiert UND
|
||||
// die neueste angekündigte — die Beta ist nur abgelaufen): Ein
|
||||
// Download derselben Fassung würde nichts lösen.
|
||||
this.beschaffungMelden(
|
||||
`MakeMKV ${installiert} ist bereits die neueste angekündigte Fassung. ` +
|
||||
'Sobald der Hersteller eine neuere veröffentlicht, holt dieser Knopf sie — ' +
|
||||
'bis dahin rippt der Beta-Modus weiter.',
|
||||
null,
|
||||
false,
|
||||
)
|
||||
this.beschaffungLaeuft = false
|
||||
return
|
||||
}
|
||||
// Merken, woran eine gelungene Installation zu erkennen ist: Die
|
||||
// Versions-Ressource der gefundenen EXE ändert sich (oder es gibt
|
||||
// erstmals eine).
|
||||
const alteExe = this.makemkvcon()
|
||||
const alteVersion = alteExe.length > 0 ? versionsangaben(alteExe).version : ''
|
||||
|
||||
const ergebnis = await makemkvInstallerHolen(neueste, (text, anteil) => this.beschaffungMelden(text, anteil, true))
|
||||
this.beschaffungMelden(`Geprüft (Quelle: ${ergebnis.quelle}) — der Installer wird gestartet …`, null, true)
|
||||
|
||||
const startFehler = await new Promise<string | null>((fertig) => {
|
||||
this.installerAntwort = fertig
|
||||
process.parentPort.postMessage({ art: 'installer-starten', pfad: ergebnis.pfad })
|
||||
// Falls das Haupt nie antwortet, bleibt der Lauf nicht ewig hängen.
|
||||
setTimeout(() => fertig('Keine Antwort vom Haupt-Prozess'), 30_000).unref()
|
||||
})
|
||||
this.installerAntwort = null
|
||||
if (startFehler !== null && startFehler.length > 0) {
|
||||
this.beschaffungMelden(`Der Installer wurde nicht gestartet: ${startFehler}`, null, false, true)
|
||||
this.beschaffungLaeuft = false
|
||||
return
|
||||
}
|
||||
this.beschaffungMelden(
|
||||
`Der MakeMKV-Installer ${ergebnis.version} läuft — bitte die Windows-Nachfrage bestätigen und durchklicken. ` +
|
||||
'Rippy merkt die fertige Installation von allein und prüft den Schlüssel neu.',
|
||||
null,
|
||||
true,
|
||||
)
|
||||
// Warten, bis die Installation durch ist: Die Versions-Ressource der
|
||||
// EXE ändert sich. Alle 15 s nachsehen, höchstens 20 Minuten.
|
||||
let runden = 0
|
||||
const zeiger = setInterval(() => {
|
||||
runden += 1
|
||||
const exe = this.makemkvcon()
|
||||
const jetztVersion = exe.length > 0 ? versionsangaben(exe).version : ''
|
||||
if (jetztVersion.length > 0 && jetztVersion !== alteVersion) {
|
||||
clearInterval(zeiger)
|
||||
this.beschaffungLaeuft = false
|
||||
this.beschaffungMelden(`MakeMKV ${jetztVersion} ist installiert — der Schlüssel wird neu geprüft.`, null, false)
|
||||
void this.schluesselLauf().then(() => this.senden())
|
||||
} else if (runden >= 80) {
|
||||
clearInterval(zeiger)
|
||||
this.beschaffungLaeuft = false
|
||||
this.beschaffungMelden(
|
||||
'Die fertige Installation wurde nicht bemerkt — nach dem Durchklicken hilft „Schlüssel neu prüfen".',
|
||||
null,
|
||||
false,
|
||||
)
|
||||
}
|
||||
}, 15_000)
|
||||
zeiger.unref()
|
||||
} catch (fehler) {
|
||||
this.beschaffungMelden(fehler instanceof Error ? fehler.message : String(fehler), null, false, true)
|
||||
this.beschaffungLaeuft = false
|
||||
}
|
||||
}
|
||||
}
|
||||
+265
-1141
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,42 @@
|
||||
// Der gemeinsame Kontext der Kern-Dienste (5.5.0, Separation of Concerns):
|
||||
// Jeder Dienst bekommt genau das hier — die Datenbank, die Wege nach
|
||||
// draußen und das Protokoll — statt auf Modul-Globale zu greifen. So ist
|
||||
// jeder Dienst für sich lesbar und mit einem Fake-Kontext testbar.
|
||||
import type { DbStatus, KernNachricht } from '../gemeinsam/nachrichten'
|
||||
import type { Protokoll } from '../gemeinsam/protokoll'
|
||||
import type { Datenbank } from './speicher/db'
|
||||
|
||||
export interface KernKontext {
|
||||
/** null, wenn die Datenbank nicht zu öffnen war — der Kern läuft trotzdem (R4). */
|
||||
readonly db: Datenbank | null
|
||||
readonly dbStatus: DbStatus
|
||||
/** Nur ans Fenster (wenn eins verbunden ist). */
|
||||
anFenster(nachricht: KernNachricht): void
|
||||
/** Ans Haupt UND ans Fenster — für alles, was Tray/Taskleiste/Updater brauchen. */
|
||||
anHauptUndFenster(nachricht: KernNachricht): void
|
||||
/** Eine Zeile ohne Warnzeichen fürs Ereignis-Protokoll — und in die Datei. */
|
||||
hinweis(text: string): void
|
||||
/** Eine Zeile MIT Warnzeichen (kern-fehler) — und in die Datei. */
|
||||
fehler(text: string): void
|
||||
readonly protokoll: Protokoll
|
||||
/** Der Gerüst-Beweis (--smoke-kern): ohne Netz, ohne MakeMKV, ohne Takte. */
|
||||
readonly smoke: boolean
|
||||
}
|
||||
|
||||
/** --datenbank=<pfad> kommt vom Haupt (der Kern kennt Electrons app.getPath
|
||||
* nicht — er ist ein reiner Node-Prozess). */
|
||||
export function datenbankPfadAusArgv(argv: readonly string[]): string | null {
|
||||
for (const arg of argv) {
|
||||
if (arg.startsWith('--datenbank=')) {
|
||||
const pfad = arg.slice('--datenbank='.length)
|
||||
if (pfad.length > 0) return pfad
|
||||
}
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
/** Einstellung lesen mit Vorgabe — die eine Quelle (§ 6.7). */
|
||||
export function einstellung(kontext: Pick<KernKontext, 'db'>, schluessel: string, vorgabe = ''): string {
|
||||
const wert = kontext.db?.einstellungLesen(schluessel)
|
||||
return wert === null || wert === undefined ? vorgabe : wert
|
||||
}
|
||||
@@ -185,6 +185,22 @@ export class TmdbClient {
|
||||
})) as FilmDetails | null
|
||||
}
|
||||
|
||||
/** Poster beliebter Filme (5.5.0, Hintergrund der Erst-Einrichtung):
|
||||
* /movie/popular liefert results[].poster_path — dieselbe Form wie die
|
||||
* Suche (FilmTreffer). Zwei Seiten à 20 reichen für ein volles Raster. */
|
||||
async beliebtePoster(hoechstens = 40): Promise<string[]> {
|
||||
const pfade: string[] = []
|
||||
for (let seite = 1; seite <= 2 && pfade.length < hoechstens; seite++) {
|
||||
const daten = (await this.anfrage('movie/popular', { language: 'de-DE', page: String(seite) })) as {
|
||||
results?: FilmTreffer[]
|
||||
} | null
|
||||
for (const f of daten?.results ?? []) {
|
||||
if (typeof f.poster_path === 'string' && f.poster_path.length > 0) pfade.push(f.poster_path)
|
||||
}
|
||||
}
|
||||
return pfade.slice(0, hoechstens)
|
||||
}
|
||||
|
||||
/** Staffel-Details mit Episoden-Laufzeiten — für die Serien-Zuordnung. */
|
||||
async tvStaffel(id: number, staffel: number): Promise<{ episodes?: Array<{ episode_number: number; runtime?: number }> } | null> {
|
||||
return (await this.anfrage(`tv/${id}/season/${staffel}`, { language: 'de-DE' })) as {
|
||||
|
||||
@@ -10,6 +10,9 @@
|
||||
// MakeMKV will den Laufwerksbuchstaben. Entschieden wird nach der FORM des
|
||||
// Pfades, nicht nach dem Rechner.
|
||||
export function quelle(geraetepfad: string): string {
|
||||
// 5.5.0: Das Rettungs-Abbild ist eine ISO-Datei — makemkvcon liest sie
|
||||
// als `iso:<pfad>` (Manpage makemkvcon: „iso:<FileName>").
|
||||
if (/\.iso$/i.test(geraetepfad)) return `iso:${geraetepfad}`
|
||||
let pfad = (geraetepfad ?? '').trim()
|
||||
if (pfad.length === 0) return ''
|
||||
for (const vorsatz of ['\\\\.\\', '\\\\?\\']) {
|
||||
|
||||
@@ -0,0 +1,185 @@
|
||||
// Das Rettungs-Abbild (5.5.0, Commander: „korrupte Discs … selbst
|
||||
// reparieren, mit 0 füllen") — Rippys eigener Sektor-Leser, wie beim
|
||||
// ISO-Backup (iso.ts), aber mit Wiederholung in immer kleineren Stücken und
|
||||
// Nullen für das, was die Disc nicht mehr hergibt:
|
||||
//
|
||||
// 1 MiB am Stück → scheitert: 64-KiB-Stücke, je zwei Versuche →
|
||||
// scheitert: einzelne 2048-Byte-Sektoren, je zwei Versuche → Nullen.
|
||||
//
|
||||
// Das Ergebnis ist ein Abbild ohne Loch, das MakeMKV als `iso:` lesen kann
|
||||
// (Manpage makemkvcon; MakeMKV-FAQ „decrypted backup"): Ein genullter
|
||||
// Sektor ist für MakeMKV kein Lesefehler mehr, an dem es hängen bleibt —
|
||||
// nur eine Bildstörung von Sekundenbruchteilen an dieser Stelle. Was
|
||||
// wirklich unlesbar ist, holt niemand zurück; aber der Rest der Disc geht
|
||||
// nicht mehr verloren. Läuft NUR, wenn Rippy vorher Lesefehler gesehen
|
||||
// hat (Defekt-Wächter, Lesefehler-Meldung) — eine heile Disc braucht das
|
||||
// nicht (Commander 01.09.2026).
|
||||
//
|
||||
// PUR bis auf die injizierten Lese-/Schreibfunktionen: Die Ampel prüft die
|
||||
// Wiederholungs- und Nullfüll-Logik mit einem nachgebauten Gerät.
|
||||
import { open } from 'node:fs/promises'
|
||||
import { writeFileSync } from 'node:fs'
|
||||
|
||||
export const BLOCK_BYTES = 1024 * 1024
|
||||
export const FEIN_BYTES = 64 * 1024
|
||||
export const SEKTOR_BYTES = 2048
|
||||
|
||||
export interface UnlesbareStelle {
|
||||
offset: number
|
||||
bytes: number
|
||||
}
|
||||
|
||||
export type RettungsErgebnis =
|
||||
| { status: 'success'; bytes: number; unlesbareSektoren: number; stellen: UnlesbareStelle[] }
|
||||
| { status: 'cancelled'; bytes: number; unlesbareSektoren: number; stellen: UnlesbareStelle[] }
|
||||
| { status: 'error'; fehler: string; bytes: number; unlesbareSektoren: number; stellen: UnlesbareStelle[] }
|
||||
|
||||
/** Liest `laenge` Bytes ab `position` in `puffer` (ab 0) und liefert, wie
|
||||
* viele es wurden. Wirft bei einem Lesefehler. */
|
||||
export type Leser = (puffer: Buffer, laenge: number, position: number) => Promise<number>
|
||||
export type Schreiber = (puffer: Buffer, laenge: number) => Promise<void>
|
||||
|
||||
export interface RettungsOptionen {
|
||||
leser: Leser
|
||||
schreiber: Schreiber
|
||||
erwarteteBytes: number
|
||||
aufFortschritt?: (prozent: number, unlesbareSektoren: number, stellen: number) => void
|
||||
abbruch?: AbortSignal
|
||||
/** Versuche je Stück — Vorgabe 2. */
|
||||
versuche?: number
|
||||
}
|
||||
|
||||
async function lesenMitVersuchen(leser: Leser, puffer: Buffer, laenge: number, position: number, versuche: number): Promise<boolean> {
|
||||
for (let i = 0; i < versuche; i++) {
|
||||
try {
|
||||
const n = await leser(puffer, laenge, position)
|
||||
if (n === laenge) return true
|
||||
} catch {
|
||||
// Ein Fehler ist ein Versuch weniger — mehr sagt das Gerät nicht.
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
/** Zusammenhängende unlesbare Bereiche zu Stellen zusammenfassen (pur). */
|
||||
export function stelleHinzu(stellen: UnlesbareStelle[], offset: number, bytes: number): void {
|
||||
const letzte = stellen[stellen.length - 1]
|
||||
if (letzte !== undefined && letzte.offset + letzte.bytes === offset) {
|
||||
letzte.bytes += bytes
|
||||
return
|
||||
}
|
||||
stellen.push({ offset, bytes })
|
||||
}
|
||||
|
||||
export async function rettungsAbbild(o: RettungsOptionen): Promise<RettungsErgebnis> {
|
||||
const versuche = o.versuche ?? 2
|
||||
const puffer = Buffer.alloc(BLOCK_BYTES)
|
||||
const feinPuffer = Buffer.alloc(FEIN_BYTES)
|
||||
const sektorPuffer = Buffer.alloc(SEKTOR_BYTES)
|
||||
const stellen: UnlesbareStelle[] = []
|
||||
let unlesbareSektoren = 0
|
||||
let gelesen = 0
|
||||
let letzterProzent = -1
|
||||
const melden = (): void => {
|
||||
const prozent = o.erwarteteBytes > 0 ? Math.floor((gelesen * 100) / o.erwarteteBytes) : 0
|
||||
if (prozent !== letzterProzent) {
|
||||
letzterProzent = prozent
|
||||
o.aufFortschritt?.(prozent, unlesbareSektoren, stellen.length)
|
||||
}
|
||||
}
|
||||
if (o.erwarteteBytes <= 0) {
|
||||
return { status: 'error', fehler: 'Die Größe der Disc ist unbekannt — ohne sie gibt es kein Abbild.', bytes: 0, unlesbareSektoren, stellen }
|
||||
}
|
||||
try {
|
||||
while (gelesen < o.erwarteteBytes) {
|
||||
if (o.abbruch?.aborted === true) return { status: 'cancelled', bytes: gelesen, unlesbareSektoren, stellen }
|
||||
const n = Math.min(BLOCK_BYTES, o.erwarteteBytes - gelesen)
|
||||
if (!(await lesenMitVersuchen(o.leser, puffer, n, gelesen, 1))) {
|
||||
// Der Block klemmt — feiner lesen, nur das wirklich Kaputte nullen.
|
||||
for (let teil = 0; teil < n; teil += FEIN_BYTES) {
|
||||
const m = Math.min(FEIN_BYTES, n - teil)
|
||||
if (await lesenMitVersuchen(o.leser, feinPuffer, m, gelesen + teil, versuche)) {
|
||||
feinPuffer.copy(puffer, teil, 0, m)
|
||||
continue
|
||||
}
|
||||
for (let s = 0; s < m; s += SEKTOR_BYTES) {
|
||||
const k = Math.min(SEKTOR_BYTES, m - s)
|
||||
if (await lesenMitVersuchen(o.leser, sektorPuffer, k, gelesen + teil + s, versuche)) {
|
||||
sektorPuffer.copy(puffer, teil + s, 0, k)
|
||||
} else {
|
||||
puffer.fill(0, teil + s, teil + s + k)
|
||||
unlesbareSektoren += Math.ceil(k / SEKTOR_BYTES)
|
||||
stelleHinzu(stellen, gelesen + teil + s, k)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
await o.schreiber(puffer, n)
|
||||
gelesen += n
|
||||
melden()
|
||||
}
|
||||
} catch (fehler) {
|
||||
return { status: 'error', fehler: `Schreiben brach bei ${gelesen} Bytes ab: ${String(fehler)}`, bytes: gelesen, unlesbareSektoren, stellen }
|
||||
}
|
||||
return { status: 'success', bytes: gelesen, unlesbareSektoren, stellen }
|
||||
}
|
||||
|
||||
/** Der Bericht neben dem Abbild — Klartext für den Commander. */
|
||||
export function rettungsBericht(quelle: string, ergebnis: RettungsErgebnis, erwarteteBytes: number): string {
|
||||
const zeilen = [
|
||||
`Rettungs-Abbild von ${quelle}`,
|
||||
`Stand: ${ergebnis.status === 'success' ? 'vollständig' : ergebnis.status === 'cancelled' ? 'abgebrochen' : 'Fehler'}`,
|
||||
`Gelesen: ${ergebnis.bytes} von ${erwarteteBytes} Bytes`,
|
||||
`Unlesbare Sektoren: ${ergebnis.unlesbareSektoren} (${((ergebnis.unlesbareSektoren * SEKTOR_BYTES * 100) / Math.max(1, erwarteteBytes)).toFixed(4)} %) an ${ergebnis.stellen.length} Stellen`,
|
||||
]
|
||||
if (ergebnis.status === 'error') zeilen.push(`Fehler: ${ergebnis.fehler}`)
|
||||
for (const s of ergebnis.stellen.slice(0, 200)) zeilen.push(` ab Byte ${s.offset}: ${s.bytes} Bytes genullt`)
|
||||
if (ergebnis.stellen.length > 200) zeilen.push(` … und ${ergebnis.stellen.length - 200} weitere Stellen`)
|
||||
return zeilen.join('\n') + '\n'
|
||||
}
|
||||
|
||||
/** Vom Gerät in eine Datei — mit Bericht daneben (<ziel>.rettung.txt). */
|
||||
export async function rettungsAbbildDatei(
|
||||
geraetepfad: string,
|
||||
zielDatei: string,
|
||||
erwarteteBytes: number,
|
||||
aufFortschritt?: (prozent: number, unlesbareSektoren: number, stellen: number) => void,
|
||||
abbruch?: AbortSignal,
|
||||
): Promise<RettungsErgebnis> {
|
||||
let quelle
|
||||
try {
|
||||
quelle = await open(geraetepfad, 'r')
|
||||
} catch (fehler) {
|
||||
return { status: 'error', fehler: `Gerät nicht lesbar: ${String(fehler)}`, bytes: 0, unlesbareSektoren: 0, stellen: [] }
|
||||
}
|
||||
let ziel
|
||||
try {
|
||||
ziel = await open(zielDatei, 'w')
|
||||
} catch (fehler) {
|
||||
await quelle.close()
|
||||
return { status: 'error', fehler: `Zieldatei nicht anlegbar: ${String(fehler)}`, bytes: 0, unlesbareSektoren: 0, stellen: [] }
|
||||
}
|
||||
const q = quelle
|
||||
const z = ziel
|
||||
let ergebnis: RettungsErgebnis
|
||||
try {
|
||||
ergebnis = await rettungsAbbild({
|
||||
leser: async (puffer, laenge, position) => (await q.read(puffer, 0, laenge, position)).bytesRead,
|
||||
schreiber: async (puffer, laenge) => {
|
||||
await z.write(puffer, 0, laenge)
|
||||
},
|
||||
erwarteteBytes,
|
||||
aufFortschritt,
|
||||
abbruch,
|
||||
})
|
||||
} finally {
|
||||
await q.close()
|
||||
await z.close()
|
||||
}
|
||||
try {
|
||||
writeFileSync(`${zielDatei}.rettung.txt`, rettungsBericht(geraetepfad, ergebnis, erwarteteBytes))
|
||||
} catch {
|
||||
// Der Bericht ist Beigabe — das Abbild zählt.
|
||||
}
|
||||
return ergebnis
|
||||
}
|
||||
Reference in New Issue
Block a user