mediatuna 1.21.11

package/lib/stamp-dates.js

@@ -0,0 +1,468 @@
+import fs from 'fs';
+import path from 'path';
+import { padEnd } from './format.js';
+import { isStandardDatedName, normalizeDatedBasename, parseFilenameDate, filenameStampPrefix } from './filename-dates.js';
+import { readFileTimes, applyFileTimes, repairCreatedIfMoved } from './timestamps.js';
+
+export const STAMP_PREFIX_RE = /^((?:MTIME_)?\d{4}-\d{2}-\d{2}(?:_\d{2}-\d{2}-\d{2}Z?|_\d{6}Z?)?)(?:_|\.|$)/;
+
+const ISO_RE = /^(\d{4})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2}):(\d{2})(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?)?$/i;
+
+export function parseCreationDate(value) {
+    if (value == null) return null;
+    const raw = String(value).trim();
+    if (!raw || raw === 'N/A') return null;
+
+    const match = raw.match(ISO_RE);
+    if (match) {
+        const [, year, month, day, hour, minute, second] = match;
+        return {
+            year,
+            month,
+            day,
+            hour: hour ?? '00',
+            minute: minute ?? '00',
+            second: second ?? '00',
+            hasTime: hour != null,
+        };
+    }
+
+    if (/^\d{4}$/.test(raw)) return null;
+
+    const parsed = new Date(raw);
+    if (Number.isNaN(parsed.getTime())) return null;
+    const hasTime = /T\d{2}:/.test(raw) || /\d{2}:\d{2}:\d{2}/.test(raw);
+    if (!hasTime && !/^\d{4}[-/]\d{2}[-/]\d{2}/.test(raw)) return null;
+    return fromUtcDate(parsed, hasTime);
+}
+
+function fromUtcDate(date, hasTime) {
+    return {
+        year: String(date.getUTCFullYear()).padStart(4, '0'),
+        month: String(date.getUTCMonth() + 1).padStart(2, '0'),
+        day: String(date.getUTCDate()).padStart(2, '0'),
+        hour: String(date.getUTCHours()).padStart(2, '0'),
+        minute: String(date.getUTCMinutes()).padStart(2, '0'),
+        second: String(date.getUTCSeconds()).padStart(2, '0'),
+        hasTime,
+    };
+}
+
+function fromLocalDate(date, hasTime) {
+    return {
+        year: String(date.getFullYear()).padStart(4, '0'),
+        month: String(date.getMonth() + 1).padStart(2, '0'),
+        day: String(date.getDate()).padStart(2, '0'),
+        hour: String(date.getHours()).padStart(2, '0'),
+        minute: String(date.getMinutes()).padStart(2, '0'),
+        second: String(date.getSeconds()).padStart(2, '0'),
+        hasTime,
+    };
+}
+
+export function formatStampPrefix(parsed, { source = 'creation_time' } = {}) {
+    if (!parsed) return null;
+    const date = `${parsed.year}-${parsed.month}-${parsed.day}`;
+    const clock = parsed.hasTime
+        ? `_${parsed.hour}-${parsed.minute}-${parsed.second}${source === 'creation_time' ? 'Z' : ''}`
+        : '';
+    const tag = source === 'mtime' ? 'MTIME_' : '';
+    return `${tag}${date}${clock}`;
+}
+
+export function existingStampPrefix(basename) {
+    const match = basename.match(STAMP_PREFIX_RE);
+    return match ? match[1] : null;
+}
+
+export function buildStampedName(basename, prefix) {
+    const current = existingStampPrefix(basename);
+    if (current === prefix) return basename;
+    if (current) return null;
+    return `${prefix}_${basename}`;
+}
+
+/** Keep an existing date prefix; add one only when the name has none and metadata has a date. */
+export function stampedOutputStem(basename, meta, { preferMtime = false } = {}) {
+    const normalized = normalizeDatedBasename(basename);
+    if (normalized !== basename) {
+        return path.basename(normalized, path.extname(normalized));
+    }
+    const stem = path.basename(basename, path.extname(basename));
+    if (isStandardDatedName(basename)) return stem;
+    const resolved = resolveStampDate(meta, { preferMtime });
+    if (!resolved.parsed) return stem;
+    const prefix = formatStampPrefix(resolved.parsed, { source: resolved.source });
+    const stamped = buildStampedName(basename, prefix);
+    if (!stamped) return stem;
+    return path.basename(stamped, path.extname(stamped));
+}
+
+export function resolveStampDate(meta, { preferMtime = false } = {}) {
+    const fromTag = parseCreationDate(meta?.creation_time);
+    if (fromTag) {
+        return { parsed: fromTag, source: 'creation_time', raw: meta.creation_time };
+    }
+
+    if (preferMtime && meta?.modified_time) {
+        const dt = new Date(meta.modified_time);
+        if (!Number.isNaN(dt.getTime())) {
+            return { parsed: fromLocalDate(dt, true), source: 'mtime', raw: meta.modified_time };
+        }
+    }
+
+    return { parsed: null, source: null, raw: meta?.creation_time ?? null };
+}
+
+function backupRelPath(input, rootDir) {
+    if (rootDir) {
+        const rel = path.relative(rootDir, input);
+        if (rel && !rel.startsWith('..') && !path.isAbsolute(rel)) return rel;
+    }
+    return path.basename(input);
+}
+
+export function planStampRenames(files, {
+    probeFn,
+    preferMtime = false,
+    rootDir = null,
+} = {}) {
+    if (typeof probeFn !== 'function') {
+        throw new Error('planStampRenames requires probeFn');
+    }
+
+    const plannedDest = new Map();
+    const plans = [];
+
+    for (const input of files) {
+        const basename = path.basename(input);
+        const dir = path.dirname(input);
+        let meta;
+        try {
+            meta = probeFn(input);
+        } catch (err) {
+            plans.push({
+                input,
+                output: null,
+                action: 'error',
+                reason: `probe failed: ${err.message}`,
+                created: null,
+                source: null,
+                stamp: null,
+                backupRel: backupRelPath(input, rootDir),
+            });
+            continue;
+        }
+
+        const fromName = parseFilenameDate(basename);
+        const normalized = normalizeDatedBasename(basename);
+        if (fromName && normalized !== basename) {
+            const stamp = filenameStampPrefix(fromName.parsed, {
+                z: fromName.hasZ,
+                mtime: fromName.source === 'mtime',
+            });
+            const output = path.join(dir, normalized);
+            const destKey = path.resolve(output);
+            if (plannedDest.has(destKey)) {
+                plans.push({
+                    input, output, action: 'error',
+                    reason: `would collide with ${path.basename(plannedDest.get(destKey))}`,
+                    created: null, source: 'filename', stamp,
+                    backupRel: backupRelPath(input, rootDir),
+                });
+                continue;
+            }
+            if (fs.existsSync(output) && destKey !== path.resolve(input)) {
+                plans.push({
+                    input, output, action: 'error',
+                    reason: `destination already exists: ${normalized}`,
+                    created: null, source: 'filename', stamp,
+                    backupRel: backupRelPath(input, rootDir),
+                });
+                continue;
+            }
+            plannedDest.set(destKey, input);
+            plans.push({
+                input, output, action: 'rename', reason: 'filename',
+                created: null, source: 'filename', stamp,
+                backupRel: backupRelPath(input, rootDir),
+            });
+            continue;
+        }
+
+        if (isStandardDatedName(basename)) {
+            const stamp = fromName
+                ? filenameStampPrefix(fromName.parsed, {
+                    z: fromName.hasZ,
+                    mtime: fromName.source === 'mtime',
+                })
+                : null;
+            plans.push({
+                input, output: path.join(dir, basename), action: 'skip',
+                reason: 'already stamped',
+                created: stamp,
+                source: fromName?.source ?? null, stamp,
+                backupRel: backupRelPath(input, rootDir),
+            });
+            continue;
+        }
+
+        const resolved = resolveStampDate(meta, { preferMtime });
+        if (!resolved.parsed) {
+            plans.push({
+                input,
+                output: null,
+                action: 'skip',
+                reason: preferMtime
+                    ? 'no parseable creation_time or mtime'
+                    : 'no parseable creation_time (use --prefer-mtime to fall back to file date)',
+                created: resolved.raw ?? null,
+                source: null,
+                stamp: null,
+                backupRel: backupRelPath(input, rootDir),
+            });
+            continue;
+        }
+
+        const stamp = formatStampPrefix(resolved.parsed, { source: resolved.source });
+        const nextName = buildStampedName(basename, stamp);
+        if (nextName === null) {
+            plans.push({
+                input,
+                output: null,
+                action: 'skip',
+                reason: `already has a different date prefix (${existingStampPrefix(basename)})`,
+                created: resolved.raw,
+                source: resolved.source,
+                stamp,
+                backupRel: backupRelPath(input, rootDir),
+            });
+            continue;
+        }
+
+        const output = path.join(dir, nextName);
+        if (nextName === basename) {
+            plans.push({
+                input,
+                output,
+                action: 'skip',
+                reason: 'already stamped',
+                created: resolved.raw,
+                source: resolved.source,
+                stamp,
+                backupRel: backupRelPath(input, rootDir),
+            });
+            continue;
+        }
+
+        const destKey = path.resolve(output);
+        if (plannedDest.has(destKey)) {
+            plans.push({
+                input,
+                output,
+                action: 'error',
+                reason: `would collide with ${path.basename(plannedDest.get(destKey))}`,
+                created: resolved.raw,
+                source: resolved.source,
+                stamp,
+                backupRel: backupRelPath(input, rootDir),
+            });
+            continue;
+        }
+
+        if (fs.existsSync(output) && path.resolve(output) !== path.resolve(input)) {
+            plans.push({
+                input,
+                output,
+                action: 'error',
+                reason: `destination already exists: ${nextName}`,
+                created: resolved.raw,
+                source: resolved.source,
+                stamp,
+                backupRel: backupRelPath(input, rootDir),
+            });
+            continue;
+        }
+
+        plannedDest.set(destKey, input);
+        plans.push({
+            input,
+            output,
+            action: 'rename',
+            reason: resolved.source,
+            created: resolved.raw,
+            source: resolved.source,
+            stamp,
+            backupRel: backupRelPath(input, rootDir),
+        });
+    }
+
+    return {
+        plans,
+        stats: {
+            rename: plans.filter(p => p.action === 'rename').length,
+            skip: plans.filter(p => p.action === 'skip').length,
+            error: plans.filter(p => p.action === 'error').length,
+        },
+    };
+}
+
+export function formatStampPlanLines(plans, { dryRun = false, backupDir = null } = {}) {
+    const rows = plans.map(p => ({
+        from: path.basename(p.input),
+        to: p.output ? path.basename(p.output) : '—',
+        status: p.action === 'rename'
+            ? (dryRun ? 'would rename' : 'rename')
+            : p.action,
+        note: p.action === 'rename' ? (p.source || '') : (p.reason || ''),
+    }));
+
+    const fromW = Math.min(48, Math.max(18, ...rows.map(r => r.from.length)));
+    const toW = Math.min(56, Math.max(18, ...rows.map(r => r.to.length)));
+    const header = `  ${padEnd('File', fromW)}  ${padEnd('Stamped name', toW)}  Status`;
+    const rule = '  ' + '─'.repeat(fromW + toW + 12);
+    const lines = ['', rule, header, rule];
+
+    for (const row of rows) {
+        const extra = row.note ? `  ${row.note}` : '';
+        lines.push(`  ${padEnd(row.from, fromW)}  ${padEnd(row.to, toW)}  ${row.status}${extra}`);
+    }
+
+    lines.push(rule);
+    const action = dryRun ? 'would rename' : 'to rename';
+    const renameCount = plans.filter(p => p.action === 'rename').length;
+    const skipCount = plans.filter(p => p.action === 'skip').length;
+    const errorCount = plans.filter(p => p.action === 'error').length;
+    lines.push(`  ${plans.length} file(s): ${renameCount} ${action}, ${skipCount} skip, ${errorCount} error`);
+    if (backupDir) {
+        lines.push(`  Backup: ${backupDir}`);
+    }
+    lines.push('');
+    return lines;
+}
+
+function copyBackup(plan, backupDir) {
+    const dest = path.join(backupDir, plan.backupRel);
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    if (fs.existsSync(dest)) return { dest, copied: false };
+    fs.copyFileSync(plan.input, dest);
+    return { dest, copied: true };
+}
+
+export function writeStampManifest(filePath, payload) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(payload, null, 2) + '\n');
+}
+
+export function applyStampPlan(plans, {
+    dryRun = false,
+    backupDir = null,
+    manifestPath = null,
+} = {}) {
+    const renames = plans.filter(p => p.action === 'rename');
+    const result = {
+        renamed: 0,
+        skipped: plans.filter(p => p.action === 'skip').length,
+        failed: plans.filter(p => p.action === 'error').length,
+        backedUp: 0,
+        errors: [],
+    };
+
+    if (dryRun) {
+        result.renamed = renames.length;
+        return result;
+    }
+
+    const manifest = {
+        createdAt: new Date().toISOString(),
+        backupDir,
+        renames: renames.map(p => ({
+            from: path.basename(p.input),
+            to: path.basename(p.output),
+            fromPath: path.resolve(p.input),
+            toPath: path.resolve(p.output),
+            created: p.created,
+            source: p.source,
+        })),
+    };
+
+    if (backupDir) {
+        fs.mkdirSync(backupDir, { recursive: true });
+        for (const plan of renames) {
+            try {
+                const { copied } = copyBackup(plan, backupDir);
+                if (copied) result.backedUp++;
+            } catch (err) {
+                result.failed++;
+                result.errors.push(`${path.basename(plan.input)}: backup failed (${err.message})`);
+                if (manifestPath) writeStampManifest(manifestPath, { ...manifest, aborted: 'backup failed', errors: result.errors });
+                return result;
+            }
+        }
+    }
+
+    if (manifestPath) writeStampManifest(manifestPath, manifest);
+
+    for (const plan of renames) {
+        try {
+            if (fs.existsSync(plan.output) && path.resolve(plan.output) !== path.resolve(plan.input)) {
+                result.failed++;
+                result.errors.push(`${path.basename(plan.input)}: destination already exists`);
+                continue;
+            }
+            const times = readFileTimes(plan.input);
+            fs.renameSync(plan.input, plan.output);
+            applyFileTimes(plan.output, times);
+            repairCreatedIfMoved(plan.output);
+            result.renamed++;
+        } catch (err) {
+            result.failed++;
+            result.errors.push(`${path.basename(plan.input)}: rename failed (${err.message})`);
+        }
+    }
+
+    return result;
+}
+
+export function defaultManifestPath({ backupDir, targetPath, cwd = process.cwd() }) {
+    if (backupDir) return path.join(backupDir, 'mediatuna-stamp-manifest.json');
+    if (targetPath && fs.existsSync(targetPath) && fs.statSync(targetPath).isDirectory()) {
+        return path.join(targetPath, 'mediatuna-stamp-manifest.json');
+    }
+    return path.join(cwd, 'mediatuna-stamp-manifest.json');
+}
+
+export function runStampDates({
+    files,
+    probeFn,
+    preferMtime = false,
+    dryRun = false,
+    backupDir = null,
+    rootDir = null,
+    logger,
+}) {
+    const { plans, stats } = planStampRenames(files, { probeFn, preferMtime, rootDir });
+    const lines = formatStampPlanLines(plans, { dryRun, backupDir });
+    logger?.printLines?.(lines);
+
+    const manifestPath = dryRun ? null : defaultManifestPath({ backupDir, targetPath: rootDir });
+    const result = applyStampPlan(plans, { dryRun, backupDir, manifestPath });
+
+    if (!dryRun) {
+        for (const plan of plans) {
+            const target = plan.action === 'rename' && fs.existsSync(plan.output) ? plan.output : plan.input;
+            if (fs.existsSync(target)) {
+                try { repairCreatedIfMoved(target); } catch { /* keep going */ }
+            }
+        }
+    }
+
+    for (const err of result.errors) {
+        logger?.logConsole?.(`Stamp error: ${err}`);
+    }
+    if (!dryRun && manifestPath && fs.existsSync(manifestPath)) {
+        logger?.logConsole?.(`Stamp manifest: ${manifestPath}`);
+    }
+
+    return { plans, stats, result, manifestPath };
+}

package/lib/status.js

@@ -0,0 +1,78 @@
+import fs from 'fs';
+import path from 'path';
+import { isNormalizedMp3, isSourceMp3 } from './audio-policy.js';
+import { isLossyAudioSource } from './extensions.js';
+import { getMetadata } from './probe.js';
+
+export function existingOutputUsable(outPath, expectedType, {
+    existsFn = fs.existsSync,
+    statFn = fs.statSync,
+    probeFn = getMetadata,
+} = {}) {
+    if (!existsFn(outPath)) return false;
+    let size;
+    try {
+        size = statFn(outPath).size;
+    } catch {
+        return false;
+    }
+    if (size <= 0) return false;
+    const meta = probeFn(outPath);
+    if (!meta?.valid) return false;
+    if (expectedType && meta.mediaType !== expectedType) return false;
+    return true;
+}
+
+export function isConvertStatus(status) {
+    return status.startsWith('convert') || status.includes('+ mp3') || status.includes('→ mp3');
+}
+
+export function isSkippableStatus(status) {
+    return status.includes('skip (exists)') || status.includes('skip (normalized)') || status.includes('skip (resumed)');
+}
+
+export function matchesMediaMode(meta, mediaMode) {
+    if (mediaMode.audio && !mediaMode.video) return meta.mediaType === 'audio';
+    if (mediaMode.video && !mediaMode.audio) return meta.mediaType === 'video';
+    return meta.mediaType === 'video' || meta.mediaType === 'audio';
+}
+
+export function classifyStatus(input, meta, out, force, mediaMode, audioQuality, {
+    outputUsableFn = existingOutputUsable,
+} = {}) {
+    if (!meta.valid) return 'unreadable';
+    if (!matchesMediaMode(meta, mediaMode)) return 'skip (wrong type)';
+    if (meta.mediaType === 'audio') {
+        if (!force && isSourceMp3(input, meta) && isNormalizedMp3(input, meta, audioQuality)) {
+            if (path.resolve(input) === path.resolve(out) || outputUsableFn(out, 'audio')) {
+                return 'skip (normalized)';
+            }
+        }
+    }
+    const expected = meta.mediaType === 'audio' ? 'audio' : 'video';
+    if (!force && outputUsableFn(out, expected)) return 'skip (exists)';
+    if (meta.mediaType === 'audio') {
+        return isLossyAudioSource(input) ? 'convert → mp3 [lossy]' : 'convert → mp3';
+    }
+    return 'convert → mp4';
+}
+
+export function classifyExtractStatus(_input, _meta, audioOut, force, _audioQuality, {
+    outputUsableFn = existingOutputUsable,
+} = {}) {
+    if (!force && outputUsableFn(audioOut, 'audio')) return 'skip (exists)';
+    return 'convert → mp3 [extract]';
+}
+
+export function formatEntryStatus(videoStatus, extractStatus) {
+    if (!extractStatus) return videoStatus;
+    if (extractStatus.startsWith('convert')) {
+        return videoStatus.startsWith('convert') || videoStatus.startsWith('would convert')
+            ? `${videoStatus} + mp3 extract`
+            : `${videoStatus}; ${extractStatus}`;
+    }
+    if (videoStatus.startsWith('skip') && extractStatus.startsWith('skip')) {
+        return `${videoStatus}; mp3 ${extractStatus.replace('skip ', '')}`;
+    }
+    return `${videoStatus}; ${extractStatus}`;
+}

package/lib/tags.js

@@ -0,0 +1,35 @@
+export const DATE_TAG_KEYS = new Set(['date', 'creation_time', 'year', 'tdrc', 'tdor', 'originaldate']);
+export const IMPORTANT_TAG_NAMES = ['title', 'artist', 'album', 'date', 'genre'];
+
+export function normalizeTagKey(key) {
+    const lower = key.toLowerCase();
+    const colon = lower.lastIndexOf(':');
+    return colon >= 0 ? lower.slice(colon + 1) : lower;
+}
+
+export function extractTagInfo(tags = {}) {
+    const entries = Object.entries(tags).filter(([, v]) => v != null && String(v).trim() !== '');
+    return {
+        tags,
+        tagKeys: entries.map(([k]) => k),
+        tagCount: entries.length,
+    };
+}
+
+export function findTagValue(tags, name) {
+    const target = name.toLowerCase();
+    for (const [key, value] of Object.entries(tags)) {
+        if (normalizeTagKey(key) === target) return String(value).trim();
+    }
+    return null;
+}
+
+export function hasDateTag(tags) {
+    for (const key of Object.keys(tags)) {
+        if (DATE_TAG_KEYS.has(normalizeTagKey(key))) {
+            const value = String(tags[key]).trim();
+            if (value && value !== 'N/A') return true;
+        }
+    }
+    return false;
+}

package/lib/time.js

@@ -0,0 +1,29 @@
+export function secondsToHMS(seconds) {
+    const s = Math.floor(Math.max(0, Number(seconds) || 0));
+    const h = Math.floor(s / 3600);
+    const m = Math.floor((s % 3600) / 60);
+    const sec = s % 60;
+    return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}:${String(sec).padStart(2, '0')}`;
+}
+
+export function formatHMSValue(v, _options, type) {
+    if (type === 'value' || type === 'total') return secondsToHMS(v);
+    return v;
+}
+
+export function formatTimeHMS(t, _options, _round) {
+    if (t === 'NULL' || t === 'INF' || t == null || Number.isNaN(Number(t))) return '--:--:--';
+    return secondsToHMS(t);
+}
+
+export function timeToSeconds(timeStr) {
+    const parts = timeStr.split(':');
+    const last = parseFloat(parts[parts.length - 1]) || 0;
+    if (parts.length === 3) {
+        return (parseInt(parts[0], 10) || 0) * 3600 + (parseInt(parts[1], 10) || 0) * 60 + Math.floor(last);
+    }
+    if (parts.length === 2) {
+        return (parseInt(parts[0], 10) || 0) * 60 + Math.floor(last);
+    }
+    return Math.floor(last);
+}

package/lib/timestamps.js

@@ -0,0 +1,46 @@
+import fs from 'fs';
+import { execFileSync } from 'child_process';
+
+export const CREATED_REPAIR_DAYS = 30;
+
+export function readFileTimes(filePath) {
+    const stats = fs.statSync(filePath);
+    return {
+        atime: stats.atime,
+        mtime: stats.mtime,
+        birthtime: stats.birthtime,
+        ctime: stats.ctime,
+    };
+}
+
+export function createdIsMovedCopy(times, { days = CREATED_REPAIR_DAYS } = {}) {
+    const created = times.birthtime?.getTime?.() || times.ctime.getTime();
+    const modified = times.mtime.getTime();
+    return created - modified > days * 24 * 60 * 60 * 1000;
+}
+
+export function applyFileTimes(filePath, times) {
+    fs.utimesSync(filePath, times.atime, times.mtime);
+    if (process.platform === 'win32' && times.birthtime) {
+        execFileSync('powershell', [
+            '-NoProfile', '-Command',
+            `$p = ${JSON.stringify(filePath)}; $c = [datetime]${JSON.stringify(times.birthtime.toISOString())}; `
+            + '$f = Get-Item -LiteralPath $p; $f.CreationTime = $c; $f.LastWriteTime = [datetime]'
+            + JSON.stringify(times.mtime.toISOString()),
+        ], { stdio: 'ignore' });
+    }
+}
+
+export function repairCreatedIfMoved(filePath, { days = CREATED_REPAIR_DAYS } = {}) {
+    const times = readFileTimes(filePath);
+    if (!createdIsMovedCopy(times, { days })) return false;
+    const fixed = { ...times, birthtime: times.mtime, ctime: times.mtime };
+    applyFileTimes(filePath, fixed);
+    return true;
+}
+
+export function copyAndRepairTimestamps(input, output, { repairCreated = true } = {}) {
+    const times = readFileTimes(input);
+    applyFileTimes(output, times);
+    if (repairCreated) repairCreatedIfMoved(output);
+}

package/lib/tools.js

@@ -0,0 +1,13 @@
+import { execFileSync } from 'child_process';
+
+export function requireTools(tools = ['ffmpeg', 'ffprobe']) {
+    const missing = [];
+    for (const tool of tools) {
+        try {
+            execFileSync(tool, ['-version'], { stdio: 'pipe' });
+        } catch {
+            missing.push(tool);
+        }
+    }
+    return missing;
+}