@onpeek/nuvio 1.0.0

package/dist/nuvio/ops/plugins.js

@@ -0,0 +1,127 @@
+import { NuvioError } from '../errors.js';
+function assertHttpUrl(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw new NuvioError(`Invalid plugin URL: ${url}`);
+    }
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+        throw new NuvioError(`Plugin URL must be http(s): ${url}`);
+    }
+}
+export async function listPlugins(client, profileId) {
+    return client.select('plugins', `select=id,user_id,profile_id,url,name,enabled,sort_order,repo_type,created_at,updated_at` +
+        `&profile_id=eq.${profileId}&order=sort_order.asc`);
+}
+function toPushShape(plugins) {
+    return plugins.map((p) => ({
+        url: p.url,
+        name: p.name,
+        enabled: p.enabled,
+        sort_order: p.sort_order,
+        repo_type: p.repo_type,
+    }));
+}
+function diffPlugins(before, after) {
+    const b = new Map(before.map((p) => [p.url, p]));
+    const a = new Map(after.map((p) => [p.url, p]));
+    const diff = [];
+    for (const [url, p] of a) {
+        const prev = b.get(url);
+        if (!prev)
+            diff.push(`+ plugin ${url} (enabled=${p.enabled})`);
+        else {
+            if (prev.enabled !== p.enabled)
+                diff.push(`~ plugin ${url} enabled ${prev.enabled} -> ${p.enabled}`);
+            if (prev.name !== p.name)
+                diff.push(`~ plugin ${url} name ${prev.name ?? 'null'} -> ${p.name ?? 'null'}`);
+            if (prev.sort_order !== p.sort_order)
+                diff.push(`~ plugin ${url} order ${prev.sort_order} -> ${p.sort_order}`);
+        }
+    }
+    for (const url of b.keys())
+        if (!a.has(url))
+            diff.push(`- plugin ${url}`);
+    return diff.sort();
+}
+async function commit(client, profileId, originId, before, after, apply) {
+    const diff = diffPlugins(before, after);
+    if (apply && diff.length > 0) {
+        await client.rpc('sync_push_plugins', {
+            p_profile_id: profileId,
+            p_plugins: after,
+            p_origin_client_id: originId,
+        });
+    }
+    return { applied: apply && diff.length > 0, changed: diff.length > 0, before, after, diff };
+}
+export async function addPlugin(client, profileId, input, originId, apply) {
+    assertHttpUrl(input.url);
+    const before = toPushShape(await listPlugins(client, profileId));
+    if (before.some((p) => p.url === input.url))
+        throw new NuvioError(`Plugin already installed: ${input.url}`);
+    const after = [
+        ...before,
+        {
+            url: input.url,
+            name: input.name ?? null,
+            enabled: input.enabled ?? true,
+            sort_order: input.sort_order ?? before.reduce((m, p) => Math.max(m, p.sort_order + 1), 0),
+            repo_type: input.repo_type ?? null,
+        },
+    ];
+    if (after.length !== before.length + 1)
+        throw new NuvioError('Internal invariant failed (plugin add)');
+    return commit(client, profileId, originId, before, after, apply);
+}
+export async function removePlugin(client, profileId, match, originId, apply) {
+    const rows = await listPlugins(client, profileId);
+    const target = rows.find((p) => (match.url ? p.url === match.url : p.id === match.id));
+    if (!target)
+        throw new NuvioError('Plugin not found on profile');
+    const before = toPushShape(rows);
+    const after = before.filter((p) => p.url !== target.url);
+    if (after.length !== before.length - 1)
+        throw new NuvioError('Internal invariant failed (plugin remove)');
+    return commit(client, profileId, originId, before, after, apply);
+}
+/** Change a plugin's name, enabled flag, repo type or sort order. Identify it by url or table id. */
+export async function updatePlugin(client, profileId, match, changes, originId, apply) {
+    const rows = await listPlugins(client, profileId);
+    const target = rows.find((p) => (match.url ? p.url === match.url : p.id === match.id));
+    if (!target)
+        throw new NuvioError(`Plugin not found on profile ${profileId}`);
+    const before = toPushShape(rows);
+    const after = before.map((p) => p.url === target.url
+        ? {
+            url: p.url,
+            name: changes.name !== undefined ? changes.name : p.name,
+            enabled: changes.enabled !== undefined ? changes.enabled : p.enabled,
+            sort_order: changes.sort_order !== undefined ? changes.sort_order : p.sort_order,
+            repo_type: changes.repo_type !== undefined ? changes.repo_type : p.repo_type,
+        }
+        : p);
+    return commit(client, profileId, originId, before, after, apply);
+}
+export async function togglePlugin(client, profileId, url, enabled, originId, apply) {
+    const before = toPushShape(await listPlugins(client, profileId));
+    if (!before.some((p) => p.url === url))
+        throw new NuvioError(`Plugin not found: ${url}`);
+    const after = before.map((p) => (p.url === url ? { ...p, enabled } : p));
+    return commit(client, profileId, originId, before, after, apply);
+}
+export async function reorderPlugins(client, profileId, orderedUrls, originId, apply) {
+    const before = toPushShape(await listPlugins(client, profileId));
+    const current = before.map((p) => p.url).sort();
+    const wanted = [...orderedUrls].sort();
+    if (current.length !== wanted.length || current.some((u, i) => u !== wanted[i])) {
+        throw new NuvioError('Reorder must list every installed plugin URL exactly once.');
+    }
+    const after = orderedUrls.map((url, index) => ({
+        ...before.find((p) => p.url === url),
+        sort_order: index,
+    }));
+    return commit(client, profileId, originId, before, after, apply);
+}

package/dist/nuvio/ops/profiles.js

@@ -0,0 +1,383 @@
+import { NuvioError } from '../errors.js';
+import { deepMerge, writeSettings } from './settings.js';
+export const SETUP_PLATFORMS = ['tv', 'mobile', 'desktop'];
+const DEFAULT_MAPPINGS = SETUP_PLATFORMS.map((p) => ({ from: p, to: p }));
+async function readPlatformSettings(client, profileId, platform) {
+    const rows = await client.readRpc('sync_pull_profile_settings_blob', { p_profile_id: profileId, p_platform: platform });
+    return {
+        json: rows[0]?.settings_json ?? null,
+        updatedAt: rows[0]?.updated_at ?? null,
+    };
+}
+async function readCredentials(client, profileId) {
+    return client.readRpc('sync_pull_provider_credentials', { p_profile_id: profileId });
+}
+/**
+ * Copy a profile's setup to another profile: per-platform settings (deep-merged
+ * or replaced) and optionally provider credentials (merged or replaced).
+ *
+ * Transactional: every source/target state is read up front; on any write
+ * failure the already-written platforms/credentials are rolled back. Settings
+ * use the guarded writer so a concurrent change on the target is not clobbered.
+ */
+export async function copySetup(client, input, originId, apply) {
+    const source = input.source_profile_id;
+    const target = input.target_profile_id;
+    if (source === target && !input.platforms?.some((m) => m.from !== m.to)) {
+        return { applied: false, changed: false, before: {}, after: {}, diff: [] };
+    }
+    const mappings = input.platforms?.length ? input.platforms : DEFAULT_MAPPINGS;
+    const mode = input.settings_mode ?? 'merge';
+    const credMode = input.provider_credentials ?? 'none';
+    const before = { settings: {}, provider_credentials: [] };
+    const after = { settings: {}, provider_credentials: [] };
+    const diff = [];
+    // Read every source and target state BEFORE writing anything, so a chain like
+    // tv -> mobile, mobile -> desktop still uses the original mobile source state.
+    const sourceStates = new Map();
+    const targetStates = new Map();
+    for (const mapping of mappings) {
+        if (!sourceStates.has(mapping.from))
+            sourceStates.set(mapping.from, await readPlatformSettings(client, source, mapping.from));
+        if (!targetStates.has(mapping.to))
+            targetStates.set(mapping.to, await readPlatformSettings(client, target, mapping.to));
+    }
+    const desired = new Map();
+    for (const mapping of mappings) {
+        const src = sourceStates.get(mapping.from);
+        const tgt = targetStates.get(mapping.to);
+        before.settings[mapping.to] = tgt.json;
+        if (src.json === null)
+            continue;
+        const next = mode === 'replace' ? src.json : deepMerge(tgt.json ?? {}, src.json);
+        desired.set(mapping.to, { before: tgt, after: next });
+        after.settings[mapping.to] = next;
+        if (JSON.stringify(tgt.json) !== JSON.stringify(next)) {
+            diff.push(`~ ${mapping.from} -> ${mapping.to} settings (${mode}) on profile ${target}`);
+        }
+    }
+    let targetCredsBefore = [];
+    const pushCredentials = [];
+    const deleteProviders = [];
+    if (credMode !== 'none') {
+        const srcCreds = await readCredentials(client, source);
+        const tgtCreds = await readCredentials(client, target);
+        targetCredsBefore = tgtCreds;
+        before.provider_credentials = tgtCreds;
+        if (credMode === 'replace') {
+            const wanted = new Set(srcCreds.map((c) => c.provider));
+            for (const cred of tgtCreds)
+                if (!wanted.has(cred.provider))
+                    deleteProviders.push(cred.provider);
+        }
+        for (const cred of srcCreds)
+            pushCredentials.push(cred);
+        after.provider_credentials = srcCreds;
+        if (pushCredentials.length > 0) {
+            diff.push(`~ provider credentials (${credMode}): ${pushCredentials.map((c) => c.provider).join(', ')}`);
+        }
+        for (const provider of deleteProviders)
+            diff.push(`- provider credential ${provider}`);
+    }
+    if (!apply || diff.length === 0) {
+        return { applied: apply && diff.length > 0, changed: diff.length > 0, before, after, diff };
+    }
+    const toWrite = [...desired.entries()].filter(([, d]) => JSON.stringify(d.before.json) !== JSON.stringify(d.after));
+    const writtenPlatforms = [];
+    let credentialsTouched = false;
+    const restoreProviders = async () => {
+        const beforeProviders = new Set(targetCredsBefore.map((c) => c.provider));
+        for (const cred of pushCredentials) {
+            if (!beforeProviders.has(cred.provider)) {
+                await client.rpc('sync_delete_provider_credentials', {
+                    p_profile_id: target,
+                    p_provider: cred.provider,
+                    p_origin_client_id: originId,
+                });
+            }
+        }
+        if (targetCredsBefore.length > 0) {
+            await client.rpc('sync_push_provider_credentials', {
+                p_profile_id: target,
+                p_credentials: targetCredsBefore.map((c) => ({
+                    provider: c.provider,
+                    credential_json: c.credential_json,
+                })),
+                p_origin_client_id: originId,
+            });
+        }
+    };
+    try {
+        for (const [platform, d] of toWrite) {
+            const result = await writeSettings(client, target, platform, d.after, d.before.updatedAt, originId);
+            writtenPlatforms.push({
+                platform,
+                revision: result.revision,
+                guarded: result.guarded,
+                beforeJson: d.before.json,
+            });
+        }
+        if (deleteProviders.length > 0 || pushCredentials.length > 0) {
+            credentialsTouched = true;
+            for (const provider of deleteProviders) {
+                await client.rpc('sync_delete_provider_credentials', {
+                    p_profile_id: target,
+                    p_provider: provider,
+                    p_origin_client_id: originId,
+                });
+            }
+            if (pushCredentials.length > 0) {
+                await client.rpc('sync_push_provider_credentials', {
+                    p_profile_id: target,
+                    p_credentials: pushCredentials,
+                    p_origin_client_id: originId,
+                });
+            }
+        }
+    }
+    catch (error) {
+        const original = error instanceof Error ? error.message : String(error);
+        const failures = [];
+        for (const w of [...writtenPlatforms].reverse()) {
+            try {
+                if (w.guarded && w.revision) {
+                    await writeSettings(client, target, w.platform, w.beforeJson ?? {}, w.revision, originId);
+                }
+                else {
+                    await client.rpc('sync_push_profile_settings_blob', {
+                        p_profile_id: target,
+                        p_platform: w.platform,
+                        p_settings_json: w.beforeJson ?? {},
+                        p_origin_client_id: originId,
+                    });
+                }
+            }
+            catch (rollbackError) {
+                failures.push(`${w.platform}: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`);
+            }
+        }
+        if (credentialsTouched) {
+            try {
+                await restoreProviders();
+            }
+            catch (rollbackError) {
+                failures.push(`providers: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`);
+            }
+        }
+        if (failures.length > 0) {
+            throw new NuvioError(`copy_setup failed and rollback was incomplete (partially applied): ${failures.join('; ')}. ` +
+                `Original error: ${original}`);
+        }
+        throw new NuvioError(`copy_setup failed and was rolled back: ${original}`);
+    }
+    return { applied: true, changed: true, before, after, diff };
+}
+export const CLIENT_MAX_PROFILES = 6;
+export async function listProfiles(client) {
+    return client.readRpc('sync_pull_profiles', {});
+}
+function toPushShape(profiles) {
+    return profiles
+        .map((p) => ({
+        profile_index: p.profile_index,
+        name: p.name,
+        avatar_color_hex: p.avatar_color_hex,
+        uses_primary_addons: p.uses_primary_addons,
+        uses_primary_plugins: p.uses_primary_plugins,
+        avatar_id: p.avatar_id,
+        avatar_url: p.avatar_url,
+    }))
+        .sort((a, b) => a.profile_index - b.profile_index);
+}
+function diffProfiles(before, after) {
+    const diff = [];
+    const b = new Map(before.map((p) => [p.profile_index, p]));
+    const a = new Map(after.map((p) => [p.profile_index, p]));
+    for (const [idx, p] of a) {
+        const prev = b.get(idx);
+        if (!prev)
+            diff.push(`+ profile ${idx} "${p.name}"`);
+        else {
+            if (prev.name !== p.name)
+                diff.push(`~ profile ${idx} name "${prev.name}" -> "${p.name}"`);
+            if (prev.avatar_color_hex !== p.avatar_color_hex)
+                diff.push(`~ profile ${idx} color ${prev.avatar_color_hex} -> ${p.avatar_color_hex}`);
+            if (prev.uses_primary_addons !== p.uses_primary_addons)
+                diff.push(`~ profile ${idx} uses_primary_addons ${prev.uses_primary_addons} -> ${p.uses_primary_addons}`);
+        }
+    }
+    for (const idx of b.keys())
+        if (!a.has(idx))
+            diff.push(`- profile ${idx}`);
+    return diff.sort();
+}
+export async function createProfile(client, input, originId, apply) {
+    if (!input.name.trim())
+        throw new NuvioError('Profile name is required');
+    const before = toPushShape(await listProfiles(client));
+    const used = new Set(before.map((p) => p.profile_index));
+    if (used.size >= CLIENT_MAX_PROFILES) {
+        throw new NuvioError(`All ${CLIENT_MAX_PROFILES} profile slots are in use.`);
+    }
+    let index = input.profile_index;
+    if (index === undefined) {
+        index = 1;
+        while (used.has(index))
+            index += 1;
+    }
+    if (index < 1 || index > CLIENT_MAX_PROFILES)
+        throw new NuvioError('profile_index must be 1..6');
+    if (used.has(index))
+        throw new NuvioError(`Profile slot ${index} is already in use.`);
+    const after = [
+        ...before,
+        {
+            profile_index: index,
+            name: input.name.trim(),
+            avatar_color_hex: input.avatar_color_hex ?? null,
+            uses_primary_addons: index === 1 ? false : (input.uses_primary_addons ?? false),
+            uses_primary_plugins: false,
+            avatar_id: input.avatar_id ?? null,
+            avatar_url: input.avatar_url ?? null,
+        },
+    ].sort((x, y) => x.profile_index - y.profile_index);
+    // Invariant: every previously existing profile is preserved verbatim.
+    if (before.some((p) => !after.find((q) => q.profile_index === p.profile_index))) {
+        throw new NuvioError('Internal invariant failed (profile create)');
+    }
+    const diff = diffProfiles(before, after);
+    if (apply) {
+        await client.rpc('sync_push_profiles', {
+            p_client_max_profiles: CLIENT_MAX_PROFILES,
+            p_origin_client_id: originId,
+            p_profiles: after,
+        });
+    }
+    return { applied: apply, changed: diff.length > 0, before, after, diff };
+}
+export async function updateProfile(client, profileIndex, patch, apply) {
+    const profiles = await listProfiles(client);
+    const target = profiles.find((p) => p.profile_index === profileIndex);
+    if (!target)
+        throw new NuvioError(`Profile ${profileIndex} not found`);
+    const args = { p_profile_id: profileIndex };
+    if (patch.name !== undefined)
+        args.p_name = patch.name;
+    if (patch.avatar_color_hex !== undefined)
+        args.p_avatar_color_hex = patch.avatar_color_hex;
+    if (patch.uses_primary_addons !== undefined)
+        args.p_uses_primary_addons = patch.uses_primary_addons;
+    if ('avatar_id' in patch) {
+        args.p_avatar_id = patch.avatar_id;
+        args.p_avatar_id_provided = true;
+    }
+    if ('avatar_url' in patch) {
+        args.p_avatar_url = patch.avatar_url;
+        args.p_avatar_url_provided = true;
+    }
+    const preview = { ...target, ...patch };
+    const diff = [];
+    if (patch.name !== undefined && patch.name !== target.name)
+        diff.push(`name "${target.name}" -> "${patch.name}"`);
+    if (patch.avatar_color_hex !== undefined && patch.avatar_color_hex !== target.avatar_color_hex)
+        diff.push(`color ${target.avatar_color_hex} -> ${patch.avatar_color_hex}`);
+    if ('avatar_id' in patch && patch.avatar_id !== target.avatar_id)
+        diff.push(`avatar_id -> ${patch.avatar_id}`);
+    if ('avatar_url' in patch && patch.avatar_url !== target.avatar_url)
+        diff.push(`avatar_url -> ${patch.avatar_url}`);
+    if (patch.uses_primary_addons !== undefined && patch.uses_primary_addons !== target.uses_primary_addons)
+        diff.push(`uses_primary_addons -> ${patch.uses_primary_addons}`);
+    if (apply && diff.length > 0) {
+        await client.rpc('sync_patch_profile', args);
+    }
+    return {
+        applied: apply && diff.length > 0,
+        changed: diff.length > 0,
+        before: target,
+        after: preview,
+        diff,
+    };
+}
+export async function deleteProfile(client, profileIndex, originId, apply) {
+    if (profileIndex === 1) {
+        throw new NuvioError('Profile 1 is the primary profile and cannot be deleted.');
+    }
+    const profiles = await listProfiles(client);
+    const target = profiles.find((p) => p.profile_index === profileIndex);
+    if (!target)
+        throw new NuvioError(`Profile ${profileIndex} not found`);
+    const diff = [
+        `- profile ${profileIndex} "${target.name}" and ALL of its data (addons, settings, collections, library, history)`,
+    ];
+    if (apply) {
+        await client.rpc('sync_delete_profile_data', {
+            p_profile_id: profileIndex,
+            p_origin_client_id: originId,
+        });
+    }
+    return { applied: apply, changed: true, before: profileIndex, after: profileIndex, diff };
+}
+export async function copyProfileSetup(client, sourceProfileId, targetProfileId, options, originId, apply) {
+    if (sourceProfileId === targetProfileId) {
+        throw new NuvioError('Source and target profile must differ.');
+    }
+    const before = {
+        source_profile_id: sourceProfileId,
+        target_profile_id: targetProfileId,
+        tv: options.copy_tv ?? true,
+        mobile: options.copy_mobile ?? true,
+        desktop: options.copy_desktop ?? false,
+        provider_credentials: options.copy_provider_credentials ?? false,
+        replace_provider_credentials: options.replace_provider_credentials ?? false,
+    };
+    const diff = [
+        `~ copy setup ${sourceProfileId} -> ${targetProfileId}`,
+        `  tv=${before.tv} mobile=${before.mobile} desktop=${before.desktop} credentials=${before.provider_credentials}`,
+    ];
+    if (apply) {
+        await client.rpc('sync_copy_profile_setup', {
+            p_source_profile_id: sourceProfileId,
+            p_target_profile_id: targetProfileId,
+            p_copy_tv: before.tv,
+            p_copy_mobile: before.mobile,
+            p_copy_desktop: before.desktop,
+            p_copy_provider_credentials: before.provider_credentials,
+            p_replace_provider_credentials: before.replace_provider_credentials,
+            p_origin_client_id: originId,
+        });
+    }
+    return { applied: apply, changed: true, before, after: before, diff };
+}
+export async function setProfilePin(client, profileIndex, pin, currentPin, apply) {
+    if (!pin)
+        throw new NuvioError('pin is required');
+    if (apply) {
+        await client.rpc('set_profile_pin', {
+            p_profile_id: profileIndex,
+            p_pin: pin,
+            p_current_pin: currentPin ?? null,
+        });
+    }
+    return {
+        applied: apply,
+        changed: true,
+        before: profileIndex,
+        after: profileIndex,
+        diff: [`~ set PIN for profile ${profileIndex}`],
+    };
+}
+export async function clearProfilePin(client, profileIndex, currentPin, apply) {
+    if (apply) {
+        await client.rpc('clear_profile_pin', {
+            p_profile_id: profileIndex,
+            p_current_pin: currentPin ?? null,
+        });
+    }
+    return {
+        applied: apply,
+        changed: true,
+        before: profileIndex,
+        after: profileIndex,
+        diff: [`- clear PIN for profile ${profileIndex}`],
+    };
+}

package/dist/nuvio/ops/providers.js

@@ -0,0 +1,103 @@
+import { NuvioError } from '../errors.js';
+import { fetchJsonFromPublicUrl } from '../safe-fetch.js';
+function looksLikeKey(value) {
+    const v = value.trim();
+    return v.length >= 8 && v.length <= 200 && !/\s/.test(v);
+}
+/** Provider endpoints that can validate a key with a cheap read. */
+const LIVE_CHECKS = {
+    tmdb: (key) => `https://api.themoviedb.org/3/configuration?api_key=${encodeURIComponent(key)}`,
+    mdblist: (key) => `https://mdblist.com/api/?apikey=${encodeURIComponent(key)}`,
+};
+/**
+ * Verify a provider credential WITHOUT storing it. Never returns or logs the
+ * secret itself. Live checks are best-effort and only run for providers with a
+ * cheap public endpoint; others report format validation only.
+ */
+export async function testProviderCredential(provider, value) {
+    const key = provider.trim().toLowerCase();
+    if (!PROVIDER_CREDENTIAL_FIELD[key]) {
+        throw new NuvioError(`Unsupported provider "${provider}". Supported: ${Object.keys(PROVIDER_CREDENTIAL_FIELD).join(', ')}`);
+    }
+    if (!value.trim())
+        return { provider: key, format_valid: false, verified: false, detail: 'Credential is empty.' };
+    const formatValid = looksLikeKey(value);
+    if (!formatValid) {
+        return { provider: key, format_valid: false, verified: false, detail: 'Credential looks malformed.' };
+    }
+    const check = LIVE_CHECKS[key];
+    if (!check) {
+        return {
+            provider: key,
+            format_valid: true,
+            verified: null,
+            detail: 'Format accepted; this provider cannot be verified without a live call.',
+        };
+    }
+    try {
+        await fetchJsonFromPublicUrl(check(value.trim()));
+        return { provider: key, format_valid: true, verified: true, detail: 'Provider accepted the credential.' };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        // Do not echo the secret; the message comes from the HTTP layer only.
+        return { provider: key, format_valid: true, verified: false, detail: `Verification failed: ${message}` };
+    }
+}
+/** Provider credential layouts accepted by the backend. */
+export const PROVIDER_CREDENTIAL_FIELD = {
+    'debrid:torbox': 'api_key',
+    'debrid:premiumize': 'api_key',
+    'debrid:realdebrid': 'api_key',
+    tmdb: 'api_key',
+    mdblist: 'api_key',
+    introdb: 'api_key',
+    animeskip: 'client_id',
+};
+export async function listProviderCredentials(client, profileId) {
+    return client.readRpc('sync_pull_provider_credentials', { p_profile_id: profileId });
+}
+function normalizeProvider(provider) {
+    const key = provider.trim().toLowerCase();
+    const field = PROVIDER_CREDENTIAL_FIELD[key];
+    if (!field) {
+        throw new NuvioError(`Unsupported provider "${provider}". Supported: ${Object.keys(PROVIDER_CREDENTIAL_FIELD).join(', ')}`);
+    }
+    return { provider: key, field };
+}
+export async function setProviderCredential(client, profileId, provider, value, originId, apply) {
+    const { provider: key, field } = normalizeProvider(provider);
+    if (!value.trim())
+        throw new NuvioError('Credential value cannot be empty');
+    const before = await listProviderCredentials(client, profileId);
+    const credential_json = { [field]: value.trim() };
+    const exists = before.some((c) => c.provider === key);
+    const after = exists
+        ? before.map((c) => (c.provider === key ? { ...c, credential_json } : c))
+        : [...before, { provider: key, credential_json }];
+    const diff = [exists ? `~ update credential for ${key}` : `+ add credential for ${key}`];
+    if (apply) {
+        await client.rpc('sync_push_provider_credentials', {
+            p_profile_id: profileId,
+            p_credentials: [{ provider: key, credential_json }],
+            p_origin_client_id: originId,
+        });
+    }
+    return { applied: apply, changed: true, before, after, diff };
+}
+export async function deleteProviderCredential(client, profileId, provider, originId, apply) {
+    const { provider: key } = normalizeProvider(provider);
+    const before = await listProviderCredentials(client, profileId);
+    if (!before.some((c) => c.provider === key)) {
+        throw new NuvioError(`No credential stored for provider "${key}" on profile ${profileId}`);
+    }
+    const after = before.filter((c) => c.provider !== key);
+    if (apply) {
+        await client.rpc('sync_delete_provider_credentials', {
+            p_profile_id: profileId,
+            p_provider: key,
+            p_origin_client_id: originId,
+        });
+    }
+    return { applied: apply, changed: true, before, after, diff: [`- remove credential for ${key}`] };
+}

package/dist/nuvio/ops/readers.js

@@ -0,0 +1,57 @@
+import { NuvioError } from '../errors.js';
+/**
+ * Shared, complete readers used by both the mutation/snapshot paths and the
+ * public list tools. A reader that cannot prove it fetched the whole resource
+ * throws instead of silently returning a truncated state (which would make undo
+ * unsound).
+ */
+export const READ_PAGE = 1000;
+export const MAX_SAFE_PAGES = 25; // 25_000 rows
+export const PROGRESS_FETCH_LIMIT = 20000;
+export async function readAllLibrary(client, profileId) {
+    const all = [];
+    for (let page = 0; page < MAX_SAFE_PAGES; page += 1) {
+        const offset = page * READ_PAGE;
+        const rows = await client.readRpc('sync_pull_library', {
+            p_profile_id: profileId,
+            p_limit: READ_PAGE,
+            p_offset: offset,
+        });
+        all.push(...rows);
+        if (rows.length < READ_PAGE)
+            return all;
+    }
+    throw new NuvioError('Cannot create a complete reversible snapshot: library exceeds the safety limit of ' +
+        `${MAX_SAFE_PAGES * READ_PAGE} rows.`);
+}
+export async function readAllWatchHistory(client, profileId) {
+    const all = [];
+    for (let page = 1; page <= MAX_SAFE_PAGES; page += 1) {
+        const rows = await client.readRpc('sync_pull_watched_items', {
+            p_profile_id: profileId,
+            p_page: page,
+            p_page_size: READ_PAGE,
+        });
+        all.push(...rows);
+        if (rows.length < READ_PAGE)
+            return all;
+    }
+    throw new NuvioError('Cannot create a complete reversible snapshot: watch history exceeds the safety limit of ' +
+        `${MAX_SAFE_PAGES * READ_PAGE} rows.`);
+}
+/**
+ * The backend exposes no pagination contract for watch progress. We request a
+ * large batch; if it comes back full we cannot prove it is complete, so a
+ * reversible mutation must refuse rather than snapshot a partial state.
+ */
+export async function readAllWatchProgress(client, profileId, options = {}) {
+    const rows = await client.readRpc('sync_pull_watch_progress', {
+        p_profile_id: profileId,
+        p_limit: PROGRESS_FETCH_LIMIT,
+    });
+    if (options.requireComplete && rows.length >= PROGRESS_FETCH_LIMIT) {
+        throw new NuvioError('Cannot create a complete reversible snapshot: watch progress may be truncated at the fetch limit of ' +
+            `${PROGRESS_FETCH_LIMIT}.`);
+    }
+    return rows;
+}