plx-converter 0.1.0 → 0.1.2

package/dist/cli.js

@@ -1,290 +1,269 @@
 #!/usr/bin/env node
 import { confirm, intro, isCancel, outro, password, select, text } from '@clack/prompts';
-import { loadConfig, saveCredentials, saveRecentUrl, tryAutoFillCredentials } from './config.js';
-import { DeezerClient, resolveDeezerPlaylistId } from './deezer.js';
-import { Converter } from './converter.js';
-import { anonymousToken, authenticatedToken, parsePlaylistId, playlistName } from './spotify.js';
-import { reverseConvert, reverseWriteToExisting } from './reverse.js';
-import { listPlaylists } from './spotify.js';
+import { credential, loadConfig, saveCredential, saveRecentUrl, tryAutoFillCredentials } from './config.js';
+import { Conversion } from './conversion.js';
+import { PROVIDERS, inferSource, providerFor, targetKeys } from './registry.js';
 import { HELP_TEXT, parseArgs } from './args.js';
 function args() { return process.argv.slice(2); }
-// Build a validated Deezer client. If no ARL is set, prompt for it and persist.
-// Returns null when the user cancels or the ARL is rejected.
-async function ensureDeezer(cfg) {
-    if (!cfg.deezerArl) {
-        const filled = await tryAutoFillCredentials(cfg);
-        if (!filled.includes('deezerArl')) {
-            const arl = await password({ message: `Deezer ARL (${ARL_HINT})` });
-            if (isCancel(arl) || !arl)
-                return null;
-            cfg.deezerArl = String(arl);
-            await saveCredentials({ deezerArl: cfg.deezerArl });
-        }
+// --- Credentials -----------------------------------------------------------
+// Fill one provider's credential: browser auto-fill first, then a manual paste. Persists what it
+// gets. Returns the credential, or null when the user cancels.
+async function ensureCredential(cfg, spec) {
+    if (credential(cfg, spec.key))
+        return credential(cfg, spec.key);
+    const filled = await tryAutoFillCredentials(cfg);
+    if (filled.includes(spec.key))
+        return credential(cfg, spec.key);
+    const entered = await password({ message: `${spec.credentialLabel} (${spec.credentialHint})` });
+    if (isCancel(entered) || !entered)
+        return null;
+    await saveCredential(cfg, spec.key, String(entered));
+    return credential(cfg, spec.key);
+}
+// Settings entry for one provider's credential: unlike ensureCredential this always asks, so a
+// saved-but-expired credential can be replaced. Proves it against the live service before saying so.
+async function reenterCredential(cfg, spec) {
+    warnLogin(spec.loginSite);
+    const filled = await tryAutoFillCredentials(cfg);
+    if (!filled.includes(spec.key)) {
+        const entered = await password({ message: `${spec.credentialLabel} (${spec.credentialHint})` });
+        if (isCancel(entered) || !entered)
+            return;
+        await saveCredential(cfg, spec.key, String(entered));
+    }
+    await report(cfg, spec);
+}
+// Check one provider's stored credential against the live service and say what happened.
+async function report(cfg, spec) {
+    const cred = credential(cfg, spec.key);
+    if (!cred) {
+        console.log(`✗ No ${spec.credentialLabel} saved.`);
+        return false;
     }
-    const deezer = new DeezerClient(cfg.deezerArl);
     try {
-        await deezer.getMe();
+        console.log(`✓ ${spec.label}: ${await spec.validate(cred)}.`);
+        return true;
     }
     catch (error) {
-        console.log(`⚠️ ARL Deezer tidak valid (${error instanceof Error ? error.message : 'error'}). Isi ulang lewat Pengaturan.`);
-        return null;
+        console.log(`✗ ${spec.label}: ${error instanceof Error ? error.message : 'could not be verified'}`);
+        return false;
     }
-    return deezer;
 }
-// Pick a Spotify source: recent URLs, paste new, or (with sp_dc) pick from the account.
-// Returns the ref plus an authenticated read token when picked from the account
-// (covers private playlists); token is null on the anonymous paste/recent paths.
-async function chooseSource(cfg) {
-    const options = [
-        ...cfg.recentUrls.map((u) => ({ value: u, label: u })),
-        { value: '__new__', label: 'Tempel URL/ID baru' },
-    ];
-    if (cfg.spotifyDc)
-        options.push({ value: '__lib__', label: 'Pilih dari akun Spotify saya' });
-    const pick = await select({ message: 'Playlist asal (Spotify)', options });
-    if (isCancel(pick))
-        return null;
-    if (pick === '__new__') {
-        const ref = await text({ message: 'Tempel URL/ID playlist (q untuk kembali)', initialValue: '' });
-        if (isCancel(ref) || !ref || String(ref).toLowerCase() === 'q')
+// Build a provider, asking for its credential only if it needs one. `needsWrite` marks the target
+// side, which always needs one; a source that can read anonymously never asks.
+async function build(cfg, spec, needsWrite) {
+    let cred = credential(cfg, spec.key);
+    if (!cred && (needsWrite || !spec.anonymousRead)) {
+        cred = (await ensureCredential(cfg, spec)) ?? '';
+        if (!cred)
             return null;
-        return { ref: String(ref), token: null };
     }
-    if (pick === '__lib__') {
-        const token = await ensureSpotify(cfg);
-        if (!token)
-            return null;
-        const uri = await pickSpotifyPlaylist(token, 'asal');
-        return uri ? { ref: uri, token } : null;
+    try {
+        return await spec.create(cred);
     }
-    return { ref: String(pick), token: null };
-}
-// Pick an existing Deezer playlist (as target or source). Returns { id, title } or null.
-async function chooseTarget(deezer, role = 'target') {
-    const method = await select({
-        message: `Pilih playlist ${role === 'source' ? 'asal' : 'target'} (Deezer)`,
-        options: [
-            { value: 'list', label: 'Daftar dari akun Deezer' },
-            { value: 'paste', label: 'Tempel URL/ID Deezer' },
-        ],
-    });
-    if (isCancel(method))
+    catch (error) {
+        console.log(`⚠️ ${spec.label} rejected the saved credential (${error instanceof Error ? error.message : 'error'}). Replace it from the Credentials menu.`);
         return null;
-    if (method === 'list') {
-        let playlists;
-        try {
-            playlists = await deezer.listPlaylists();
-        }
-        catch (error) {
-            console.log(`⚠️ Gagal baca daftar playlist (${error instanceof Error ? error.message : 'error'}).`);
-            return null;
-        }
-        if (!playlists.length) {
-            console.log('Tidak ada playlist Deezer ditemukan di akun ini.');
-            return null;
-        }
-        const pick = await select({ message: 'Pilih playlist', options: playlists.map((p) => ({ value: p.id, label: p.title })) });
-        if (isCancel(pick))
-            return null;
-        return playlists.find((p) => p.id === pick) ?? null;
     }
-    const ref = await text({ message: 'Tempel URL/ID playlist Deezer', initialValue: '' });
-    if (isCancel(ref) || !ref)
-        return null;
-    const id = await resolveDeezerPlaylistId(String(ref));
-    return { id, title: id };
 }
-// Pick how to write the target: a new playlist or an existing one.
-async function chooseTargetKind() {
-    const kind = await select({
-        message: 'Target tujuan',
-        options: [
-            { value: 'new', label: 'Playlist baru' },
-            { value: 'existing', label: 'Playlist yang sudah ada' },
-        ],
-    });
-    if (isCancel(kind))
-        return null;
-    return kind;
-}
-// Core convert: read source, match, then write to a new playlist or an existing target.
-async function convert(cfg, options) {
-    const source = await chooseSource(cfg);
-    if (!source)
-        return;
-    const deezer = await ensureDeezer(cfg);
-    if (!deezer)
-        return;
-    const id = parsePlaylistId(source.ref);
-    const name = await playlistName(id);
-    const converter = new Converter(deezer, source.token ?? await anonymousToken(), options.output);
-    const result = await converter.matchPlaylist({ name, uri: id }, options.dryRun);
-    if (!options.dryRun && result.matchedIds.length) {
-        const kind = await chooseTargetKind();
-        if (kind === 'existing') {
-            const target = await chooseTarget(deezer);
-            if (target)
-                await converter.writeToExisting(name, target.id, result.matchedIds);
-        }
-        else if (kind === 'new') {
-            await maybeWrite(converter, name, result);
-        }
-    }
-    await converter.writeReport();
-    await saveRecentUrl(source.ref);
+// --- Pickers ---------------------------------------------------------------
+function warnLogin(sites) {
+    console.log(`⚠️ Make sure you're logged in at ${sites} in your browser, then grab the credentials.`);
 }
-async function maybeWrite(converter, name, result) {
-    if (!result.matchedIds.length)
-        return;
-    if (result.truncated) {
-        const proceed = await confirm({ message: `Playlist terpotong di 100 lagu. Lanjut dengan ${result.matchedIds.length} lagu?`, initialValue: false });
-        if (isCancel(proceed) || !proceed)
-            return;
-    }
-    const ok = await confirm({ message: `Buat '[plx] ${name}' (${result.matchedIds.length} lagu)?`, initialValue: false });
-    if (isCancel(ok) || !ok)
-        return;
-    await converter.writePlaylist(name, result.matchedIds);
+// Pick a provider by role. Adding a provider adds an option here, never a menu entry.
+async function pickProvider(message, from, exclude) {
+    const choices = from.filter((p) => p !== exclude);
+    const pick = await select({ message, options: choices.map((p) => ({ value: p.key, label: p.label })) });
+    if (isCancel(pick))
+        return null;
+    return providerFor(String(pick)) ?? null;
 }
-// Build a validated Spotify session (sp_dc cookie → authenticated token). Returns token or null.
-async function ensureSpotify(cfg) {
-    if (!cfg.spotifyDc) {
-        const filled = await tryAutoFillCredentials(cfg);
-        if (!filled.includes('spotifyDc')) {
-            const dc = await password({ message: `Spotify sp_dc (${SPDC_HINT})` });
-            if (isCancel(dc) || !dc)
-                return null;
-            cfg.spotifyDc = String(dc);
-            await saveCredentials({ spotifyDc: cfg.spotifyDc });
-        }
-    }
-    try {
-        return await authenticatedToken(cfg.spotifyDc);
-    }
-    catch (error) {
-        console.log(`⚠️ sp_dc Spotify tidak valid (${error instanceof Error ? error.message : 'error'}). Isi ulang lewat Pengaturan.`);
+// Pick the playlist to read: a recent link, a pasted one, or one from the account. Same three
+// options for every provider — the account option only appears when that provider can list.
+async function pickSourcePlaylist(cfg, spec, provider) {
+    const recents = cfg.recentUrls.filter((u) => inferSource(u) === spec);
+    const options = [
+        ...recents.map((u) => ({ value: u, label: u })),
+        { value: '__new__', label: 'Paste playlist URL/ID' },
+    ];
+    if (credential(cfg, spec.key))
+        options.push({ value: '__lib__', label: `Pick from my ${spec.label} account` });
+    const pick = await select({ message: `Source playlist (${spec.label})`, options });
+    if (isCancel(pick))
         return null;
+    if (pick === '__lib__') {
+        const chosen = await pickFromAccount(provider, spec, 'source');
+        return chosen && { id: chosen.id, name: chosen.title };
     }
+    const ref = pick === '__new__'
+        ? await text({ message: 'Paste playlist URL/ID (q to go back)', initialValue: '' })
+        : String(pick);
+    if (isCancel(ref) || !ref || String(ref).toLowerCase() === 'q')
+        return null;
+    const id = await spec.parseRef(String(ref));
+    // A provider that can resolve its own titles does it better than the registry's fallback.
+    const name = (await provider.playlistName?.(id).catch(() => '')) || await spec.playlistName(id);
+    return { id, name, ref: String(ref) };
 }
-// Pick a Spotify playlist by URI from the user's account (role 'asal' | 'target').
-async function pickSpotifyPlaylist(token, role) {
+async function pickFromAccount(provider, spec, role) {
     let playlists;
     try {
-        playlists = await listPlaylists(token);
+        playlists = await provider.listPlaylists();
     }
     catch (error) {
-        console.log(`⚠️ Gagal baca daftar playlist Spotify (${error instanceof Error ? error.message : 'error'}).`);
+        console.log(`⚠️ Failed to read the ${spec.label} playlist list (${error instanceof Error ? error.message : 'error'}).`);
         return null;
     }
     if (!playlists.length) {
-        console.log('Tidak ada playlist Spotify (yang bisa diubah) ditemukan.');
+        console.log(`No writable ${spec.label} playlists found.`);
         return null;
     }
-    const pick = await select({ message: `Pilih playlist ${role} (Spotify)`, options: playlists.map((p) => ({ value: p.uri, label: p.name })) });
+    const pick = await select({ message: `Pick ${role} playlist (${spec.label})`, options: playlists.map((p) => ({ value: p.id, label: p.title })) });
     if (isCancel(pick))
         return null;
-    return String(pick);
+    return playlists.find((p) => p.id === pick) ?? null;
 }
-// Pick an existing Spotify playlist (writable) as reverse target. Returns uri or null.
-async function chooseSpotifyTarget(token) {
-    return pickSpotifyPlaylist(token, 'target');
+// Pick the target playlist: an existing one (from the account or pasted), or null for a new one.
+// Returns undefined when the user cancels, to keep it apart from "a new playlist".
+async function pickTargetPlaylist(spec, provider) {
+    const kind = await select({
+        message: 'Target destination',
+        options: [
+            { value: 'new', label: 'New playlist' },
+            { value: 'existing', label: 'Existing playlist' },
+        ],
+    });
+    if (isCancel(kind))
+        return undefined;
+    if (kind === 'new')
+        return null;
+    const how = await select({
+        message: `Pick target playlist (${spec.label})`,
+        options: [
+            { value: 'list', label: `List from my ${spec.label} account` },
+            { value: 'paste', label: 'Paste playlist URL/ID' },
+        ],
+    });
+    if (isCancel(how))
+        return undefined;
+    if (how === 'list')
+        return (await pickFromAccount(provider, spec, 'target'))?.id;
+    const ref = await text({ message: 'Paste playlist URL/ID', initialValue: '' });
+    if (isCancel(ref) || !ref)
+        return undefined;
+    return spec.parseRef(String(ref));
 }
-// Reverse flow: Deezer playlist (source) → new or existing Spotify playlist (target).
-async function reverseConvertFlow(cfg, options) {
-    const deezer = await ensureDeezer(cfg);
-    if (!deezer)
+// --- Conversion ------------------------------------------------------------
+// One flow for every direction: pick source provider, pick target provider, then convert.
+async function runConversion(cfg, options) {
+    const sourceSpec = await pickProvider('Source provider', PROVIDERS);
+    if (!sourceSpec)
+        return;
+    const targetSpec = await pickProvider('Target provider', PROVIDERS, sourceSpec);
+    if (!targetSpec)
         return;
-    const source = await chooseTarget(deezer, 'source');
+    const source = await build(cfg, sourceSpec, false);
     if (!source)
         return;
-    const token = await ensureSpotify(cfg);
-    if (!token)
+    const picked = await pickSourcePlaylist(cfg, sourceSpec, source);
+    if (!picked)
         return;
-    const kind = await chooseTargetKind();
-    if (kind === 'existing') {
-        const target = await chooseSpotifyTarget(token);
-        if (target)
-            await reverseWriteToExisting(deezer, token, source.id, source.title, target, options.output);
+    // A dry run writes nothing, so it never asks for the target's credential or its destination.
+    const target = await build(cfg, targetSpec, !options.dryRun);
+    if (!target)
+        return;
+    let targetPlaylist = null;
+    if (!options.dryRun) {
+        const chosen = await pickTargetPlaylist(targetSpec, target);
+        if (chosen === undefined)
+            return;
+        targetPlaylist = chosen;
     }
-    else if (kind === 'new') {
-        await reverseConvert(deezer, token, source.id, source.title, options.output);
+    const conversion = new Conversion(source, target, options.output);
+    try {
+        const result = await conversion.matchPlaylist({ name: picked.name, uri: picked.id }, options.dryRun);
+        if (!options.dryRun && result.matchedIds.length) {
+            if (targetPlaylist)
+                await conversion.writeToExisting(picked.name, targetPlaylist, result.matchedIds);
+            else
+                await confirmAndCreate(conversion, picked.name, result);
+        }
+    }
+    finally {
+        await conversion.writeReport(); // a failed write must not cost the whole report
     }
+    if (picked.ref)
+        await saveRecentUrl(picked.ref);
 }
-function warnLogin(sites) {
-    console.log(`⚠️ Pastikan sudah login di ${sites} di browser, lalu ambil kredensialnya.`);
+async function confirmAndCreate(conversion, name, result) {
+    if (result.truncated) {
+        const proceed = await confirm({ message: `Playlist truncated at ${result.total} tracks. Continue with ${result.matchedIds.length} tracks?`, initialValue: false });
+        if (isCancel(proceed) || !proceed)
+            return;
+    }
+    const ok = await confirm({ message: `Create '[plx] ${name}' (${result.matchedIds.length} tracks)?`, initialValue: false });
+    if (isCancel(ok) || !ok)
+        return;
+    await conversion.writePlaylist(name, result.matchedIds);
 }
-const ARL_HINT = 'login deezer.com → F12 → Application → Cookies → arl → salin value';
-const SPDC_HINT = 'login open.spotify.com → F12 → Application → Cookies → sp_dc → salin value';
+// --- Menu ------------------------------------------------------------------
+// Fixed entry count: the two provider-shaped entries (Convert, Credentials) branch by provider
+// rather than listing one option each, so adding a provider never lengthens this menu.
 async function runInteractive(options) {
-    intro('plx — Spotify ⇄ Deezer');
-    const cfg = await loadConfig(false); // no requirement at menu entry
+    intro('plx — playlist converter');
+    const cfg = await loadConfig();
+    if (cfg.legacyCredentials)
+        console.log('⚠️ Your saved credentials are in an older format and were not carried over. Re-enter them from Credentials (or use Auto-fetch) — it only takes one browser dialog.');
     for (;;) {
+        const saved = PROVIDERS.filter((p) => credential(cfg, p.key)).length;
         const choice = await select({
-            message: 'Pilih aksi',
+            message: 'Pick an action',
             options: [
-                { value: 'forward', label: 'Spotify → Deezer' },
-                { value: 'reverse', label: 'Deezer → Spotify' },
-                { value: 'arl', label: `Deezer ARL: ${cfg.deezerArl ? '✓ tersimpan' : '(belum diisi)'}` },
-                { value: 'spdc', label: `Spotify sp_dc: ${cfg.spotifyDc ? '✓ tersimpan' : '(belum diisi)'}` },
-                { value: 'autofetch', label: 'Ambil kredensial otomatis (dari browser)' },
-                { value: 'output', label: `Laporan: ${options.output}` },
-                { value: 'quit', label: 'Keluar' },
+                { value: 'convert', label: 'Convert a playlist' },
+                { value: 'credentials', label: `Credentials: ${saved}/${PROVIDERS.length} saved` },
+                { value: 'autofetch', label: 'Auto-fetch credentials (from browser)' },
+                { value: 'output', label: `Report: ${options.output}` },
+                { value: 'quit', label: 'Quit' },
             ],
         });
         if (isCancel(choice) || choice === 'quit')
             break;
-        if (choice === 'forward') {
-            await convert(cfg, options);
-            continue;
-        }
-        if (choice === 'reverse') {
-            await reverseConvertFlow(cfg, options);
-            continue;
-        }
-        if (choice === 'arl') {
-            warnLogin('Deezer (deezer.com)');
-            const filled = await tryAutoFillCredentials(cfg);
-            if (!filled.includes('deezerArl')) {
-                const arl = await password({ message: `Deezer ARL (${ARL_HINT})` });
-                if (isCancel(arl) || !arl)
-                    continue;
-                cfg.deezerArl = String(arl);
-                await saveCredentials({ deezerArl: cfg.deezerArl });
-            }
-            console.log('✓ Deezer ARL tersimpan.');
+        if (choice === 'convert') {
+            await runConversion(cfg, options);
             continue;
         }
-        if (choice === 'spdc') {
-            warnLogin('Spotify (open.spotify.com)');
-            const filled = await tryAutoFillCredentials(cfg);
-            if (!filled.includes('spotifyDc')) {
-                const dc = await password({ message: `Spotify sp_dc (${SPDC_HINT})` });
-                if (isCancel(dc) || !dc)
-                    continue;
-                cfg.spotifyDc = String(dc);
-                await saveCredentials({ spotifyDc: cfg.spotifyDc });
-            }
-            console.log('✓ Spotify sp_dc tersimpan.');
+        if (choice === 'credentials') {
+            const spec = await pickProvider('Which provider?', PROVIDERS);
+            if (spec)
+                await reenterCredential(cfg, spec);
             continue;
         }
         if (choice === 'autofetch') {
-            warnLogin('Deezer & Spotify');
+            warnLogin(PROVIDERS.map((p) => p.label).join(' & '));
             const filled = await tryAutoFillCredentials(cfg, true);
-            console.log(filled.length
-                ? `✓ Terambil dari browser: ${filled.join(', ')}.`
-                : '✗ Tidak ada kredensial yang bisa diambil (browser belum login / keychain ditolak).');
+            if (!filled.length) {
+                console.log('✗ No credentials could be fetched (browser not logged in / keychain denied).');
+                continue;
+            }
+            console.log(`Fetched from browser: ${filled.join(', ')}. Checking…`);
+            for (const key of filled) {
+                const spec = providerFor(key);
+                if (spec)
+                    await report(cfg, spec);
+            }
             continue;
         }
         if (choice === 'output') {
-            const output = await text({ message: 'Path file laporan', initialValue: options.output });
+            const output = await text({ message: 'Report file path', initialValue: options.output });
             if (isCancel(output) || !output)
                 continue;
             options.output = String(output);
             continue;
         }
     }
-    outro(`Selesai. Laporan: ${options.output}`);
+    outro(`Done. Report: ${options.output}`);
 }
+// --- Entry -----------------------------------------------------------------
 async function main() {
     const options = parseArgs(args());
     if (options.help) {
@@ -295,18 +274,52 @@ async function main() {
         await runInteractive(options);
         return;
     }
-    const cfg = await loadConfig(true);
-    const deezer = new DeezerClient(cfg.deezerArl);
-    await deezer.getMe();
-    const converter = new Converter(deezer, await anonymousToken(), options.output);
+    // A target is never guessed — not naming one is an error, dry run or not.
+    const targetSpec = options.target ? providerFor(options.target) : undefined;
+    if (!targetSpec) {
+        throw new Error(options.target
+            ? `Unknown target provider '${options.target}'. Valid targets: ${targetKeys().join(', ')}.`
+            : `No target provider. Name one with --to <${targetKeys().join('|')}>.`);
+    }
+    const cfg = await loadConfig();
+    if (cfg.legacyCredentials)
+        console.log('⚠️ Saved credentials are in an older format and were not carried over. Run `plx` and re-enter them (one browser dialog).');
     for (const raw of options.urls) {
-        const id = parsePlaylistId(raw);
-        const name = await playlistName(id);
-        const result = await converter.matchPlaylist({ name, uri: id }, options.dryRun);
-        if (!options.dryRun && result.matchedIds.length)
-            await converter.writePlaylist(name, result.matchedIds);
+        const sourceSpec = inferSource(raw);
+        if (!sourceSpec)
+            throw new Error(`Cannot tell which provider '${raw}' belongs to. Use a link from one of: ${PROVIDERS.map((p) => p.label).join(', ')}.`);
+        if (sourceSpec === targetSpec)
+            throw new Error(`Source and target are both ${sourceSpec.label}.`);
+        const source = await sourceSpec.create(readCredential(cfg, sourceSpec));
+        // A dry run only searches the target, which may need no credential at all; a write always does.
+        const target = await targetSpec.create(options.dryRun ? credential(cfg, targetSpec.key) : writeCredential(cfg, targetSpec));
+        const conversion = new Conversion(source, target, options.output);
+        try {
+            const id = await sourceSpec.parseRef(raw);
+            // A provider that can resolve its own titles does it better than the registry's fallback.
+            const name = (await source.playlistName?.(id).catch(() => '')) || await sourceSpec.playlistName(id);
+            const result = await conversion.matchPlaylist({ name, uri: id }, options.dryRun);
+            if (!options.dryRun && result.matchedIds.length)
+                await conversion.writePlaylist(name, result.matchedIds);
+        }
+        finally {
+            await conversion.writeReport(); // a failed write must not cost the whole report
+        }
     }
-    await converter.writeReport();
     outro(`Report saved to ${options.output}`);
 }
+// Reading: a provider that permits anonymous reads needs nothing.
+function readCredential(cfg, spec) {
+    const cred = credential(cfg, spec.key);
+    if (!cred && !spec.anonymousRead)
+        throw new Error(`No ${spec.label} credential, needed to read a ${spec.label} playlist. Run \`plx\` and save it from the Credentials menu.`);
+    return cred;
+}
+// Writing: always needs one, whatever the provider allows for reads.
+function writeCredential(cfg, spec) {
+    const cred = credential(cfg, spec.key);
+    if (!cred)
+        throw new Error(`No ${spec.label} credential, needed to write into ${spec.label}. Run \`plx\` and save it from the Credentials menu, or use --dry-run to match without writing.`);
+    return cred;
+}
 main().catch((error) => { console.error(`Error: ${error instanceof Error ? error.message : error}`); process.exitCode = 1; });