@onpeek/nuvio 1.0.0

package/dist/commands/index.js

@@ -0,0 +1,26 @@
+import { definePlanMutation } from './helpers.js';
+import { registerProfileCommands } from './profiles.js';
+import { registerAddonCommands } from './addons.js';
+import { registerPluginCommands } from './plugins.js';
+import { registerSettingsCommands } from './settings.js';
+import { registerCollectionCommands } from './collections.js';
+import { registerLibraryCommands } from './library.js';
+import { registerProviderCommands } from './providers.js';
+import { registerTrackerCommands } from './trackers.js';
+import { registerSessionCommands } from './sessions.js';
+import { registerAccountCommands } from './account.js';
+import { registerUndoCommands } from './undo.js';
+export function registerAllCommands(registry, client, cfg) {
+    registerProfileCommands(registry, client, cfg);
+    registerAddonCommands(registry, client, cfg);
+    registerPluginCommands(registry, client, cfg);
+    registerSettingsCommands(registry, client, cfg);
+    registerCollectionCommands(registry, client, cfg);
+    registerLibraryCommands(registry, client, cfg);
+    registerProviderCommands(registry, client, cfg);
+    registerTrackerCommands(registry, client, cfg);
+    registerSessionCommands(registry, client, cfg);
+    registerAccountCommands(registry, client, cfg);
+    registerUndoCommands(registry, client, cfg);
+    definePlanMutation(registry, client, cfg);
+}

package/dist/commands/library.js

@@ -0,0 +1,105 @@
+import { z } from 'zod';
+import { defineMutation, defineRead } from './helpers.js';
+import { historyAddShape, historyDeleteShape, libraryAddShape, libraryRemoveShape, progressDeleteShape, progressSetShape, profile, } from '../nuvio/schemas.js';
+import * as library from '../nuvio/ops/library.js';
+export function registerLibraryCommands(registry, client, cfg) {
+    const originId = cfg.originClientId;
+    const resource = (kind) => (args) => ({ kind, profile_id: args.profile_id });
+    defineRead(registry, client, cfg, {
+        name: 'nuvio_get_library',
+        title: 'Get library',
+        description: "List items in a profile's library (bookmarks/favourites).",
+        risk: 'read',
+        schema: {
+            profile_id: profile,
+            limit: z.number().int().min(1).max(1000).default(100),
+            offset: z.number().int().min(0).default(0),
+        },
+        handler: (args) => library.getLibrary(client, args.profile_id, args.limit, args.offset),
+    });
+    defineMutation(registry, client, cfg, {
+        name: 'nuvio_add_to_library',
+        title: 'Add to library',
+        description: 'Add or update library items in bulk (upsert by content_id + content_type).',
+        risk: 'write',
+        resource: resource('library'),
+        scope: (args) => args.items.map((i) => ({ content_id: i.content_id, content_type: i.content_type })),
+        schema: libraryAddShape,
+        handler: (args, ctx) => library.addToLibrary(client, args.profile_id, args.items, originId, ctx.apply),
+    });
+    defineMutation(registry, client, cfg, {
+        name: 'nuvio_remove_from_library',
+        title: 'Remove from library',
+        description: "Remove items from a profile's library by content_id + content_type.",
+        risk: 'destructive',
+        resource: resource('library'),
+        scope: (args) => args.keys,
+        schema: libraryRemoveShape,
+        handler: (args, ctx) => library.removeFromLibrary(client, args.profile_id, args.keys, originId, ctx.apply),
+    });
+    defineRead(registry, client, cfg, {
+        name: 'nuvio_get_watch_progress',
+        title: 'Get watch progress',
+        description: 'List "continue watching" progress entries for a profile.',
+        risk: 'read',
+        schema: { profile_id: profile, limit: z.number().int().min(1).max(100000).default(100) },
+        handler: (args) => library.getWatchProgress(client, args.profile_id, args.limit),
+    });
+    defineMutation(registry, client, cfg, {
+        name: 'nuvio_set_watch_progress',
+        title: 'Set watch progress',
+        description: 'Create or update continue-watching entries (position/duration) for movies or episodes, in bulk.',
+        risk: 'write',
+        resource: resource('watch_progress'),
+        scope: (args) => args.entries.map((e) => library.progressKeyOf(e)),
+        schema: progressSetShape,
+        handler: (args, ctx) => library.setWatchProgress(client, args.profile_id, args.entries, originId, ctx.apply),
+    });
+    defineMutation(registry, client, cfg, {
+        name: 'nuvio_delete_watch_progress',
+        title: 'Delete watch progress',
+        description: 'Delete continue-watching entries using structured keys (content_id + optional season/episode).',
+        risk: 'destructive',
+        resource: resource('watch_progress'),
+        scope: (args) => args.keys.map((k) => library.progressKeyOf(k)),
+        schema: progressDeleteShape,
+        handler: (args, ctx) => library.deleteWatchProgress(client, args.profile_id, args.keys, originId, ctx.apply),
+    });
+    defineRead(registry, client, cfg, {
+        name: 'nuvio_get_watch_history',
+        title: 'Get watch history',
+        description: 'List watched items for a profile.',
+        risk: 'read',
+        schema: {
+            profile_id: profile,
+            page: z.number().int().min(1).default(1).describe('Page number (1-based)'),
+            page_size: z.number().int().min(1).max(1000).default(100),
+        },
+        handler: (args) => library.getWatchHistory(client, args.profile_id, args.page, args.page_size),
+    });
+    defineMutation(registry, client, cfg, {
+        name: 'nuvio_add_to_watch_history',
+        title: 'Add to watch history',
+        description: "Idempotently add watched items to a profile's history (upsert by content_id + season + episode). " +
+            'A repeated identical call does not create a duplicate.',
+        risk: 'write',
+        resource: resource('watch_history'),
+        scope: (args) => args.items.map((i) => ({
+            content_id: i.content_id,
+            season: i.season ?? null,
+            episode: i.episode ?? null,
+        })),
+        schema: historyAddShape,
+        handler: (args, ctx) => library.addToWatchHistory(client, args.profile_id, args.items, originId, ctx.apply),
+    });
+    defineMutation(registry, client, cfg, {
+        name: 'nuvio_delete_watch_history',
+        title: 'Delete watch history',
+        description: 'Delete watch-history entries by content id (and season/episode).',
+        risk: 'destructive',
+        resource: resource('watch_history'),
+        scope: (args) => args.keys,
+        schema: historyDeleteShape,
+        handler: (args, ctx) => library.deleteWatchHistory(client, args.profile_id, args.keys, originId, ctx.apply),
+    });
+}

package/dist/commands/plugins.js

@@ -0,0 +1,58 @@
+import { defineMutation, defineRead } from './helpers.js';
+import { assertTarget, pluginAddShape, pluginRemoveShape, pluginReorderShape, pluginUpdateShape, profile, } from '../nuvio/schemas.js';
+import * as plugins from '../nuvio/ops/plugins.js';
+export function registerPluginCommands(registry, client, cfg) {
+    const originId = cfg.originClientId;
+    const resource = (args) => ({ kind: 'plugins', profile_id: args.profile_id });
+    defineRead(registry, client, cfg, {
+        name: 'nuvio_list_plugins',
+        title: 'List plugins',
+        description: 'List plugins installed on a profile.',
+        risk: 'read',
+        schema: { profile_id: profile },
+        handler: (args) => plugins.listPlugins(client, args.profile_id),
+    });
+    defineMutation(registry, client, cfg, {
+        name: 'nuvio_add_plugin',
+        title: 'Install a plugin',
+        description: 'Install a plugin on a profile by URL, preserving the existing plugin list.',
+        risk: 'write',
+        resource,
+        schema: pluginAddShape,
+        handler: (args, ctx) => plugins.addPlugin(client, args.profile_id, args, originId, ctx.apply),
+    });
+    defineMutation(registry, client, cfg, {
+        name: 'nuvio_update_plugin',
+        title: 'Update a plugin',
+        description: 'Change a plugin name, enabled flag, repo type or sort order. Identify it by url or table id.',
+        risk: 'write',
+        resource,
+        schema: pluginUpdateShape,
+        handler: (args, ctx) => {
+            assertTarget('nuvio_update_plugin', args);
+            const { profile_id, url, id, ...changes } = args;
+            return plugins.updatePlugin(client, profile_id, { url, id }, changes, originId, ctx.apply);
+        },
+    });
+    defineMutation(registry, client, cfg, {
+        name: 'nuvio_reorder_plugins',
+        title: 'Reorder plugins',
+        description: 'Set plugin order. Provide every installed plugin URL exactly once, in the desired order.',
+        risk: 'write',
+        resource,
+        schema: pluginReorderShape,
+        handler: (args, ctx) => plugins.reorderPlugins(client, args.profile_id, args.ordered_urls, originId, ctx.apply),
+    });
+    defineMutation(registry, client, cfg, {
+        name: 'nuvio_remove_plugin',
+        title: 'Remove a plugin',
+        description: 'Uninstall a plugin from a profile.',
+        risk: 'destructive',
+        resource,
+        schema: pluginRemoveShape,
+        handler: (args, ctx) => {
+            assertTarget('nuvio_remove_plugin', args);
+            return plugins.removePlugin(client, args.profile_id, { url: args.url, id: args.id }, originId, ctx.apply);
+        },
+    });
+}

package/dist/commands/profiles.js

@@ -0,0 +1,126 @@
+import { z } from 'zod';
+import { defineMutation, defineRead } from './helpers.js';
+import * as profiles from '../nuvio/ops/profiles.js';
+const index = z.number().int().min(1).max(6);
+export function registerProfileCommands(registry, client, cfg) {
+    const originId = cfg.originClientId;
+    defineRead(registry, client, cfg, {
+        name: 'nuvio_list_profiles',
+        title: 'List Nuvio profiles',
+        description: 'List all profiles (slot 1..6, name, avatar, flags, PIN lock state).',
+        risk: 'read',
+        schema: {},
+        handler: () => profiles.listProfiles(client),
+    });
+    defineMutation(registry, client, cfg, {
+        name: 'nuvio_create_profile',
+        title: 'Create a Nuvio profile',
+        description: 'Add a new profile, preserving every existing one. Max 6 profiles; slot 1 is primary.',
+        risk: 'write',
+        resource: { kind: 'profiles' },
+        schema: {
+            name: z.string().min(1),
+            profile_id: index.optional().describe('Slot 1..6; auto-picked if omitted'),
+            avatar_color_hex: z
+                .string()
+                .regex(/^#[0-9a-fA-F]{6}$/)
+                .optional(),
+            avatar_id: z.string().optional().describe('Avatar catalog id (see nuvio_list_avatars)'),
+            avatar_url: z.url().optional(),
+            uses_primary_addons: z.boolean().optional().describe('Share addons with profile 1'),
+        },
+        handler: (args, ctx) => profiles.createProfile(client, {
+            name: args.name,
+            profile_index: args.profile_id,
+            avatar_color_hex: args.avatar_color_hex,
+            avatar_id: args.avatar_id,
+            avatar_url: args.avatar_url,
+            uses_primary_addons: args.uses_primary_addons,
+        }, originId, ctx.apply),
+    });
+    defineMutation(registry, client, cfg, {
+        name: 'nuvio_update_profile',
+        title: 'Update a Nuvio profile',
+        description: 'Sparsely update one profile (name, avatar color, avatar id/url, uses_primary_addons).',
+        risk: 'write',
+        resource: { kind: 'profiles' },
+        schema: {
+            profile_id: index,
+            name: z.string().min(1).optional(),
+            avatar_color_hex: z
+                .string()
+                .regex(/^#[0-9a-fA-F]{6}$/)
+                .optional(),
+            avatar_id: z.string().nullable().optional(),
+            avatar_url: z.url().nullable().optional(),
+            uses_primary_addons: z.boolean().optional(),
+        },
+        handler: (args, ctx) => profiles.updateProfile(client, args.profile_id, {
+            name: args.name,
+            avatar_color_hex: args.avatar_color_hex,
+            ...('avatar_id' in args ? { avatar_id: args.avatar_id } : {}),
+            ...('avatar_url' in args ? { avatar_url: args.avatar_url } : {}),
+            uses_primary_addons: args.uses_primary_addons,
+        }, ctx.apply),
+    });
+    defineMutation(registry, client, cfg, {
+        name: 'nuvio_delete_profile',
+        title: 'Delete a Nuvio profile',
+        description: 'Delete a profile and ALL of its data (addons, settings, collections, library, history). Profile 1 cannot be deleted and this cannot be undone.',
+        risk: 'destructive',
+        resource: { kind: 'profiles' },
+        reversible: false,
+        note: 'profile data is deleted permanently and cannot be restored from a snapshot',
+        schema: { profile_id: index.min(2) },
+        handler: (args, ctx) => profiles.deleteProfile(client, args.profile_id, originId, ctx.apply),
+    });
+    defineMutation(registry, client, cfg, {
+        name: 'nuvio_copy_setup',
+        title: 'Copy setup between profiles',
+        description: 'Copy a profile setup to another profile, optionally across platforms (platforms: [{from,to}], defaults to ' +
+            'identity per platform). Settings are deep-merged (settings_mode=merge) or replaced (replace); provider ' +
+            'credentials can be left alone, merged, or replaced. Transactional: on failure it rolls back and reports ' +
+            'whether the rollback completed.',
+        risk: 'write',
+        resource: (args) => ({ kind: 'profile_setup', profile_id: args.target_profile_id }),
+        schema: {
+            source_profile_id: index,
+            target_profile_id: index,
+            platforms: z
+                .array(z.object({ from: z.enum(profiles.SETUP_PLATFORMS), to: z.enum(profiles.SETUP_PLATFORMS) }))
+                .optional()
+                .describe('Platform mappings (e.g. tv -> mobile). Defaults to tv->tv, mobile->mobile, desktop->desktop.'),
+            settings_mode: z.enum(['merge', 'replace']).optional().default('merge'),
+            provider_credentials: z.enum(['none', 'merge', 'replace']).optional().default('none'),
+        },
+        handler: (args, ctx) => profiles.copySetup(client, {
+            source_profile_id: args.source_profile_id,
+            target_profile_id: args.target_profile_id,
+            platforms: args.platforms,
+            settings_mode: args.settings_mode,
+            provider_credentials: args.provider_credentials,
+        }, originId, ctx.apply),
+    });
+    defineMutation(registry, client, cfg, {
+        name: 'nuvio_set_profile_pin',
+        title: 'Set a profile PIN',
+        description: 'Set or change the PIN lock on a profile. Not reversible (the PIN hash is never returned).',
+        risk: 'destructive',
+        resource: { kind: 'profiles' },
+        reversible: false,
+        note: 'PIN changes cannot be reversed automatically',
+        schema: { profile_id: index, pin: z.string().min(1), current_pin: z.string().optional() },
+        handler: (args, ctx) => profiles.setProfilePin(client, args.profile_id, args.pin, args.current_pin, ctx.apply),
+    });
+    defineMutation(registry, client, cfg, {
+        name: 'nuvio_clear_profile_pin',
+        title: 'Clear a profile PIN',
+        description: 'Remove the PIN lock from a profile. Not reversible.',
+        risk: 'destructive',
+        resource: { kind: 'profiles' },
+        reversible: false,
+        note: 'PIN changes cannot be reversed automatically',
+        schema: { profile_id: index, current_pin: z.string().optional() },
+        handler: (args, ctx) => profiles.clearProfilePin(client, args.profile_id, args.current_pin, ctx.apply),
+    });
+}

package/dist/commands/providers.js

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import { defineMutation, defineRead } from './helpers.js';
+import { PROVIDER_CREDENTIAL_FIELD, listProviderCredentials, setProviderCredential, deleteProviderCredential, testProviderCredential, } from '../nuvio/ops/providers.js';
+import { providerSetShape } from '../nuvio/schemas.js';
+export function registerProviderCommands(registry, client, cfg) {
+    const originId = cfg.originClientId;
+    const profile = z.number().int().min(1).max(6).default(1);
+    const resource = (args) => ({ kind: 'provider_credentials', profile_id: args.profile_id });
+    defineRead(registry, client, cfg, {
+        name: 'nuvio_list_provider_credentials',
+        title: 'List provider credentials',
+        description: 'List configured providers for a profile (debrid services, TMDB, MDBList, AniSkip, IntroDB). Secret values are masked.',
+        risk: 'read',
+        schema: { profile_id: profile },
+        handler: async (args) => {
+            const rows = await listProviderCredentials(client, args.profile_id);
+            return {
+                supported_providers: Object.keys(PROVIDER_CREDENTIAL_FIELD),
+                configured: rows.map((row) => ({
+                    provider: row.provider,
+                    configured: true,
+                    updated_at: row.updated_at,
+                })),
+            };
+        },
+    });
+    defineMutation(registry, client, cfg, {
+        name: 'nuvio_set_provider_credential',
+        title: 'Set a provider credential',
+        description: 'Store an API key for a provider: debrid:torbox, debrid:premiumize, debrid:realdebrid, tmdb, mdblist, introdb (api key) or animeskip (client id).',
+        risk: 'write',
+        resource,
+        schema: providerSetShape,
+        handler: (args, ctx) => setProviderCredential(client, args.profile_id, args.provider, args.api_key, originId, ctx.apply),
+    });
+    defineRead(registry, client, cfg, {
+        name: 'nuvio_test_provider_credential',
+        title: 'Test a provider credential',
+        description: 'Verify a provider credential without storing it. The secret is never returned or logged; the result ' +
+            'reports format validity and, where the provider exposes a cheap endpoint, a live check.',
+        risk: 'read',
+        schema: {
+            provider: z.string().describe('One of the supported provider ids'),
+            api_key: z.string().min(1).describe('API key / client id value to verify'),
+        },
+        handler: (args) => testProviderCredential(args.provider, args.api_key),
+    });
+    defineMutation(registry, client, cfg, {
+        name: 'nuvio_delete_provider_credential',
+        title: 'Delete a provider credential',
+        description: 'Remove a stored provider credential from a profile.',
+        risk: 'destructive',
+        resource,
+        schema: { profile_id: profile, provider: z.string() },
+        handler: (args, ctx) => deleteProviderCredential(client, args.profile_id, args.provider, originId, ctx.apply),
+    });
+}

package/dist/commands/sessions.js

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { defineMutation, defineRead } from './helpers.js';
+import * as sessions from '../nuvio/ops/sessions.js';
+export function registerSessionCommands(registry, client, cfg) {
+    defineRead(registry, client, cfg, {
+        name: 'nuvio_list_sessions',
+        title: 'List signed-in devices',
+        description: 'List active login sessions/devices (device name, platform, client, last active, which is current).',
+        risk: 'read',
+        schema: {},
+        handler: () => sessions.listSessions(client),
+    });
+    defineMutation(registry, client, cfg, {
+        name: 'nuvio_revoke_session',
+        title: 'Log out a device',
+        description: 'Revoke one login session (log that device out). Cannot be undone — the device must sign in again. Never deletes the account.',
+        risk: 'destructive',
+        resource: { kind: 'sessions' },
+        reversible: false,
+        note: 'revoked sessions cannot be recreated; the device needs to sign in again',
+        schema: { session_id: z.uuid() },
+        handler: (args, ctx) => sessions.revokeSession(client, args.session_id, ctx.apply),
+    });
+    defineMutation(registry, client, cfg, {
+        name: 'nuvio_register_device',
+        title: 'Register this device',
+        description: "Register a device/installation against the account. client_name must be one the Nuvio backend accepts (for example 'Nuvio Web'); other values are rejected by the backend.",
+        risk: 'write',
+        resource: { kind: 'sessions' },
+        reversible: false,
+        schema: {
+            installation_id: z.string(),
+            client_name: z.string(),
+            client_version: z.string().optional(),
+            device_name: z.string().optional(),
+            platform: z.string().optional(),
+        },
+        handler: (args, ctx) => sessions.registerDevice(client, {
+            installation_id: args.installation_id,
+            client_name: args.client_name,
+            client_version: args.client_version,
+            device_name: args.device_name,
+            platform: args.platform,
+        }, ctx.apply),
+    });
+}

package/dist/commands/settings.js

@@ -0,0 +1,43 @@
+import { defineMutation, defineRead } from './helpers.js';
+import { getSettingsShape, updateSettingsShape } from '../nuvio/schemas.js';
+import * as settings from '../nuvio/ops/settings.js';
+export function registerSettingsCommands(registry, client, cfg) {
+    const originId = cfg.originClientId;
+    const settingsResource = (args) => ({ kind: 'settings', profile_id: args.profile_id, platform: args.platform });
+    const homeResource = (args) => ({ kind: 'home_catalog_settings', profile_id: args.profile_id, platform: args.platform });
+    defineRead(registry, client, cfg, {
+        name: 'nuvio_get_settings',
+        title: 'Get profile settings',
+        description: 'Read the JSON settings blob for a profile on a platform.',
+        risk: 'read',
+        schema: getSettingsShape,
+        handler: (args) => settings.getSettings(client, args.profile_id, args.platform),
+    });
+    defineMutation(registry, client, cfg, {
+        name: 'nuvio_update_settings',
+        title: 'Update profile settings',
+        description: 'Update a profile settings blob. `patch` is deep-merged (nested keys are preserved, arrays and scalars ' +
+            'replace), `set` assigns nested dot paths and `unset` deletes them — applied in the order patch, set, unset.',
+        risk: 'write',
+        resource: settingsResource,
+        schema: updateSettingsShape,
+        handler: (args, ctx) => settings.updateSettings(client, args.profile_id, args.platform, args, originId, ctx.apply),
+    });
+    defineMutation(registry, client, cfg, {
+        name: 'nuvio_update_home_catalog_settings',
+        title: 'Update home catalog settings',
+        description: 'Update the home screen layout/catalog blob with the same patch/set/unset semantics as nuvio_update_settings.',
+        risk: 'write',
+        resource: homeResource,
+        schema: updateSettingsShape,
+        handler: (args, ctx) => settings.updateHomeCatalogSettings(client, args.profile_id, args.platform, args, originId, ctx.apply),
+    });
+    defineRead(registry, client, cfg, {
+        name: 'nuvio_get_home_catalog_settings',
+        title: 'Get home catalog settings',
+        description: 'Read the home screen layout/catalog configuration for a profile on a platform.',
+        risk: 'read',
+        schema: getSettingsShape,
+        handler: (args) => settings.getHomeCatalogSettings(client, args.profile_id, args.platform),
+    });
+}

package/dist/commands/trackers.js

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+import { defineMutation, defineRead } from './helpers.js';
+import { TRACKERS, listTrackerTokens, listTrackerSettings, setTrackerSettings, setTrackerToken, unlinkTracker, } from '../nuvio/ops/trackers.js';
+export function registerTrackerCommands(registry, client, cfg) {
+    const profile = z.number().int().min(1).max(6).default(1);
+    const tracker = z.enum(TRACKERS).describe('Tracker: mal | anilist | kitsu');
+    defineRead(registry, client, cfg, {
+        name: 'nuvio_list_trackers',
+        title: 'List trackers',
+        description: 'List linked trackers (MAL / AniList / Kitsu) and their per-profile settings. Access tokens are masked.',
+        risk: 'read',
+        schema: { profile_id: profile },
+        handler: async (args) => {
+            const [tokens, settings] = await Promise.all([
+                listTrackerTokens(client, args.profile_id),
+                listTrackerSettings(client, args.profile_id),
+            ]);
+            const byTracker = new Map(settings.map((s) => [s.tracker, s]));
+            return TRACKERS.map((name) => {
+                const token = tokens.find((t) => t.tracker === name);
+                const setting = byTracker.get(name);
+                return {
+                    tracker: name,
+                    linked: Boolean(token),
+                    username: token?.tracker_username ?? null,
+                    expires_at: token?.expires_at ?? null,
+                    enabled_statuses: setting?.enabled_statuses ?? [],
+                    send_progress: setting?.send_progress ?? null,
+                };
+            });
+        },
+    });
+    defineMutation(registry, client, cfg, {
+        name: 'nuvio_set_tracker_settings',
+        title: 'Update tracker settings',
+        description: 'Set which statuses sync, row order and progress syncing for a linked tracker.',
+        risk: 'write',
+        resource: (args) => ({ kind: 'tracker_settings', profile_id: args.profile_id }),
+        schema: {
+            profile_id: profile,
+            tracker,
+            enabled_statuses: z.array(z.string()).optional(),
+            row_order: z.array(z.string()).optional(),
+            send_progress: z.boolean().optional(),
+        },
+        handler: (args, ctx) => setTrackerSettings(client, args.profile_id, args.tracker, {
+            enabled_statuses: args.enabled_statuses,
+            row_order: args.row_order,
+            send_progress: args.send_progress,
+        }, ctx.apply),
+    });
+    defineMutation(registry, client, cfg, {
+        name: 'nuvio_link_tracker',
+        title: 'Link a tracker',
+        description: 'Store tracker OAuth tokens for a profile. Use this only when tokens were obtained out-of-band; prefer the app sign-in flow.',
+        risk: 'write',
+        resource: (args) => ({ kind: 'tracker_tokens', profile_id: args.profile_id }),
+        schema: {
+            profile_id: profile,
+            tracker,
+            access_token: z.string().min(1),
+            refresh_token: z.string().optional(),
+            expires_in_seconds: z.number().int().positive().optional(),
+            tracker_user_id: z.string().optional(),
+            username: z.string().optional(),
+        },
+        handler: (args, ctx) => setTrackerToken(client, args.profile_id, args.tracker, {
+            access_token: args.access_token,
+            refresh_token: args.refresh_token,
+            expires_in_seconds: args.expires_in_seconds,
+            tracker_user_id: args.tracker_user_id,
+            username: args.username,
+        }, ctx.apply),
+    });
+    defineMutation(registry, client, cfg, {
+        name: 'nuvio_unlink_tracker',
+        title: 'Unlink a tracker',
+        description: 'Remove stored tokens for a tracker on a profile.',
+        risk: 'destructive',
+        resource: (args) => ({ kind: 'tracker_tokens', profile_id: args.profile_id }),
+        schema: { profile_id: profile, tracker },
+        handler: (args, ctx) => unlinkTracker(client, args.profile_id, args.tracker, ctx.apply),
+    });
+}