yt2jellyfin 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 h4kbas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,49 @@
-# Temporary Holding Version
+# yt2jellyfin
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+TUI: paste YouTube urls, download as MP3, fix title/artist/album/genre, upload to the Jellyfin music library, refresh the library.
+
+## Install
+
+```sh
+npm i -g yt2jellyfin
+yt2jellyfin
+```
+
+## Requirements
+
+- node >= 22, pnpm
+- `yt-dlp`, `ffmpeg` on PATH
+- the [RemoteUpload plugin](https://github.com/grandguyjs/media-upload-plugin) on the Jellyfin server
+- Jellyfin API key (Dashboard / API Keys, admin, needed for plugin upload + refresh)
+
+## From source
+
+```sh
+pnpm install
+pnpm dev
+# or
+pnpm build && node dist/index.js
+```
+
+First run opens a setup screen with prefilled defaults (jellyfin url, upload dir, yt-dlp/ffmpeg paths); enter through the fields and it writes the config. A missing or broken config file shows the same screen again.
+
+Flow: `enter` adds a url, `enter` on an empty line downloads all, then each track opens a review box. `tab`/`shift+tab` move between fields, `enter` on the last field saves tags and uploads, `esc` skips. When the queue empties the library refresh is triggered.
+
+## Config
+
+Asked in the TUI on first run, saved to `~/.config/yt2jellyfin/config.json` (mode 600). Values below are the defaults the setup screen prefills.
+
+```json
+{
+  "jellyfinUrl": "http://media.example.com:8096",
+  "jellyfinApiKey": "",
+  "jellyfinUploadDir": "/media/music/YouTube",
+  "downloadDir": "~/Music/yt2jellyfin",
+  "ytDlpPath": "yt-dlp",
+  "ffmpegPath": "ffmpeg"
+}
+```
+
+Env overrides: `YTJ_JELLYFIN_URL`, `YTJ_JELLYFIN_API_KEY`, `YTJ_JELLYFIN_UPLOAD_DIR`, `YTJ_DOWNLOAD_DIR`, `YTJ_YTDLP`, `YTJ_FFMPEG`.
+
+Uploads are chunked through the plugin API into `jellyfinUploadDir` (server-side path inside the Jellyfin music library; the app sets the plugin's upload dir to it). Files never need ssh/scp.

package/dist/app.js

@@ -0,0 +1,310 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRef, useState } from 'react';
+import { useEffect } from 'react';
+import { Box, Text, useApp, useInput } from 'ink';
+import TextInput from 'ink-text-input';
+import { loadConfig, saveConfig } from './config.js';
+import { downloadTrack } from './ytdlp.js';
+import { applyTags } from './media.js';
+import { refreshLibrary, uploadToServer } from './jellyfin.js';
+const SETUP_FIELDS = [
+    { key: 'jellyfinUrl', label: 'Jellyfin url' },
+    { key: 'jellyfinApiKey', label: 'API key', secret: true },
+    { key: 'jellyfinUploadDir', label: 'Server dir' },
+    { key: 'downloadDir', label: 'Download dir' },
+    { key: 'ytDlpPath', label: 'yt-dlp' },
+    { key: 'ffmpegPath', label: 'ffmpeg' },
+];
+const FIELD_ORDER = ['title', 'artist', 'album', 'genre'];
+const FIELD_LABELS = {
+    title: 'Title',
+    artist: 'Artist',
+    album: 'Album',
+    genre: 'Genre',
+};
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function statusIcon(status) {
+    if (status === 'uploaded')
+        return '[ok]';
+    if (status === 'error')
+        return '[!!]';
+    if (status === 'downloading' || status === 'uploading')
+        return '[..]';
+    return '[ ]';
+}
+function statusColor(status) {
+    if (status === 'uploaded')
+        return 'green';
+    if (status === 'error')
+        return 'red';
+    if (status === 'downloading' || status === 'uploading')
+        return 'yellow';
+    return undefined;
+}
+function statusText(item) {
+    if (item.status === 'downloading') {
+        return item.progress ? `downloading ${item.progress}` : 'downloading';
+    }
+    if (item.status === 'error')
+        return `failed: ${item.error ?? 'unknown error'}`;
+    if (item.status === 'downloaded')
+        return 'ready to tag';
+    return item.status;
+}
+function defaults(meta, file) {
+    const base = file.split('/').pop() ?? file;
+    const title = (meta.track || meta.title || base.replace(/\.mp3$/i, '')).trim();
+    const artist = (meta.artist || meta.channel || meta.uploader || '').trim();
+    return {
+        title,
+        artist,
+        album: (meta.album ?? '').trim(),
+        genre: (meta.genre ?? '').trim(),
+    };
+}
+export function App() {
+    const loaded = useRef(loadConfig()).current;
+    const { exit } = useApp();
+    const [config, setConfig] = useState(loaded.config);
+    const cfg = config;
+    const [phase, setPhase] = useState(loaded.needsSetup ? 'setup' : 'urls');
+    const [draft, setDraft] = useState(loaded.config);
+    const [setupIndex, setSetupIndex] = useState(0);
+    const [items, setItems] = useState([]);
+    const [input, setInput] = useState('');
+    const [message, setMessage] = useState('');
+    const [reviewIndex, setReviewIndex] = useState(0);
+    const [fieldIndex, setFieldIndex] = useState(0);
+    const [busy, setBusy] = useState(false);
+    const urlsRef = useRef([]);
+    const busyRef = useRef(false);
+    // Mirror of the items state kept in a ref so async steps read fresh statuses
+    // without waiting for React to commit the last batched update.
+    const itemsRef = useRef(items);
+    function commit(next) {
+        itemsRef.current = next;
+        setItems(next);
+    }
+    function updateItem(index, patch) {
+        commit(itemsRef.current.map((item, i) => (i === index ? { ...item, ...patch } : item)));
+    }
+    function start() {
+        if (itemsRef.current.length === 0) {
+            setMessage('paste a youtube url first');
+            return;
+        }
+        urlsRef.current = itemsRef.current.map((item) => item.url);
+        setMessage('');
+        commit(itemsRef.current.map((item) => ({
+            ...item,
+            status: 'queued',
+            progress: '',
+            error: undefined,
+        })));
+        setPhase('downloading');
+    }
+    function submitSetup(index) {
+        if (index < SETUP_FIELDS.length - 1) {
+            setSetupIndex(index + 1);
+            return;
+        }
+        const next = {
+            jellyfinUrl: draft.jellyfinUrl.trim().replace(/\/+$/, ''),
+            jellyfinApiKey: draft.jellyfinApiKey.trim(),
+            jellyfinUploadDir: draft.jellyfinUploadDir.trim(),
+            downloadDir: draft.downloadDir.trim(),
+            ytDlpPath: draft.ytDlpPath.trim() || 'yt-dlp',
+            ffmpegPath: draft.ffmpegPath.trim() || 'ffmpeg',
+        };
+        if (!/^https?:\/\//i.test(next.jellyfinUrl)) {
+            setMessage('jellyfin url must start with http:// or https://');
+            setSetupIndex(0);
+            return;
+        }
+        if (next.jellyfinApiKey.length === 0) {
+            setMessage('api key is required');
+            setSetupIndex(1);
+            return;
+        }
+        if (next.jellyfinUploadDir.length === 0 || next.downloadDir.length === 0) {
+            setMessage('upload and download dirs cannot be empty');
+            return;
+        }
+        try {
+            saveConfig(next);
+            setConfig(next);
+            setDraft(next);
+            setMessage(`config saved to ${loaded.path}`);
+            setPhase('urls');
+        }
+        catch (error) {
+            setMessage(`could not save config: ${errorMessage(error)}`);
+        }
+    }
+    function submitUrls(value) {
+        const tokens = value.split(/\s+/).filter(Boolean);
+        const urls = tokens.filter((token) => /^https?:\/\//i.test(token));
+        if (urls.length === 0) {
+            if (tokens.length === 0 && itemsRef.current.length > 0) {
+                start();
+            }
+            else {
+                setMessage('not a url: paste a youtube link');
+            }
+            return;
+        }
+        const fresh = urls.filter((url) => !itemsRef.current.some((item) => item.url === url));
+        if (fresh.length === 0) {
+            setMessage('url already in the list');
+            return;
+        }
+        commit([
+            ...itemsRef.current,
+            ...fresh.map((url) => ({
+                url,
+                status: 'queued',
+                progress: '',
+                title: '',
+                artist: '',
+                album: '',
+                genre: '',
+            })),
+        ]);
+        setInput('');
+        setMessage('');
+    }
+    useEffect(() => {
+        if (phase !== 'downloading')
+            return;
+        let cancelled = false;
+        void (async () => {
+            for (let i = 0; i < urlsRef.current.length && !cancelled; i++) {
+                updateItem(i, { status: 'downloading', progress: '', error: undefined });
+                try {
+                    const { file, meta } = await downloadTrack(cfg, urlsRef.current[i], (percent) => {
+                        updateItem(i, { progress: percent });
+                    });
+                    updateItem(i, { status: 'downloaded', file, ...defaults(meta, file) });
+                }
+                catch (error) {
+                    updateItem(i, { status: 'error', error: errorMessage(error) });
+                }
+            }
+            if (cancelled)
+                return;
+            const first = itemsRef.current.findIndex((item) => item.status === 'downloaded');
+            if (first === -1) {
+                setMessage('nothing downloaded');
+                setPhase('done');
+                return;
+            }
+            setReviewIndex(first);
+            setFieldIndex(0);
+            setPhase('review');
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [phase]);
+    async function advance(from) {
+        const next = itemsRef.current.findIndex((item, i) => i > from && item.status === 'downloaded');
+        if (next !== -1) {
+            setReviewIndex(next);
+            setFieldIndex(0);
+            return;
+        }
+        try {
+            await refreshLibrary(cfg);
+            setMessage('upload done, library scan started');
+        }
+        catch (error) {
+            setMessage(`upload done, refresh failed: ${errorMessage(error)}`);
+        }
+        setPhase('done');
+    }
+    async function acceptAndUpload() {
+        if (busyRef.current)
+            return;
+        const index = reviewIndex;
+        const item = itemsRef.current[index];
+        if (!item || item.status !== 'downloaded' || !item.file)
+            return;
+        const values = {
+            title: item.title.trim(),
+            artist: item.artist.trim(),
+            album: item.album.trim(),
+            genre: item.genre.trim(),
+        };
+        if (values.title.length === 0) {
+            setMessage('title cannot be empty');
+            return;
+        }
+        busyRef.current = true;
+        setBusy(true);
+        setMessage('');
+        updateItem(index, { status: 'uploading' });
+        try {
+            const tagged = await applyTags(cfg, item.file, values);
+            updateItem(index, { file: tagged });
+            await uploadToServer(cfg, tagged);
+            updateItem(index, { status: 'uploaded' });
+            await advance(index);
+        }
+        catch (error) {
+            updateItem(index, { status: 'error', error: errorMessage(error) });
+            await advance(index);
+        }
+        finally {
+            busyRef.current = false;
+            setBusy(false);
+        }
+    }
+    function submitField(index) {
+        if (index < FIELD_ORDER.length - 1) {
+            setFieldIndex(index + 1);
+        }
+        else {
+            void acceptAndUpload();
+        }
+    }
+    useInput((_input, key) => {
+        if (phase === 'done') {
+            if (key.return || key.escape)
+                exit();
+            return;
+        }
+        if (phase === 'setup') {
+            if (key.tab) {
+                const delta = key.shift ? -1 : 1;
+                setSetupIndex((prev) => (prev + delta + SETUP_FIELDS.length) % SETUP_FIELDS.length);
+            }
+            return;
+        }
+        if (phase !== 'review')
+            return;
+        if (key.tab) {
+            const delta = key.shift ? -1 : 1;
+            setFieldIndex((prev) => (prev + delta + FIELD_ORDER.length) % FIELD_ORDER.length);
+            return;
+        }
+        if (key.escape) {
+            const item = itemsRef.current[reviewIndex];
+            if (!item || item.status !== 'downloaded')
+                return;
+            updateItem(reviewIndex, { status: 'error', error: 'skipped' });
+            void advance(reviewIndex);
+        }
+    });
+    const current = items[reviewIndex];
+    const uploaded = items.filter((item) => item.status === 'uploaded').length;
+    const failed = items.filter((item) => item.status === 'error').length;
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, color: "cyan", children: "yt2jellyfin" }), _jsxs(Text, { dimColor: true, children: ['  ', cfg.jellyfinUrl, ' · ', cfg.jellyfinUploadDir] })] }), _jsxs(Text, { dimColor: true, children: ["config ", loaded.path] }), phase !== 'setup' && !cfg.jellyfinApiKey && (_jsx(Text, { color: "yellow", children: "jellyfin api key missing: set YTJ_JELLYFIN_API_KEY or edit the config file" })), phase === 'setup' ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { children: "first run: check the jellyfin settings, defaults are prefilled" }), SETUP_FIELDS.map((field, index) => (_jsxs(Box, { children: [_jsx(Box, { width: 15, children: _jsx(Text, { color: index === setupIndex ? 'green' : undefined, children: field.label }) }), index === setupIndex ? (_jsx(TextInput, { value: draft[field.key], mask: field.secret ? '*' : undefined, onChange: (value) => setDraft((prev) => ({ ...prev, [field.key]: value })), onSubmit: () => submitSetup(index) })) : (_jsx(Text, { dimColor: draft[field.key].length === 0, children: field.secret && draft[field.key].length > 0
+                                    ? '*'.repeat(8)
+                                    : draft[field.key] || '-' }))] }, field.key))), _jsx(Text, { dimColor: true, children: "tab/shift+tab moves field \u00B7 enter saves on the last field" })] })) : phase === 'urls' ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [items.map((item, index) => (_jsxs(Text, { children: [index + 1, ". ", item.url] }, item.url))), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "green", children: "url " }), _jsx(TextInput, { value: input, onChange: setInput, onSubmit: submitUrls, placeholder: "https://www.youtube.com/watch?v=..." })] }), _jsx(Text, { dimColor: true, children: "enter adds url \u00B7 enter on empty line downloads all \u00B7 ctrl+c quits" })] })) : (_jsx(Box, { flexDirection: "column", marginTop: 1, children: items.map((item, index) => (_jsxs(Text, { color: statusColor(item.status), children: [statusIcon(item.status), " ", index + 1, ". ", item.title || item.url, _jsxs(Text, { dimColor: true, children: ['  ', statusText(item)] })] }, item.url))) })), phase === 'review' && current && current.status !== 'uploaded' && (_jsxs(Box, { flexDirection: "column", marginTop: 1, borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { dimColor: true, children: current.url }), FIELD_ORDER.map((name, index) => (_jsxs(Box, { children: [_jsx(Box, { width: 9, children: _jsx(Text, { color: index === fieldIndex ? 'green' : undefined, children: FIELD_LABELS[name] }) }), index === fieldIndex && current.status === 'downloaded' ? (_jsx(TextInput, { value: current[name], onChange: (value) => updateItem(reviewIndex, { [name]: value }), onSubmit: () => submitField(index) })) : (_jsx(Text, { dimColor: current[name].length === 0, children: current[name] || '-' }))] }, name))), _jsx(Text, { dimColor: true, children: current.status === 'uploading'
+                            ? 'uploading...'
+                            : busy
+                                ? 'refreshing library...'
+                                : 'tab/shift+tab moves field · enter saves and uploads · esc skips track' })] })), phase === 'done' && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: ["uploaded ", uploaded, " \u00B7 failed ", failed] }) })), message.length > 0 && _jsx(Text, { color: "yellow", children: message }), phase === 'done' && _jsx(Text, { dimColor: true, children: "enter exits" })] }));
+}

package/dist/config.js

@@ -0,0 +1,51 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+const CONFIG_PATH = join(homedir(), '.config', 'yt2jellyfin', 'config.json');
+const DEFAULT_CONFIG = {
+    jellyfinUrl: 'http://media.example.com:8096',
+    jellyfinApiKey: '',
+    jellyfinUploadDir: '/media/music/YouTube',
+    downloadDir: join(homedir(), 'Music', 'yt2jellyfin'),
+    ytDlpPath: 'yt-dlp',
+    ffmpegPath: 'ffmpeg',
+};
+const ENV_OVERRIDES = {
+    YTJ_JELLYFIN_URL: 'jellyfinUrl',
+    YTJ_JELLYFIN_API_KEY: 'jellyfinApiKey',
+    YTJ_JELLYFIN_UPLOAD_DIR: 'jellyfinUploadDir',
+    YTJ_DOWNLOAD_DIR: 'downloadDir',
+    YTJ_YTDLP: 'ytDlpPath',
+    YTJ_FFMPEG: 'ffmpegPath',
+};
+export function saveConfig(config) {
+    mkdirSync(dirname(CONFIG_PATH), { recursive: true });
+    mkdirSync(config.downloadDir, { recursive: true });
+    writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n');
+    chmodSync(CONFIG_PATH, 0o600);
+}
+export function loadConfig() {
+    let needsSetup = false;
+    let stored = {};
+    if (!existsSync(CONFIG_PATH)) {
+        needsSetup = true;
+    }
+    else {
+        try {
+            stored = JSON.parse(readFileSync(CONFIG_PATH, 'utf8'));
+        }
+        catch {
+            // broken/empty config: ask again with defaults instead of crashing
+            stored = {};
+            needsSetup = true;
+        }
+    }
+    const config = { ...DEFAULT_CONFIG, ...stored };
+    for (const [envKey, configKey] of Object.entries(ENV_OVERRIDES)) {
+        const value = process.env[envKey];
+        if (typeof value === 'string' && value.length > 0) {
+            config[configKey] = value;
+        }
+    }
+    return { config, path: CONFIG_PATH, needsSetup };
+}

package/dist/index.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink';
+import { App } from './app.js';
+render(_jsx(App, {}));

package/dist/jellyfin.js

@@ -0,0 +1,85 @@
+import { readFile } from 'node:fs/promises';
+import { basename } from 'node:path';
+// RemoteUpload plugin: https://github.com/grandguyjs/media-upload-plugin
+const REMOTE_UPLOAD_PLUGIN_ID = 'b5a2d6b3-c5f4-4f88-aed4-5f3e9877d0a6';
+// The plugin's own client uploads 28MB chunks; keep the same size so a reverse
+// proxy sized for it (30MB body) also works here.
+const UPLOAD_CHUNK_SIZE = 28 * 1024 * 1024;
+function apiUrl(cfg, path) {
+    return `${cfg.jellyfinUrl.replace(/\/+$/, '')}${path}`;
+}
+function authHeaders(cfg) {
+    return { 'X-Emby-Token': cfg.jellyfinApiKey };
+}
+function requireApiKey(cfg) {
+    if (!cfg.jellyfinApiKey) {
+        throw new Error('Jellyfin API key is empty: set YTJ_JELLYFIN_API_KEY or add jellyfinApiKey to the config file');
+    }
+}
+// The plugin always writes into one configured server directory, so point it at
+// the music library before uploading (first run and after a dir change).
+async function ensureUploadDir(cfg) {
+    if (cfg.jellyfinUploadDir.trim().length === 0) {
+        throw new Error('Jellyfin upload dir is empty: set YTJ_JELLYFIN_UPLOAD_DIR or add jellyfinUploadDir to the config file');
+    }
+    const url = apiUrl(cfg, `/Plugins/${REMOTE_UPLOAD_PLUGIN_ID}/Configuration`);
+    const current = await fetch(url, { headers: authHeaders(cfg) });
+    if (!current.ok) {
+        throw new Error(`RemoteUpload plugin config read failed (${current.status}): is the plugin installed?`);
+    }
+    const configuration = (await current.json());
+    if (configuration.uploaddir === cfg.jellyfinUploadDir)
+        return;
+    const dirs = Array.isArray(configuration.uploaddirs) ? configuration.uploaddirs : [];
+    if (!dirs.includes(cfg.jellyfinUploadDir))
+        dirs.push(cfg.jellyfinUploadDir);
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: { ...authHeaders(cfg), 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            ...configuration,
+            uploaddir: cfg.jellyfinUploadDir,
+            uploaddirs: dirs,
+        }),
+    });
+    if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`RemoteUpload dir update failed (${response.status}): ${body}`);
+    }
+}
+export async function uploadToServer(cfg, file) {
+    requireApiKey(cfg);
+    await ensureUploadDir(cfg);
+    const name = basename(file);
+    const data = await readFile(file);
+    const totalChunks = Math.max(1, Math.ceil(data.byteLength / UPLOAD_CHUNK_SIZE));
+    for (let chunkIndex = 0; chunkIndex < totalChunks; chunkIndex++) {
+        const start = chunkIndex * UPLOAD_CHUNK_SIZE;
+        const chunk = data.subarray(start, start + UPLOAD_CHUNK_SIZE);
+        const form = new FormData();
+        form.append('file', new Blob([chunk], { type: 'audio/mpeg' }), name);
+        form.append('chunkIndex', String(chunkIndex));
+        form.append('totalChunks', String(totalChunks));
+        const response = await fetch(apiUrl(cfg, '/mediaupload/upload'), {
+            method: 'POST',
+            headers: authHeaders(cfg),
+            body: form,
+        });
+        if (!response.ok) {
+            const body = await response.text();
+            throw new Error(`upload failed (${response.status}): ${body}`);
+        }
+    }
+}
+export async function refreshLibrary(cfg) {
+    requireApiKey(cfg);
+    const url = apiUrl(cfg, '/Library/Refresh');
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: authHeaders(cfg),
+    });
+    if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`jellyfin refresh failed (${response.status}): ${body}`);
+    }
+}

package/dist/media.js

@@ -0,0 +1,52 @@
+import { execFile } from 'node:child_process';
+import { rename, rm } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+export function sanitizeFileName(name) {
+    const cleaned = name
+        .replace(/[\\/:*?"<>|]/g, ' ')
+        .replace(/[\u0000-\u001f\u007f]/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .replace(/[. ]+$/, '');
+    return cleaned.slice(0, 150).trim() || 'track';
+}
+export function trackFileName(title, artist) {
+    const safeTitle = sanitizeFileName(title);
+    const safeArtist = artist.trim().length > 0 ? sanitizeFileName(artist) : '';
+    return safeArtist.length > 0 ? `${safeArtist} - ${safeTitle}.mp3` : `${safeTitle}.mp3`;
+}
+// Rewrites the mp3 tags so Jellyfin does not index YouTube junk (video title as
+// title, channel name as artist, description/purl as extra metadata).
+export async function applyTags(cfg, file, values) {
+    const target = join(dirname(file), trackFileName(values.title, values.artist));
+    const temp = `${file}.tagged.mp3`;
+    const args = [
+        '-y',
+        '-i',
+        file,
+        '-map',
+        '0',
+        '-c',
+        'copy',
+        '-map_metadata',
+        '-1',
+        '-metadata',
+        `title=${values.title}`,
+        '-metadata',
+        `artist=${values.artist}`,
+    ];
+    if (values.album.trim().length > 0) {
+        args.push('-metadata', `album=${values.album}`);
+    }
+    if (values.genre.trim().length > 0) {
+        args.push('-metadata', `genre=${values.genre}`);
+    }
+    await execFileAsync(cfg.ffmpegPath, [...args, temp]);
+    if (resolve(target) !== resolve(file)) {
+        await rm(file, { force: true });
+    }
+    await rename(temp, target);
+    return target;
+}

package/dist/ytdlp.js

@@ -0,0 +1,84 @@
+import { spawn } from 'node:child_process';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { createInterface } from 'node:readline';
+const META_PREFIX = '__META__';
+const FILE_PREFIX = '__FILE__';
+const PROGRESS_PREFIX = '__PROG__';
+function expandHome(file) {
+    if (file === '~')
+        return homedir();
+    if (file.startsWith('~/'))
+        return join(homedir(), file.slice(2));
+    return file;
+}
+export function downloadTrack(cfg, url, onProgress) {
+    return new Promise((resolvePromise, rejectPromise) => {
+        const args = [
+            '--no-playlist',
+            '--newline',
+            '--no-warnings',
+            '--print',
+            `before_dl:${META_PREFIX}%(.{id,title,artist,album,genre,track,uploader,channel})j`,
+            '--progress-template',
+            `download:${PROGRESS_PREFIX}%(progress._percent_str)s`,
+            '--print',
+            `after_move:${FILE_PREFIX}%(filepath)s`,
+            '-x',
+            '--audio-format',
+            'mp3',
+            '--audio-quality',
+            '0',
+            '--embed-metadata',
+            '--embed-thumbnail',
+            '-o',
+            '%(id)s.%(ext)s',
+            url,
+        ];
+        const child = spawn(cfg.ytDlpPath, args, {
+            cwd: cfg.downloadDir,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const meta = {};
+        let file = '';
+        let stderr = '';
+        const stdout = createInterface({ input: child.stdout });
+        stdout.on('line', (line) => {
+            if (line.startsWith(META_PREFIX)) {
+                try {
+                    Object.assign(meta, JSON.parse(line.slice(META_PREFIX.length)));
+                }
+                catch {
+                    // keep going with whatever yt-dlp gave us
+                }
+                return;
+            }
+            if (line.startsWith(FILE_PREFIX)) {
+                file = line.slice(FILE_PREFIX.length).trim();
+                return;
+            }
+            if (line.startsWith(PROGRESS_PREFIX)) {
+                onProgress(line.slice(PROGRESS_PREFIX.length).trim());
+            }
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr = (stderr + chunk.toString()).slice(-4000);
+        });
+        child.on('error', (error) => {
+            rejectPromise(new Error(`failed to run ${cfg.ytDlpPath}: ${error.message}`));
+        });
+        child.on('close', (code) => {
+            if (code !== 0) {
+                rejectPromise(new Error(stderr.trim() || `yt-dlp exited with code ${code}`));
+                return;
+            }
+            const guessed = meta.id ? resolve(cfg.downloadDir, `${meta.id}.mp3`) : '';
+            const result = file ? resolve(expandHome(file)) : guessed;
+            if (!result) {
+                rejectPromise(new Error('yt-dlp finished but no output file was reported'));
+                return;
+            }
+            resolvePromise({ file: result, meta });
+        });
+    });
+}

package/package.json

@@ -1,6 +1,44 @@
 {
   "name": "yt2jellyfin",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "Paste a YouTube URL, download MP3, clean tags, upload to Jellyfin",
+  "type": "module",
+  "bin": {
+    "yt2jellyfin": "./dist/index.js"
+  },
+  "scripts": {
+    "dev": "tsx src/index.tsx",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "ink": "^8.0.0",
+    "ink-text-input": "^6.0.0",
+    "react": "^19.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.6",
+    "@types/react": "^19.3.0",
+    "tsx": "^4.23.15",
+    "typescript": "^5.9.3"
+  },
+  "author": "h4kbas",
+  "keywords": [
+    "jellyfin",
+    "youtube",
+    "yt-dlp",
+    "mp3",
+    "tui",
+    "ink",
+    "cli"
+  ],
+  "files": [
+    "dist"
+  ]
+}