@labelgrid/mcp 0.2.2 → 0.3.0

package/dist/tools/catalog-write.js

@@ -1,206 +0,0 @@
-/**
- * Catalog write toolset (safe writes): create/update/delete for labels,
- * artists, writers and publishers, plus multipart image uploads.
- *
- * Create/update forward a permissive `fields` object straight to the API, which
- * owns all validation — this keeps each tool a thin wrapper and lets the full
- * documented field set through without re-declaring it here. The tool
- * descriptions name the required and common fields; consult the LabelGrid API
- * docs for the complete list.
- */
-import { statSync } from 'node:fs';
-import { z } from 'zod';
-import { assertAllowedExtension } from '../api/content-types.js';
-/** Accepted image extensions for the catalog image uploads. */
-const IMAGE_EXTS = ['.jpg', '.jpeg', '.png', '.webp', '.tif', '.tiff'];
-/** A permissive body of API fields, forwarded verbatim to the endpoint. */
-function fieldsBody(desc) {
-    return z.record(z.string(), z.unknown()).describe(desc);
-}
-/** Rejects a path that is not an existing regular file, before any HTTP call. */
-function fileError(p) {
-    let isFile = false;
-    try {
-        isFile = statSync(p).isFile();
-    }
-    catch {
-        isFile = false;
-    }
-    return isFile
-        ? null
-        : { code: 'FILE_NOT_FOUND', message: `No readable file at ${p}.`, status: 0 };
-}
-function createTool(spec) {
-    return {
-        name: spec.name,
-        toolset: 'catalog',
-        gate: 'safe_write',
-        title: spec.title,
-        description: spec.description,
-        inputShape: { fields: fieldsBody(spec.fieldsDesc) },
-        annotations: {},
-        handler: (args, { client }) => client.post(spec.path, args.fields),
-    };
-}
-function updateTool(spec) {
-    return {
-        name: spec.name,
-        toolset: 'catalog',
-        gate: 'safe_write',
-        title: spec.title,
-        description: spec.description,
-        inputShape: {
-            [spec.idField]: z.number().int().positive(),
-            fields: fieldsBody(spec.fieldsDesc),
-        },
-        annotations: {},
-        handler: (args, { client }) => client.patch(`${spec.basePath}/${args[spec.idField]}`, args.fields),
-    };
-}
-function deleteTool(spec) {
-    return {
-        name: spec.name,
-        toolset: 'catalog',
-        gate: 'safe_write',
-        title: spec.title,
-        description: spec.description,
-        inputShape: { [spec.idField]: z.number().int().positive() },
-        annotations: { destructiveHint: true },
-        handler: (args, { client }) => client.delete(`${spec.basePath}/${args[spec.idField]}`),
-    };
-}
-const uploadLabelImage = {
-    name: 'upload_label_image',
-    toolset: 'catalog',
-    gate: 'safe_write',
-    title: 'Upload a label image',
-    description: 'Upload a label image from a local file. `image_type` selects which asset: logo, logo-dark (a dark-mode variant), or background. `file_path` must be a local image file.',
-    inputShape: {
-        label_id: z.number().int().positive(),
-        image_type: z.enum(['logo', 'logo-dark', 'background']),
-        file_path: z.string().describe('Local path to the image file to upload.'),
-    },
-    annotations: {},
-    handler: async (args, { client }) => {
-        const err = fileError(args.file_path);
-        if (err)
-            return { error: err };
-        const ext = assertAllowedExtension(args.file_path, IMAGE_EXTS);
-        if ('error' in ext)
-            return { error: ext.error };
-        return client.postMultipart(`/labels/${args.label_id}/images/${args.image_type}`, ext.realPath, 'file');
-    },
-};
-const uploadArtistPhoto = {
-    name: 'upload_artist_photo',
-    toolset: 'catalog',
-    gate: 'safe_write',
-    title: 'Upload an artist photo',
-    description: 'Upload an artist photo from a local file. `file_path` must be a local image file.',
-    inputShape: {
-        artist_id: z.number().int().positive(),
-        file_path: z.string().describe('Local path to the photo file to upload.'),
-    },
-    annotations: {},
-    handler: async (args, { client }) => {
-        const err = fileError(args.file_path);
-        if (err)
-            return { error: err };
-        const ext = assertAllowedExtension(args.file_path, IMAGE_EXTS);
-        if ('error' in ext)
-            return { error: ext.error };
-        return client.postMultipart(`/artists/${args.artist_id}/photo`, ext.realPath, 'file');
-    },
-};
-export const catalogWriteTools = [
-    createTool({
-        name: 'create_label',
-        path: '/labels',
-        title: 'Create a label',
-        description: 'Create a new label. Pass its attributes in `fields`.',
-        fieldsDesc: 'Label attributes. Required: name (string), default_email (string). Common optional: active, support_email, website_url, spotify_url, applemusic_url, default_copyright_name_p_line, default_copyright_name_c_line, isrc_base, enable_website, image. See the API docs for the full field list.',
-    }),
-    updateTool({
-        name: 'update_label',
-        idField: 'label_id',
-        basePath: '/labels',
-        title: 'Update a label',
-        description: 'Update a label. Supply only the fields you want to change in `fields`.',
-        fieldsDesc: 'Label fields to change (same field set as create_label). Supply only what changes.',
-    }),
-    deleteTool({
-        name: 'delete_label',
-        idField: 'label_id',
-        basePath: '/labels',
-        title: 'Delete a label',
-        description: 'Delete a label. The API refuses to delete a label that still has releases — remove or reassign its releases first.',
-    }),
-    uploadLabelImage,
-    createTool({
-        name: 'create_artist',
-        path: '/artists',
-        title: 'Create an artist',
-        description: 'Create a new artist. Pass its attributes in `fields`.',
-        fieldsDesc: 'Artist attributes. Required: artist_name (string). Common optional: full_name, email, location, bio_short, bio_full, isni, default_language, and platform profile URLs (spotify_url, applemusic_url, youtube_url, etc.). See the API docs for the full field list.',
-    }),
-    updateTool({
-        name: 'update_artist',
-        idField: 'artist_id',
-        basePath: '/artists',
-        title: 'Update an artist',
-        description: 'Update an artist. Supply only the fields you want to change in `fields`.',
-        fieldsDesc: 'Artist fields to change (same field set as create_artist). Supply only what changes.',
-    }),
-    deleteTool({
-        name: 'delete_artist',
-        idField: 'artist_id',
-        basePath: '/artists',
-        title: 'Delete an artist',
-        description: 'Delete an artist. The API refuses deletion when the artist is still referenced by releases or tracks.',
-    }),
-    uploadArtistPhoto,
-    createTool({
-        name: 'create_writer',
-        path: '/writers',
-        title: 'Create a writer',
-        description: 'Create a new songwriter. Pass its attributes in `fields`.',
-        fieldsDesc: 'Writer attributes. Required: first_name (string), last_name (string). Common optional: middle_name, display_credits, email, country, pro, ipi, isni, publisher_id (or publisher_name/publisher_pro/publisher_ipi). See the API docs for the full field list.',
-    }),
-    updateTool({
-        name: 'update_writer',
-        idField: 'writer_id',
-        basePath: '/writers',
-        title: 'Update a writer',
-        description: 'Update a writer. Supply only the fields you want to change in `fields`.',
-        fieldsDesc: 'Writer fields to change (same field set as create_writer). Supply only what changes.',
-    }),
-    deleteTool({
-        name: 'delete_writer',
-        idField: 'writer_id',
-        basePath: '/writers',
-        title: 'Delete a writer',
-        description: 'Delete a writer. The API refuses deletion when the writer is still referenced by tracks.',
-    }),
-    createTool({
-        name: 'create_publisher',
-        path: '/publishers',
-        title: 'Create a publisher',
-        description: 'Create a new publisher. Pass its attributes in `fields`.',
-        fieldsDesc: 'Publisher attributes. Required: name (string). Common optional: ipi, pro, isni, controlled_publisher. See the API docs for the full field list.',
-    }),
-    updateTool({
-        name: 'update_publisher',
-        idField: 'publisher_id',
-        basePath: '/publishers',
-        title: 'Update a publisher',
-        description: 'Update a publisher. Supply only the fields you want to change in `fields`.',
-        fieldsDesc: 'Publisher fields to change (same field set as create_publisher). Supply only what changes.',
-    }),
-    deleteTool({
-        name: 'delete_publisher',
-        idField: 'publisher_id',
-        basePath: '/publishers',
-        title: 'Delete a publisher',
-        description: 'Delete a publisher. The API refuses deletion when the publisher is still referenced by writers.',
-    }),
-];

package/dist/tools/delivery.d.ts

@@ -1,6 +0,0 @@
-/**
- * Delivery reads: the distribution queue and a release's smart-link landing
- * page configuration. Both read-only, in the `delivery` toolset.
- */
-import type { ToolDef } from './types.js';
-export declare const deliveryTools: ToolDef[];

package/dist/tools/delivery.js

@@ -1,40 +0,0 @@
-/**
- * Delivery reads: the distribution queue and a release's smart-link landing
- * page configuration. Both read-only, in the `delivery` toolset.
- */
-import { z } from 'zod';
-const getDeliveryQueue = {
-    name: 'get_delivery_queue',
-    toolset: 'delivery',
-    gate: 'read',
-    title: 'Get the distribution queue',
-    description: 'List the distribution queue entries for your account, paginated — one entry per (release, outlet) delivery with its current status (e.g. pending review, processing, scheduled, complete, error). Filter by `release_id`, `outlet_id`, or `status`. Use this to see where a release is in the delivery pipeline to each store.',
-    inputShape: {
-        release_id: z.number().int().positive().optional().describe('Filter to one release.'),
-        outlet_id: z.number().int().positive().optional().describe('Filter to one outlet/store.'),
-        status: z.string().optional().describe('Filter by delivery status.'),
-        page: z.number().int().positive().optional(),
-        per_page: z.number().int().positive().optional(),
-    },
-    annotations: { readOnlyHint: true },
-    handler: (args, { client }) => client.get('/queues/distro', {
-        page: args.page,
-        per_page: args.per_page,
-        filter: {
-            release_id: args.release_id,
-            outlet_id: args.outlet_id,
-            status: args.status,
-        },
-    }),
-};
-const getLandingConfig = {
-    name: 'get_landing_config',
-    toolset: 'delivery',
-    gate: 'read',
-    title: 'Get a release landing-page config',
-    description: 'Retrieve the smart-link landing-page configuration for a release: whether the links page is enabled, its style/mode, custom copy, the action list and any pre-order links. Pair with update_landing_config to change it.',
-    inputShape: { release_id: z.number().int().positive() },
-    annotations: { readOnlyHint: true },
-    handler: (args, { client }) => client.get(`/releases/${args.release_id}/landing-config`),
-};
-export const deliveryTools = [getDeliveryQueue, getLandingConfig];

package/dist/tools/files-read.d.ts

@@ -1,7 +0,0 @@
-/**
- * Catalog file reads: track and release asset lookups, a signed audio
- * download URL, and track license reads. All read-only, in the `catalog`
- * toolset.
- */
-import type { ToolDef } from './types.js';
-export declare const filesReadTools: ToolDef[];

package/dist/tools/files-read.js

@@ -1,86 +0,0 @@
-/**
- * Catalog file reads: track and release asset lookups, a signed audio
- * download URL, and track license reads. All read-only, in the `catalog`
- * toolset.
- */
-import { z } from 'zod';
-/** Track asset kinds the API exposes. */
-const TRACK_FILE_TYPE = z
-    .enum(['stereo', 'dolby', 'lyrics'])
-    .describe('Which track asset: stereo audio, Dolby Atmos audio, or the lyrics file.');
-/** Downloadable track audio asset kinds for the signed download-url endpoint. */
-const TRACK_DOWNLOAD_ASSET_TYPE = z
-    .enum(['audio_16', 'audio_24', 'audio_32', 'audio_preview_full', 'audio_preview_clip'])
-    .describe('Which downloadable asset: audio_16/audio_24/audio_32 = the WAV master at that bit depth; ' +
-    'audio_preview_full/audio_preview_clip = the generated MP3 preview (full-length / clip).');
-/** Release animated cover (motion artwork) video kinds. */
-const RELEASE_ASSET_TYPE = z
-    .enum(['square', 'tall'])
-    .describe('Which animated cover (motion artwork) video: the square or the tall/portrait cover video.');
-const getTrackFile = {
-    name: 'get_track_file',
-    toolset: 'catalog',
-    gate: 'read',
-    title: 'Get a track file',
-    description: 'Retrieve metadata about one of a track’s asset files (its stereo audio, Dolby Atmos audio, or lyrics file), including its processing state. This returns file information, not the bytes — use get_track_audio_download_url for a downloadable link.',
-    inputShape: { track_id: z.number().int().positive(), file_type: TRACK_FILE_TYPE },
-    annotations: { readOnlyHint: true },
-    handler: (args, { client }) => client.get(`/tracks/${args.track_id}/files/${args.file_type}`),
-};
-const getTrackAudioDownloadUrl = {
-    name: 'get_track_audio_download_url',
-    toolset: 'catalog',
-    gate: 'read',
-    title: 'Get a track audio download URL',
-    description: 'Return a time-limited, signed URL to download one of a track’s audio assets. `asset_type` selects the asset: audio_16, audio_24, and audio_32 are the WAV master at that bit depth; audio_preview_full and audio_preview_clip are the generated MP3 preview (full-length / clip). Returns { download_url, expires_in }; the URL expires roughly 10 minutes after it is issued, so request a fresh one when it lapses. Fetch the URL directly — do not send your API token to it.',
-    inputShape: { track_id: z.number().int().positive(), asset_type: TRACK_DOWNLOAD_ASSET_TYPE },
-    annotations: { readOnlyHint: true },
-    handler: (args, { client }) => client.get(`/tracks/${args.track_id}/files/${args.asset_type}/download-url`),
-};
-const listTrackLicenses = {
-    name: 'list_track_licenses',
-    toolset: 'catalog',
-    gate: 'read',
-    title: 'List track licenses',
-    description: 'List the licenses attached to a track (e.g. cover/mechanical or sample clearances), paginated.',
-    inputShape: {
-        track_id: z.number().int().positive(),
-        page: z.number().int().positive().optional(),
-        per_page: z.number().int().positive().optional(),
-    },
-    annotations: { readOnlyHint: true },
-    handler: (args, { client }) => client.get(`/tracks/${args.track_id}/licenses`, {
-        page: args.page,
-        per_page: args.per_page,
-    }),
-};
-const getTrackLicense = {
-    name: 'get_track_license',
-    toolset: 'catalog',
-    gate: 'read',
-    title: 'Get a track license',
-    description: 'Retrieve one license attached to a track by its license id.',
-    inputShape: {
-        track_id: z.number().int().positive(),
-        license_id: z.number().int().positive(),
-    },
-    annotations: { readOnlyHint: true },
-    handler: (args, { client }) => client.get(`/tracks/${args.track_id}/licenses/${args.license_id}`),
-};
-const getReleaseFile = {
-    name: 'get_release_file',
-    toolset: 'catalog',
-    gate: 'read',
-    title: 'Get a release file',
-    description: 'Retrieve metadata about a release animated cover (motion artwork) video asset — the square or the tall/portrait cover video — including its processing state.',
-    inputShape: { release_id: z.number().int().positive(), asset_type: RELEASE_ASSET_TYPE },
-    annotations: { readOnlyHint: true },
-    handler: (args, { client }) => client.get(`/releases/${args.release_id}/files/${args.asset_type}`),
-};
-export const filesReadTools = [
-    getTrackFile,
-    getTrackAudioDownloadUrl,
-    listTrackLicenses,
-    getTrackLicense,
-    getReleaseFile,
-];

package/dist/tools/full-writes.d.ts

@@ -1,12 +0,0 @@
-/**
- * Full-write toolset (`distribution`): the consequential actions that put a
- * release into the world or change immutable assets. Every tool here is gated
- * `full_write`, so it is neither registered nor callable unless the operator
- * has explicitly armed full writes (the flag AND the acknowledgment sentence).
- *
- * These wrap: finalized audio/artwork uploads (via the presigned-URL flow),
- * license file management, the FINAL distribute/takedown actions, the
- * Preflight-QC confirm-review step, and one-time Beatport onboarding.
- */
-import type { ToolDef } from './types.js';
-export declare const fullWriteTools: ToolDef[];

package/dist/tools/full-writes.js

@@ -1,248 +0,0 @@
-/**
- * Full-write toolset (`distribution`): the consequential actions that put a
- * release into the world or change immutable assets. Every tool here is gated
- * `full_write`, so it is neither registered nor callable unless the operator
- * has explicitly armed full writes (the flag AND the acknowledgment sentence).
- *
- * These wrap: finalized audio/artwork uploads (via the presigned-URL flow),
- * license file management, the FINAL distribute/takedown actions, the
- * Preflight-QC confirm-review step, and one-time Beatport onboarding.
- */
-import { z } from 'zod';
-import { assertAllowedExtension } from '../api/content-types.js';
-import { uploadViaPresignedUrl } from '../api/upload.js';
-/** Per-tool upload extension allow-lists: an upload tool never reads an arbitrary file. */
-const AUDIO_EXTS = {
-    stereo: ['.wav', '.flac', '.aif', '.aiff'],
-    dolby: ['.wav'],
-    lyrics: ['.lrc', '.txt'],
-};
-const ANIMATED_COVER_EXTS = ['.mp4', '.mov'];
-const IMAGE_EXTS = ['.jpg', '.jpeg', '.png', '.webp', '.tif', '.tiff'];
-const LICENSE_EXTS = ['.pdf', '.jpg', '.jpeg', '.png'];
-const TRACK_FILE_TYPE = z
-    .enum(['stereo', 'dolby', 'lyrics'])
-    .describe('Which track asset: stereo audio, Dolby Atmos audio, or the lyrics (LRC) file.');
-const RELEASE_ASSET_TYPE = z
-    .enum(['square', 'tall'])
-    .describe('Which animated cover (motion artwork) video: the square or the tall/portrait cover video.');
-const trackId = z.number().int().positive().describe('The track id.');
-const releaseId = z.number().int().positive().describe('The release id.');
-const labelId = z.number().int().positive().describe('The label id.');
-const filePath = z.string().describe('Local path to the file to upload.');
-/** Optional caller-supplied idempotency key, plumbed to the Idempotency-Key header. */
-const idempotencyKey = z
-    .string()
-    .min(8)
-    .max(128)
-    .optional()
-    .describe('Optional idempotency key. The server deduplicates by this key for 24h — pass the SAME key when retrying a call whose outcome you did not observe. Without it, each call is a new operation.');
-/** Optional license metadata shared by the license upload/update tools. */
-const licenseMeta = {
-    license_id: z.string().optional().describe('The license/clearance reference number, if any.'),
-    license_provider: z
-        .enum(['licensing_agency', 'direct_from_publisher'])
-        .optional()
-        .describe('Where the license came from.'),
-    license_provider_name: z.string().optional().describe('The name of the license provider.'),
-    original_track_link: z.string().optional().describe('URL to the original/source track.'),
-};
-/** Collects the defined license metadata fields into a string map for multipart. */
-function licenseExtra(args) {
-    const out = {};
-    for (const key of [
-        'type',
-        'license_id',
-        'license_provider',
-        'license_provider_name',
-        'original_track_link',
-    ]) {
-        const v = args[key];
-        if (v !== undefined && v !== null)
-            out[key] = String(v);
-    }
-    return out;
-}
-const uploadTrackAudio = {
-    name: 'upload_track_audio',
-    toolset: 'distribution',
-    gate: 'full_write',
-    title: 'Upload a track audio/lyrics file',
-    description: 'Upload a finalized audio file (stereo WAV/FLAC or Dolby Atmos) or lyrics (LRC) file for a track. The file is uploaded directly to storage and then processed asynchronously; check its state with get_track_file. Once a release is distributed the file is immutable — upload the correct master before distributing.',
-    inputShape: { track_id: trackId, file_type: TRACK_FILE_TYPE, file_path: filePath },
-    annotations: {},
-    handler: async (args, { client }) => {
-        const ext = assertAllowedExtension(args.file_path, AUDIO_EXTS[args.file_type]);
-        if ('error' in ext)
-            return { error: ext.error };
-        return uploadViaPresignedUrl(client, {
-            uploadUrlPath: `/tracks/${args.track_id}/files/${args.file_type}/upload-url`,
-            commitPath: `/tracks/${args.track_id}/files/${args.file_type}`,
-            filePath: ext.realPath,
-        });
-    },
-};
-const deleteTrackAudio = {
-    name: 'delete_track_audio',
-    toolset: 'distribution',
-    gate: 'full_write',
-    title: 'Delete a track audio/lyrics file',
-    description: 'Delete one of a track’s asset files (stereo, Dolby Atmos, or lyrics). Allowed only while the parent release is still an editable draft; the API refuses once the release is locked or distributed.',
-    inputShape: { track_id: trackId, file_type: TRACK_FILE_TYPE },
-    annotations: { destructiveHint: true },
-    handler: (args, { client }) => client.delete(`/tracks/${args.track_id}/files/${args.file_type}`),
-};
-const uploadReleaseAsset = {
-    name: 'upload_release_asset',
-    toolset: 'distribution',
-    gate: 'full_write',
-    title: 'Upload a release animated cover video',
-    description: 'Upload a finalized animated cover (motion artwork) video for a release — the square or the tall/portrait cover video. The video is uploaded directly to storage and then processed; check its state with get_release_file. Upload the correct video before distributing — it is immutable once the release is live. For the static cover art image use upload_release_artwork.',
-    inputShape: { release_id: releaseId, asset_type: RELEASE_ASSET_TYPE, file_path: filePath },
-    annotations: {},
-    handler: async (args, { client }) => {
-        const ext = assertAllowedExtension(args.file_path, ANIMATED_COVER_EXTS);
-        if ('error' in ext)
-            return { error: ext.error };
-        return uploadViaPresignedUrl(client, {
-            uploadUrlPath: `/releases/${args.release_id}/files/${args.asset_type}/upload-url`,
-            commitPath: `/releases/${args.release_id}/files/${args.asset_type}`,
-            filePath: ext.realPath,
-        });
-    },
-};
-const deleteReleaseAsset = {
-    name: 'delete_release_asset',
-    toolset: 'distribution',
-    gate: 'full_write',
-    title: 'Delete a release animated cover video',
-    description: 'Delete a release animated cover (motion artwork) video — the square or the tall/portrait cover video. Allowed only while the release is still an editable draft.',
-    inputShape: { release_id: releaseId, asset_type: RELEASE_ASSET_TYPE },
-    annotations: { destructiveHint: true },
-    handler: (args, { client }) => client.delete(`/releases/${args.release_id}/files/${args.asset_type}`),
-};
-const uploadReleaseArtwork = {
-    name: 'upload_release_artwork',
-    toolset: 'distribution',
-    gate: 'full_write',
-    title: 'Upload release cover art',
-    description: 'Upload or replace the release’s static cover art image from a local file. Cover art is immutable once the release is distributed — upload the final artwork before distributing.',
-    inputShape: { release_id: releaseId, file_path: filePath },
-    annotations: {},
-    handler: async (args, { client }) => {
-        const ext = assertAllowedExtension(args.file_path, IMAGE_EXTS);
-        if ('error' in ext)
-            return { error: ext.error };
-        return client.postMultipart(`/releases/${args.release_id}/photo`, ext.realPath, 'file');
-    },
-};
-const uploadTrackLicense = {
-    name: 'upload_track_license',
-    toolset: 'distribution',
-    gate: 'full_write',
-    title: 'Upload a track license',
-    description: 'Attach a license document to a track (for a cover or a cleared sample). `file_path` is the local license file and `type` is "cover" or "sample". Optionally record license_id, license_provider, license_provider_name, and original_track_link. Licenses are immutability-governed once the release is live.',
-    inputShape: {
-        track_id: trackId,
-        file_path: filePath,
-        type: z.enum(['cover', 'sample']).describe('The kind of license: a cover or a sample license.'),
-        ...licenseMeta,
-    },
-    annotations: {},
-    handler: async (args, { client }) => {
-        const ext = assertAllowedExtension(args.file_path, LICENSE_EXTS);
-        if ('error' in ext)
-            return { error: ext.error };
-        return client.postMultipart(`/tracks/${args.track_id}/licenses`, ext.realPath, 'file', licenseExtra(args));
-    },
-};
-const updateTrackLicense = {
-    name: 'update_track_license',
-    toolset: 'distribution',
-    gate: 'full_write',
-    title: 'Update a track license',
-    description: 'Replace the file and/or metadata of an existing track license. `track_license_id` is the id of the license (from list_track_licenses); `file_path` is the license file to submit. Optionally update license_id, license_provider, license_provider_name, and original_track_link.',
-    inputShape: {
-        track_id: trackId,
-        track_license_id: z.number().int().positive().describe('The track license id to update.'),
-        file_path: filePath,
-        ...licenseMeta,
-    },
-    annotations: {},
-    handler: async (args, { client }) => {
-        const ext = assertAllowedExtension(args.file_path, LICENSE_EXTS);
-        if ('error' in ext)
-            return { error: ext.error };
-        return client.postMultipart(`/tracks/${args.track_id}/licenses/${args.track_license_id}`, ext.realPath, 'file', licenseExtra(args));
-    },
-};
-const deleteTrackLicense = {
-    name: 'delete_track_license',
-    toolset: 'distribution',
-    gate: 'full_write',
-    title: 'Delete a track license',
-    description: 'Permanently delete a track license and its file. `track_license_id` is the license id (from list_track_licenses). This cannot be undone.',
-    inputShape: {
-        track_id: trackId,
-        track_license_id: z.number().int().positive().describe('The track license id to delete.'),
-    },
-    annotations: { destructiveHint: true },
-    handler: (args, { client }) => client.delete(`/tracks/${args.track_id}/licenses/${args.track_license_id}`),
-};
-const distributeRelease = {
-    name: 'distribute_release',
-    toolset: 'distribution',
-    gate: 'full_write',
-    title: 'Distribute a release',
-    description: 'Submit a release for distribution to the stores/outlets — this is the FINAL, consequential action that sends the release out; validate_release should pass first. The server enforces your account’s weekly submission limit and returns a structured error if it is exceeded. Pass idempotency_key and reuse the SAME value if you retry a call whose outcome you did not observe — the server deduplicates by it for 24h; without a key each call is a new submission.',
-    inputShape: { release_id: releaseId, idempotency_key: idempotencyKey },
-    annotations: { destructiveHint: true },
-    handler: (args, { client }) => client.post(`/releases/${args.release_id}/distribute`, undefined, {
-        idempotency: true,
-        idempotencyKey: args.idempotency_key,
-    }),
-};
-const takedownRelease = {
-    name: 'takedown_release',
-    toolset: 'distribution',
-    gate: 'full_write',
-    title: 'Take down a release',
-    description: 'Take a release down from ALL outlets/stores — a final, consequential action that removes it everywhere it was delivered. Re-distribution afterward is a fresh submission.',
-    inputShape: { release_id: releaseId },
-    annotations: { destructiveHint: true },
-    handler: (args, { client }) => client.post(`/releases/${args.release_id}/takedown-all`),
-};
-const confirmReview = {
-    name: 'confirm_review',
-    toolset: 'distribution',
-    gate: 'full_write',
-    title: 'Confirm a held release into review',
-    description: 'Confirm a release that Preflight QC placed on hold, moving it into distribution review. Use after you have reviewed the quality report and accept the release as-is. Safe to repeat.',
-    inputShape: { release_id: releaseId },
-    annotations: { idempotentHint: true },
-    handler: (args, { client }) => client.post(`/releases/${args.release_id}/confirm-review`),
-};
-const enableBeatport = {
-    name: 'enable_beatport',
-    toolset: 'distribution',
-    gate: 'full_write',
-    title: 'Request Beatport onboarding for a label',
-    description: 'Request Beatport onboarding for a label. This is a one-time action that cannot be un-requested once submitted, so confirm the label is correct first.',
-    inputShape: { label_id: labelId },
-    annotations: { destructiveHint: true },
-    handler: (args, { client }) => client.post(`/labels/${args.label_id}/enable-beatport`),
-};
-export const fullWriteTools = [
-    uploadTrackAudio,
-    deleteTrackAudio,
-    uploadReleaseAsset,
-    deleteReleaseAsset,
-    uploadReleaseArtwork,
-    uploadTrackLicense,
-    updateTrackLicense,
-    deleteTrackLicense,
-    distributeRelease,
-    takedownRelease,
-    confirmReview,
-    enableBeatport,
-];

package/dist/tools/identity.d.ts

@@ -1,3 +0,0 @@
-/** Identity toolset: read the authenticated account, revoke API tokens. */
-import type { ToolDef } from './types.js';
-export declare const identityTools: ToolDef[];

package/dist/tools/identity.js

@@ -1,28 +0,0 @@
-/** Identity toolset: read the authenticated account, revoke API tokens. */
-import { z } from 'zod';
-const getMe = {
-    name: 'get_me',
-    toolset: 'identity',
-    gate: 'read',
-    title: 'Get my account',
-    description: 'Return the authenticated LabelGrid account profile, including the release submission limit/quota and terms-acceptance status. Use this to confirm which account your API token belongs to before making other calls.',
-    inputShape: {},
-    annotations: { readOnlyHint: true },
-    handler: (_args, { client }) => client.get('/me'),
-};
-const revokeApiToken = {
-    name: 'revoke_api_token',
-    toolset: 'identity',
-    gate: 'safe_write',
-    title: 'Revoke an API token',
-    description: 'Revoke a LabelGrid API token. Pass token_id to revoke a specific token; omit it to revoke the token currently in use. WARNING: revoking the current token immediately ends this session — the server loses access and stops working until you configure a new token.',
-    inputShape: { token_id: z.number().int().positive().optional() },
-    annotations: { destructiveHint: true, idempotentHint: true },
-    handler: (args, { client }) => {
-        const tokenId = args.token_id;
-        return tokenId === undefined
-            ? client.delete('/tokens/current')
-            : client.delete(`/tokens/${tokenId}`);
-    },
-};
-export const identityTools = [getMe, revokeApiToken];

package/dist/tools/release-write.d.ts

@@ -1,12 +0,0 @@
-/**
- * Release write toolset (safe writes): the release/track draft lifecycle plus
- * validate, quality-report refresh, landing-page config, a short URL, and
- * review-issue notes.
- *
- * create_release and create_track send an auto-generated Idempotency-Key so a
- * retried creation cannot duplicate the entity. Release/track create+update
- * forward a permissive `fields` object straight to the API, which owns all
- * validation; the descriptions name the required fields.
- */
-import type { ToolDef } from './types.js';
-export declare const releaseWriteTools: ToolDef[];