@se-studio/contentful-cms 0.0.0-next16-20260822103555

package/dist/commands/asset.js

@@ -0,0 +1,685 @@
+/** biome-ignore-all lint/suspicious/noConsole: Console output is intentional in CLI */
+import * as path from 'node:path';
+import pc from 'picocolors';
+import { attachAssetUsages } from '../audit/asset-usage.js';
+import { runMediaReview } from '../audit/media-review.js';
+import { loadConfig, resolveSpaceConfig } from '../config/load.js';
+import { defaultFileNameForMime, getAssetBacklinks, getAssetSummary, uploadAssetBuffer, } from '../contentful/assets.js';
+import { createSafeEnvironment } from '../contentful/client.js';
+import { HOSTED_ASSET_UPLOAD_BASE64_ERROR, isHostedAssetUploadContext, } from '../contentful/hosted-asset-upload.js';
+import { createMediaEntry } from '../contentful/media.js';
+import { parseSafeRegExpPattern } from '../contentful/regex.js';
+import { getActiveFieldDef, getContentTypeCached } from '../contentful/set-field-schema.js';
+import { fetchUploadSource } from '../contentful/upload-fetch.js';
+import { ContentIndexSyncError } from '../index/errors.js';
+import { notifyContentIndexChanged } from '../index/invalidate.js';
+import { auditMissingAlt, findAssetByFileNameInIndex, mediaByAssetId, searchAssetsInIndex, } from '../index/query.js';
+import { ensureContentIndex } from '../index/require.js';
+import { assetSummaryToJson } from '../output/json.js';
+import { isJsonMode } from '../output/mode.js';
+import { errorMsg, infoMsg, successMsg, warnMsg } from '../output/print.js';
+import { getRuntimeContext } from '../runtime/context.js';
+import { makeAssetLink, makeEntryLink, resolveRef } from '../session/refs.js';
+import { requireSession, saveSession } from '../session/store.js';
+function handleAssetCommandError(err) {
+    if (err instanceof ContentIndexSyncError) {
+        errorMsg(err.message);
+    }
+    else {
+        errorMsg(err instanceof Error ? err.message : String(err));
+    }
+    process.exit(1);
+}
+export function registerAssetCommand(program) {
+    const asset = program.command('asset').description('Search and inspect Contentful assets');
+    asset
+        .command('search [query]')
+        .description('Search assets by title and/or filename')
+        .option('-n, --limit <n>', 'Max results (default 10)', '10')
+        .option('--skip <n>', 'Skip first N results for pagination', '0')
+        .option('--type <mime>', 'Filter by MIME type prefix (e.g. image/, application/pdf)')
+        .option('--filename <name>', 'Exact match on file.fileName')
+        .option('--filename-match <pattern>', 'Regex match on file.fileName')
+        .action(async (query, opts, cmd) => {
+        const parentOpts = cmd.parent?.parent?.opts() ?? {};
+        try {
+            const config = loadConfig(parentOpts.config);
+            const { space } = resolveSpaceConfig(config, parentOpts.space);
+            const limit = Number.parseInt(opts.limit, 10) || 10;
+            const skip = Number.parseInt(opts.skip, 10) || 0;
+            await ensureContentIndex(space, { onRebuild: warnMsg });
+            if (!query && !opts.filename && !opts.filenameMatch) {
+                errorMsg('Provide a title query and/or --filename / --filename-match.');
+                process.exit(1);
+            }
+            if (opts.filename && query) {
+                warnMsg('Ignoring title query — --filename takes precedence.');
+            }
+            if (opts.filenameMatch && query) {
+                warnMsg('Ignoring title query — --filename-match takes precedence.');
+            }
+            const pattern = opts.filenameMatch
+                ? parseSafeRegExpPattern(opts.filenameMatch, '--filename-match')
+                : undefined;
+            const results = searchAssetsInIndex(space, {
+                ...(opts.filename ? { exactFileName: opts.filename } : {}),
+                ...(pattern ? { fileNamePattern: pattern } : {}),
+                ...(query && !opts.filename && !opts.filenameMatch ? { query } : {}),
+                ...(opts.type ? { mimeTypePrefix: opts.type } : {}),
+                limit,
+                skip,
+            });
+            if (isJsonMode()) {
+                console.log(JSON.stringify(results.map(assetSummaryToJson), null, 2));
+                return;
+            }
+            if (results.length === 0) {
+                const label = query ?? opts.filename ?? opts.filenameMatch ?? '';
+                console.log(pc.dim(`No assets found for "${label}"`));
+                return;
+            }
+            const label = query ?? opts.filename ?? opts.filenameMatch ?? 'filename search';
+            console.log(`\n${pc.bold('Assets matching: ')}${pc.cyan(label)}\n`);
+            for (const a of results) {
+                const dims = a.width && a.height ? `  ${a.width}×${a.height}` : '';
+                const sizeStr = a.size ? `  ${Math.round(a.size / 1024)}KB` : '';
+                const ct = a.contentType ? `  ${pc.dim(a.contentType)}` : '';
+                console.log(`  ${pc.bold(a.id)}  ${a.title}${pc.dim(`${dims}${sizeStr}`)}${ct}`);
+                console.log(`    ${pc.dim(a.fileName)}  ${pc.dim(a.url)}`);
+            }
+            console.log('');
+            if (skip > 0 || results.length === limit) {
+                console.log(pc.dim(`Use --skip ${String(skip + limit)} to see the next page.`));
+            }
+            console.log(pc.dim('Use the asset ID with: cms-edit asset set <ref> <field> <asset-id>'));
+        }
+        catch (err) {
+            handleAssetCommandError(err);
+        }
+    });
+    asset
+        .command('info <asset-id>')
+        .description('Show details for a specific asset')
+        .option('--no-backlinks', 'Skip fetching entries that reference this asset')
+        .action(async (assetId, opts, cmd) => {
+        const parentOpts = cmd.parent?.parent?.opts() ?? {};
+        try {
+            const session = await requireSession(parentOpts.session, parentOpts.config);
+            const config = loadConfig(parentOpts.config);
+            const { space } = resolveSpaceConfig(config, session.spaceKey);
+            const env = await createSafeEnvironment(space);
+            const locale = space.defaultLocale;
+            const summary = await getAssetSummary(env, assetId);
+            if (!summary) {
+                errorMsg(`Asset "${assetId}" not found.`);
+                process.exit(1);
+                return;
+            }
+            const fetchBacklinks = opts.backlinks !== false;
+            const backlinks = fetchBacklinks ? await getAssetBacklinks(env, assetId, locale) : [];
+            if (isJsonMode()) {
+                console.log(JSON.stringify({ ...assetSummaryToJson(summary), backlinks: fetchBacklinks ? backlinks : null }, null, 2));
+                return;
+            }
+            console.log(`\n${pc.bold('Asset: ')}${summary.title}`);
+            console.log(`  ID:           ${summary.id}`);
+            const isImage = summary.contentType.startsWith('image/');
+            const descLabel = isImage ? 'Alt text:' : 'Description:';
+            if (summary.description) {
+                console.log(`  ${descLabel.padEnd(13)} ${summary.description}`);
+            }
+            else {
+                console.log(`  ${descLabel.padEnd(13)} ${pc.dim('(none)')}`);
+            }
+            console.log(`  File:         ${summary.fileName}`);
+            console.log(`  Content type: ${summary.contentType}`);
+            if (summary.width)
+                console.log(`  Dimensions:   ${summary.width}×${summary.height}`);
+            if (summary.size)
+                console.log(`  Size:         ${Math.round(summary.size / 1024)}KB`);
+            console.log(`  URL:          ${summary.url}`);
+            if (fetchBacklinks) {
+                if (backlinks.length === 0) {
+                    console.log(`  Referenced by: (none found)`);
+                }
+                else {
+                    console.log(`  Referenced by: ${String(backlinks.length)} entr${backlinks.length === 1 ? 'y' : 'ies'}`);
+                    for (const b of backlinks) {
+                        const label = b.contentType === 'media' ? `${b.label} (media)` : b.label;
+                        console.log(`    ${pc.dim(b.entryId)}  ${b.contentType}  "${label}"`);
+                    }
+                }
+            }
+            console.log('');
+        }
+        catch (err) {
+            errorMsg(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    });
+    asset
+        .command('get <ref> <field>')
+        .description('Show the current asset linked on a field in the active session.\n' +
+        'Example: cms-edit asset get @c0 visual')
+        .action(async (ref, field, _opts, cmd) => {
+        const parentOpts = cmd.parent?.parent?.opts() ?? {};
+        try {
+            const session = await requireSession(parentOpts.session, parentOpts.config);
+            const entry = resolveRef(session, ref);
+            const locale = session.defaultLocale;
+            const fieldData = entry.fields[field];
+            if (!fieldData) {
+                errorMsg(`Field "${field}" is missing on ${ref}.`);
+                process.exit(1);
+                return;
+            }
+            const val = fieldData[locale] ?? fieldData['en-US'];
+            if (!val || typeof val !== 'object') {
+                errorMsg(`Field "${field}" on ${ref} is not set or is not an asset link.`);
+                process.exit(1);
+                return;
+            }
+            // Collect asset IDs to look up (handles single Link and Array of Links)
+            const assetIds = [];
+            const asLink = val;
+            if (asLink.sys?.linkType === 'Asset' && asLink.sys.id) {
+                assetIds.push(asLink.sys.id);
+            }
+            else if (Array.isArray(val)) {
+                for (const item of val) {
+                    if (item.sys?.linkType === 'Asset' && item.sys.id) {
+                        assetIds.push(item.sys.id);
+                    }
+                }
+            }
+            if (assetIds.length === 0) {
+                errorMsg(`Field "${field}" on ${ref} does not contain an asset link.`);
+                process.exit(1);
+                return;
+            }
+            const config = loadConfig(parentOpts.config);
+            const { space } = resolveSpaceConfig(config, session.spaceKey);
+            const env = await createSafeEnvironment(space);
+            const summaries = await Promise.all(assetIds.map((id) => getAssetSummary(env, id)));
+            if (isJsonMode()) {
+                const validSummaries = summaries.flatMap((s) => (s ? [assetSummaryToJson(s)] : []));
+                console.log(JSON.stringify({ ref, field, assets: validSummaries }, null, 2));
+                return;
+            }
+            console.log(`\n${pc.bold(`${ref}.${field}`)}\n`);
+            for (const s of summaries) {
+                if (!s)
+                    continue;
+                const dims = s.width && s.height ? `  ${s.width}×${s.height}` : '';
+                const sizeStr = s.size ? `  ${Math.round(s.size / 1024)}KB` : '';
+                console.log(`  ${pc.bold(s.id)}  ${s.fileName}${pc.dim(`${dims}${sizeStr}`)}  ${pc.dim(s.contentType)}`);
+                console.log(`    ${pc.dim(s.url)}`);
+            }
+            console.log('');
+        }
+        catch (err) {
+            errorMsg(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    });
+    asset
+        .command('upload')
+        .description('Upload a file as a new draft Contentful asset and print its asset ID.\n' +
+        'Provide exactly one source: --base64 (local CLI only), --url, or --staged (hosted MCP).\n' +
+        'No session required — uses --space flag or defaultSpace from config.\n' +
+        'Example: cms-edit asset upload --url https://example.com/chart.png --title "Figure 1"\n' +
+        'Example: cms-edit asset upload --base64 <encoded> --mime image/jpeg --title "Poster" (local CLI)\n' +
+        'Example: cms-edit asset upload --staged <uploadId> --mime image/png --file-name photo.png')
+        .option('--base64 <encoded>', 'Base64-encoded file content')
+        .option('--url <https-url>', 'Public URL to fetch and upload')
+        .option('--staged <uploadId>', 'Consume a staged upload from cms_edit_request_staged_upload (hosted)')
+        .option('--mime <type>', 'MIME type (required for --base64; optional override for file/url)')
+        .option('--file-name <name>', 'Target fileName in Contentful (default derived from path/url/mime)')
+        .option('--title <title>', 'Asset title (default: filename without extension)')
+        .option('--description <text>', 'Asset description')
+        .option('--alt <text>', 'Alt text (stored as description when --description is not provided)')
+        .option('--with-media', 'Also create a draft Media entry wrapping this asset')
+        .option('--media-name <name>', 'Media entry name (default: asset title, then --title)')
+        .option('--media-position <position>', 'Media horizontal position: Left, Middle, or Right')
+        .option('--media-width <n>', 'Media width percent (1–100)', (v) => Number.parseInt(v, 10))
+        .option('--if-exists-by-filename', 'Return existing asset (and media if --with-media) when fileName already exists')
+        .action(async (opts, cmd) => {
+        const parentOpts = cmd.parent?.parent?.opts() ?? {};
+        try {
+            const config = loadConfig(parentOpts.config);
+            const { space } = resolveSpaceConfig(config, parentOpts.space);
+            const env = await createSafeEnvironment(space);
+            const locale = space.defaultLocale;
+            const description = opts.description ?? opts.alt ?? '';
+            const sources = [opts.base64 ? 'base64' : undefined, opts.url, opts.staged].filter(Boolean);
+            if (sources.length !== 1) {
+                errorMsg('Provide exactly one upload source: --base64, --url, or --staged.');
+                process.exit(1);
+            }
+            const usingBase64 = Boolean(opts.base64);
+            const usingUrl = Boolean(opts.url);
+            const usingStaged = Boolean(opts.staged);
+            if (usingBase64 && isHostedAssetUploadContext()) {
+                errorMsg(HOSTED_ASSET_UPLOAD_BASE64_ERROR);
+                process.exit(1);
+            }
+            if (opts.ifExistsByFilename &&
+                (usingBase64 || usingUrl || usingStaged) &&
+                !opts.fileName) {
+                errorMsg('--file-name is required with --if-exists-by-filename when using --base64, --url, or --staged.');
+                process.exit(1);
+            }
+            let summary;
+            let targetFileName = opts.fileName;
+            if (usingBase64) {
+                if (!opts.mime) {
+                    errorMsg('--mime is required when using --base64.');
+                    process.exit(1);
+                }
+                targetFileName = targetFileName ?? defaultFileNameForMime(opts.mime);
+            }
+            else if (usingStaged) {
+                if (!opts.mime) {
+                    errorMsg('--mime is required when using --staged.');
+                    process.exit(1);
+                }
+                if (!opts.fileName) {
+                    errorMsg('--file-name is required when using --staged.');
+                    process.exit(1);
+                }
+            }
+            else if (usingUrl) {
+                if (!targetFileName) {
+                    try {
+                        const urlPath = new URL(opts.url ?? '').pathname;
+                        targetFileName =
+                            path.basename(urlPath) ||
+                                defaultFileNameForMime(opts.mime ?? 'application/octet-stream');
+                    }
+                    catch {
+                        targetFileName = defaultFileNameForMime(opts.mime ?? 'application/octet-stream');
+                    }
+                }
+            }
+            if (opts.ifExistsByFilename && targetFileName) {
+                await ensureContentIndex(space, { onRebuild: warnMsg });
+                const existing = findAssetByFileNameInIndex(space, targetFileName);
+                if (existing) {
+                    let mediaIds = [];
+                    if (opts.withMedia) {
+                        const indexedMedia = mediaByAssetId(space, existing.id);
+                        if (indexedMedia.length > 0) {
+                            mediaIds = indexedMedia.map((m) => m.id);
+                        }
+                        else {
+                            const media = await createMediaEntry(env, {
+                                assetId: existing.id,
+                                name: opts.mediaName ?? opts.title ?? existing.title,
+                                locale,
+                                position: opts.mediaPosition,
+                                width: opts.mediaWidth,
+                            });
+                            mediaIds = [media.id];
+                        }
+                    }
+                    const mediaId = mediaIds[0];
+                    if (isJsonMode()) {
+                        console.log(JSON.stringify({
+                            ok: true,
+                            existing: true,
+                            ...assetSummaryToJson(existing),
+                            mediaId,
+                            mediaIds,
+                        }, null, 2));
+                    }
+                    else {
+                        infoMsg(`Asset with fileName "${existing.fileName}" already exists (ID: ${existing.id}).`);
+                        if (mediaIds.length > 0) {
+                            infoMsg(mediaIds.length === 1
+                                ? `Media entry ID: ${mediaIds[0]}`
+                                : `Media entry IDs: ${mediaIds.join(', ')}`);
+                        }
+                    }
+                    return;
+                }
+            }
+            if (opts.base64) {
+                const buffer = Buffer.from(opts.base64, 'base64');
+                summary = await uploadAssetBuffer(env, buffer, {
+                    title: opts.title,
+                    description,
+                    fileName: targetFileName ?? defaultFileNameForMime(opts.mime ?? ''),
+                    mimeType: opts.mime ?? 'application/octet-stream',
+                    locale,
+                }, (msg) => infoMsg(msg));
+            }
+            else if (opts.url) {
+                const { buffer, contentType } = await fetchUploadSource(opts.url ?? '');
+                const mimeType = opts.mime ?? contentType ?? 'application/octet-stream';
+                summary = await uploadAssetBuffer(env, buffer, {
+                    title: opts.title,
+                    description,
+                    fileName: targetFileName ?? defaultFileNameForMime(mimeType),
+                    mimeType,
+                    locale,
+                }, (msg) => infoMsg(msg));
+            }
+            else if (opts.staged) {
+                const context = getRuntimeContext();
+                const userId = context?.user?.userId;
+                const stagedStore = context?.stagedUploadStore;
+                if (!userId || !stagedStore) {
+                    errorMsg('--staged requires hosted MCP context (authenticated user and Redis staged upload store).');
+                    process.exit(1);
+                }
+                const staged = await stagedStore.consume(userId, opts.staged);
+                summary = await uploadAssetBuffer(env, staged.buffer, {
+                    title: opts.title,
+                    description,
+                    fileName: targetFileName ?? staged.fileName,
+                    mimeType: opts.mime ?? staged.mimeType,
+                    locale,
+                }, (msg) => infoMsg(msg));
+            }
+            else {
+                errorMsg('Provide exactly one upload source: --base64, --url, or --staged.');
+                process.exit(1);
+            }
+            const mediaIds = [];
+            if (opts.withMedia) {
+                const media = await createMediaEntry(env, {
+                    assetId: summary.id,
+                    name: opts.mediaName ?? opts.title ?? summary.title,
+                    locale,
+                    position: opts.mediaPosition,
+                    width: opts.mediaWidth,
+                });
+                mediaIds.push(media.id);
+            }
+            if (isJsonMode()) {
+                console.log(JSON.stringify({
+                    ok: true,
+                    ...assetSummaryToJson(summary),
+                    mediaId: mediaIds[0],
+                    mediaIds,
+                }, null, 2));
+                return;
+            }
+            const dims = summary.width && summary.height ? ` ${summary.width}×${summary.height},` : '';
+            const sizeStr = summary.size ? ` ${Math.round(summary.size / 1024)} KB,` : '';
+            console.log(pc.green(`✓ Uploaded asset "${summary.title}" (ID: ${summary.id})`));
+            console.log(`  File: ${summary.fileName} (${dims}${sizeStr} ${summary.contentType})`);
+            console.log(`  URL:  ${summary.url}`);
+            if (mediaIds.length > 0) {
+                console.log(`  Media entry ID: ${mediaIds[0]}`);
+            }
+            const assetRow = assetSummaryToIndexRow(summary);
+            await notifyContentIndexChanged(space, { upsertAssets: [assetRow] });
+        }
+        catch (err) {
+            handleAssetCommandError(err);
+        }
+    });
+    asset
+        .command('set <ref> <field> <asset-id>')
+        .description('Set a visual/asset field on an entry to a specific asset ID.\n' +
+        'If the field expects an Entry link of type "media", a media wrapper entry is auto-created.\n' +
+        'Use --mobile <id> to also set the mobileVisual field in the same operation.\n' +
+        'Example: cms-edit asset set @c0 visual abc123 --mobile def456')
+        .option('--mobile <id>', 'Also set the mobileVisual field to this asset ID')
+        .action(async (ref, field, assetId, opts, cmd) => {
+        const parentOpts = cmd.parent?.parent?.opts() ?? {};
+        try {
+            const session = await requireSession(parentOpts.session, parentOpts.config);
+            const entry = resolveRef(session, ref);
+            const locale = session.defaultLocale;
+            const config = loadConfig(parentOpts.config);
+            const { space } = resolveSpaceConfig(config, session.spaceKey);
+            const env = await createSafeEnvironment(space);
+            const resolveFieldLink = async (targetField, targetAssetId) => {
+                try {
+                    const ct = await getContentTypeCached(env, session, entry.sys.contentType.sys.id);
+                    const fieldDef = getActiveFieldDef(ct, targetField);
+                    if (fieldDef?.type === 'Link' && fieldDef.linkType === 'Entry') {
+                        const validations = fieldDef.validations ?? [];
+                        const linkContentType = validations
+                            .flatMap((v) => v.linkContentType ?? [])
+                            .at(0);
+                        if (linkContentType === 'media') {
+                            const media = await createMediaEntry(env, {
+                                assetId: targetAssetId,
+                                name: `Media for ${targetAssetId}`,
+                                locale,
+                            });
+                            infoMsg(`  Created media wrapper entry ${media.id} for asset ${targetAssetId}`);
+                            return makeEntryLink(media.id);
+                        }
+                        const hint = linkContentType
+                            ? `Create a '${linkContentType}' entry wrapping the asset and use: cms-edit set ${ref} ${targetField} <entry-id> --link`
+                            : `Create the wrapper entry manually and use: cms-edit set ${ref} ${targetField} <entry-id> --link`;
+                        errorMsg(`Field '${targetField}' expects a Link → Entry${linkContentType ? ` (${linkContentType})` : ''}, not an Asset.\n  ${hint}`);
+                        process.exit(1);
+                    }
+                }
+                catch (schemaErr) {
+                    warnMsg(`Could not inspect schema for '${targetField}': ${schemaErr instanceof Error ? schemaErr.message : String(schemaErr)}. Setting as asset link.`);
+                }
+                return makeAssetLink(targetAssetId);
+            };
+            const primaryLink = await resolveFieldLink(field, assetId);
+            if (!entry.fields[field])
+                entry.fields[field] = {};
+            entry.fields[field][locale] = primaryLink;
+            if (opts.mobile) {
+                const mobileLink = await resolveFieldLink('mobileVisual', opts.mobile);
+                const mobileField = 'mobileVisual';
+                if (!entry.fields[mobileField])
+                    entry.fields[mobileField] = {};
+                entry.fields[mobileField][locale] = mobileLink;
+            }
+            if (!session.modifiedEntryIds.includes(entry.sys.id)) {
+                session.modifiedEntryIds.push(entry.sys.id);
+            }
+            await saveSession(session);
+            if (opts.mobile) {
+                successMsg(`Set ${field}=${assetId} and mobileVisual=${opts.mobile} on ${ref}.`);
+            }
+            else {
+                successMsg(`Set ${field} on ${ref} to asset ${assetId}.`);
+            }
+        }
+        catch (err) {
+            errorMsg(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    });
+    asset
+        .command('review')
+        .description('Review visual assets (images, videos, Lottie) for filename, alt text, dimensions, size, and GIF issues.\n' +
+        'Uses the Preview API index by default. Use --json for full report (for spreadsheets / skills).\n' +
+        'Example: cms-edit --json-output asset review --space brightline')
+        .option('--published', 'Use Delivery API index instead of Preview')
+        .option('--include-passing', 'Include assets with no failing issues (default: failures only)')
+        .option('--max-width <n>', 'Max image/video width in pixels (default 2000)', '2000')
+        .option('--max-image-kb <n>', 'Max raster image size in KB (default 800)', '800')
+        .option('--max-video-mb <n>', 'Max video size in MB (default 8)', '8')
+        .option('--max-lottie-kb <n>', 'Max Lottie JSON size in KB (default 400)', '400')
+        .option('--include-usage', 'Include slug-bearing usage ancestry per asset in JSON output (slower; uses CMA walk-up)')
+        .option('--usage-limit <n>', 'Max assets to resolve usages for when --include-usage is set (default 50; 0 = unlimited)', '50')
+        .action(async (opts, cmd) => {
+        const parentOpts = cmd.parent?.parent?.opts() ?? {};
+        try {
+            const config = loadConfig(parentOpts.config);
+            const { key, space } = resolveSpaceConfig(config, parentOpts.space);
+            await ensureContentIndex(space, {
+                onRebuild: warnMsg,
+                preview: opts.published ? false : undefined,
+            });
+            const maxWidth = Number.parseInt(opts.maxWidth, 10);
+            const maxImageKb = Number.parseInt(opts.maxImageKb, 10);
+            const maxVideoMb = Number.parseInt(opts.maxVideoMb, 10);
+            const maxLottieKb = Number.parseInt(opts.maxLottieKb, 10);
+            const report = runMediaReview(key, space, {
+                preview: !opts.published,
+                failuresOnly: !opts.includePassing,
+                thresholds: {
+                    maxWidth: Number.isNaN(maxWidth) ? undefined : maxWidth,
+                    maxImageBytes: Number.isNaN(maxImageKb) ? undefined : maxImageKb * 1024,
+                    warnImageBytes: Number.isNaN(maxImageKb)
+                        ? undefined
+                        : Math.round(maxImageKb * 1024 * 0.6),
+                    maxVideoBytes: Number.isNaN(maxVideoMb) ? undefined : maxVideoMb * 1024 * 1024,
+                    warnVideoBytes: Number.isNaN(maxVideoMb)
+                        ? undefined
+                        : Math.round(maxVideoMb * 1024 * 1024 * 0.6),
+                    maxLottieBytes: Number.isNaN(maxLottieKb) ? undefined : maxLottieKb * 1024,
+                    warnLottieBytes: Number.isNaN(maxLottieKb)
+                        ? undefined
+                        : Math.round(maxLottieKb * 1024 * 0.6),
+                },
+            });
+            if (opts.includeUsage) {
+                const env = await createSafeEnvironment(space);
+                const parsedLimit = Number.parseInt(opts.usageLimit, 10);
+                const usageLimit = Number.isNaN(parsedLimit) ? 50 : parsedLimit;
+                const usageResult = await attachAssetUsages(env, report.assets, space.defaultLocale, usageLimit);
+                report.usageLimit = usageResult.limit;
+                report.usageResolvedCount = usageResult.resolvedCount;
+                report.usageTruncated = usageResult.truncated;
+                if (usageResult.truncated) {
+                    warnMsg(`Usage ancestry resolved for ${String(usageResult.resolvedCount)} of ${String(report.assets.length)} assets (--usage-limit ${String(usageResult.limit)}). Pass a higher --usage-limit for more; use 0 for unlimited (may timeout on hosted MCP).`);
+                }
+            }
+            if (isJsonMode()) {
+                console.log(JSON.stringify(report, null, 2));
+            }
+            else {
+                console.log(`\n${pc.bold(`Media review — ${key}`)}\n`);
+                console.log(`  Source: ${report.preview ? 'Preview API' : 'Delivery API'}`);
+                console.log(`  Visual assets scanned: ${String(report.total)}`);
+                console.log(`  Assets with failures: ${String(report.failingCount)}\n`);
+                for (const asset of report.assets) {
+                    const dims = asset.width != null && asset.height != null
+                        ? ` ${String(asset.width)}×${String(asset.height)}`
+                        : '';
+                    const failIssues = asset.issues.filter((issue) => issue.severity === 'fail');
+                    console.log(`${pc.red('✗')} ${pc.bold(asset.fileName)}${pc.dim(dims)}  ${pc.dim(asset.id)}`);
+                    for (const issue of failIssues) {
+                        console.log(`    ${pc.yellow(issue.code)}: ${issue.message}`);
+                    }
+                    console.log(`    ${pc.dim(asset.contentfulUrl)}`);
+                    console.log('');
+                }
+                if (report.failingCount === 0) {
+                    console.log(pc.green('  No failing assets found.\n'));
+                }
+                else {
+                    console.log(pc.dim('Use --json for full report (spreadsheet / contentful-cms-media-review skill).'));
+                    console.log('');
+                }
+            }
+            if (report.failingCount > 0)
+                process.exit(1);
+        }
+        catch (err) {
+            handleAssetCommandError(err);
+        }
+    });
+    asset
+        .command('audit')
+        .description('Audit image assets for missing descriptions (alt text) across the space.\n' +
+        'Exits with code 1 if any images are missing a description.\n' +
+        'Example: cms-edit asset audit')
+        .option('-n, --limit <n>', 'Max image assets to scan (default: all in index)')
+        .action(async (opts, cmd) => {
+        const parentOpts = cmd.parent?.parent?.opts() ?? {};
+        try {
+            const config = loadConfig(parentOpts.config);
+            const { space } = resolveSpaceConfig(config, parentOpts.space);
+            await ensureContentIndex(space, { onRebuild: warnMsg });
+            const maxTotal = opts.limit ? Number.parseInt(opts.limit, 10) : undefined;
+            const { checked: total, missing } = auditMissingAlt(space, {
+                ...(maxTotal !== undefined && !Number.isNaN(maxTotal) ? { limit: maxTotal } : {}),
+            });
+            if (isJsonMode()) {
+                console.log(JSON.stringify({ total, missingCount: missing.length, missing }, null, 2));
+            }
+            else {
+                console.log(`\n${pc.bold('Asset alt text audit')}\n`);
+                console.log(`  Images checked: ${String(total)}`);
+                console.log(`  Missing alt text: ${String(missing.length)}\n`);
+                if (missing.length > 0) {
+                    for (const m of missing) {
+                        console.log(`  ${pc.red('✗')} ${pc.bold(m.id)}  ${m.title}  ${pc.dim(m.fileName)}`);
+                    }
+                    console.log('');
+                    console.log(pc.dim(`Fix with: cms-edit asset set-description <asset-id> "alt text"`));
+                    console.log('');
+                }
+                else {
+                    console.log(pc.green('  All image assets have alt text.\n'));
+                }
+            }
+            if (missing.length > 0)
+                process.exit(1);
+        }
+        catch (err) {
+            handleAssetCommandError(err);
+        }
+    });
+    asset
+        .command('set-description <asset-id> <text>')
+        .description('Update the description (alt text) on a Contentful asset. Saves as draft by default.\n' +
+        'Example: cms-edit asset set-description abc123 "A chart showing revenue growth"')
+        .option('--publish', 'Publish the asset after updating the description')
+        .action(async (assetId, text, opts, cmd) => {
+        const parentOpts = cmd.parent?.parent?.opts() ?? {};
+        try {
+            const config = loadConfig(parentOpts.config);
+            const { space } = resolveSpaceConfig(config, parentOpts.space);
+            const env = await createSafeEnvironment(space);
+            const locale = space.defaultLocale;
+            const asset = await env.getAsset(assetId);
+            const fields = asset.fields;
+            if (!fields['description'])
+                fields['description'] = {};
+            fields['description'][locale] = text;
+            const updated = await env.updateAsset(asset);
+            if (opts.publish) {
+                await env.publishAsset(updated);
+                successMsg(`Updated and published description on asset ${assetId}.`);
+            }
+            else {
+                successMsg(`Updated description on asset ${assetId} (saved as draft).`);
+            }
+            const summary = await getAssetSummary(env, assetId);
+            if (summary) {
+                await notifyContentIndexChanged(space, {
+                    upsertAssets: [assetSummaryToIndexRow(summary)],
+                });
+            }
+            if (isJsonMode()) {
+                console.log(JSON.stringify({ ok: true, assetId, description: text, published: opts.publish ?? false }, null, 2));
+            }
+        }
+        catch (err) {
+            errorMsg(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    });
+}
+function assetSummaryToIndexRow(summary) {
+    return {
+        id: summary.id,
+        fileName: summary.fileName,
+        title: summary.title,
+        description: summary.description ?? null,
+        contentType: summary.contentType,
+        url: summary.url,
+        width: summary.width ?? null,
+        height: summary.height ?? null,
+        size: summary.size ?? null,
+        updatedAt: new Date().toISOString(),
+    };
+}
+//# sourceMappingURL=asset.js.map