@playdrop/playdrop-cli 0.5.2 → 0.5.4

package/dist/commands/search.js

@@ -12,7 +12,7 @@ function parseSearchKind(raw) {
         return 'all';
     }
     const normalized = raw.trim().toLowerCase();
-    if (normalized === 'app' || normalized === 'asset' || normalized === 'asset-pack' || normalized === 'all') {
+    if (normalized === 'app' || normalized === 'asset' || normalized === 'asset-pack' || normalized === 'asset-spec' || normalized === 'all') {
         return normalized;
     }
     return null;
@@ -50,6 +50,16 @@ function parseAssetSubcategory(raw) {
     const normalized = (0, types_1.normalizeAssetSubcategory)(raw);
     return normalized.length > 0 ? normalized : null;
 }
+function parseSearchSort(raw) {
+    if (!raw || raw.trim().length === 0) {
+        return undefined;
+    }
+    const normalized = raw.trim().toLowerCase();
+    if (types_1.SEARCH_SORT_VALUES.includes(normalized)) {
+        return normalized;
+    }
+    return null;
+}
 function toSearchItem(result) {
     if (result.kind === 'app') {
         return {
@@ -67,6 +77,14 @@ function toSearchItem(result) {
             item: result.asset,
         };
     }
+    if (result.kind === 'asset-spec') {
+        return {
+            kind: 'asset-spec',
+            ref: `${result.assetSpec.creatorUsername}/asset-spec/${result.assetSpec.name}`,
+            targetPath: result.targetPath,
+            item: result.assetSpec,
+        };
+    }
     if (result.kind === 'pack') {
         return {
             kind: 'asset-pack',
@@ -85,6 +103,9 @@ function itemSummary(item) {
         const subcategory = item.item.currentVersion?.subcategory;
         return subcategory ? `${item.item.category.toLowerCase()}/${subcategory}` : item.item.category.toLowerCase();
     }
+    if (item.kind === 'asset-spec') {
+        return item.item.currentVersionRef ? `current ${item.item.currentVersionRef.split('@')[1] ?? 'none'}` : 'no current version';
+    }
     return 'asset-pack';
 }
 function formatCountValue(value) {
@@ -98,15 +119,28 @@ function buildCountsSuffix(item) {
         }
         parts.push(`launch ${formatCountValue(item.item.playCount)}`);
     }
-    if (item.kind === 'asset' && typeof item.item.playCount === 'number') {
+    if (item.kind === 'asset') {
         if (typeof item.item.viewCount === 'number') {
             parts.push(`view ${formatCountValue(item.item.viewCount)}`);
         }
-        parts.push(`play ${formatCountValue(item.item.playCount)}`);
+        if (typeof item.item.downloadCount === 'number') {
+            parts.push(`download ${formatCountValue(item.item.downloadCount)}`);
+        }
+        if (typeof item.item.playCount === 'number') {
+            parts.push(`play ${formatCountValue(item.item.playCount)}`);
+        }
     }
     if (item.kind === 'asset-pack' && typeof item.item.downloadCount === 'number') {
         parts.push(`download ${formatCountValue(item.item.downloadCount)}`);
     }
+    if (item.kind === 'asset-spec') {
+        parts.push(`assets ${formatCountValue(item.item.publicAssetCount)}`);
+        parts.push(`apps ${formatCountValue(item.item.supportingAppCount)}`);
+        if (item.item.documentationAvailable) {
+            parts.push('docs yes');
+        }
+        return ` | ${parts.join(' | ')}`;
+    }
     if (typeof item.item.likeCount === 'number') {
         parts.push(`like ${formatCountValue(item.item.likeCount)}`);
     }
@@ -118,6 +152,71 @@ function buildCountsSuffix(item) {
     }
     return parts.length > 0 ? ` | ${parts.join(' | ')}` : '';
 }
+function normalizeOptionalString(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim();
+    return normalized.length > 0 ? normalized : undefined;
+}
+function normalizeTagFilters(rawTags) {
+    if (!Array.isArray(rawTags) || rawTags.length === 0) {
+        return [];
+    }
+    const normalizedRefs = [];
+    const seenRefs = new Set();
+    for (const rawTag of rawTags) {
+        if (typeof rawTag !== 'string' || rawTag.trim().length === 0) {
+            return null;
+        }
+        let normalizedRef = '';
+        try {
+            normalizedRef = (0, types_1.normalizeTagRef)(rawTag);
+        }
+        catch {
+            return null;
+        }
+        if (seenRefs.has(normalizedRef)) {
+            return null;
+        }
+        seenRefs.add(normalizedRef);
+        normalizedRefs.push(normalizedRef);
+    }
+    if (normalizedRefs.length > 5) {
+        return null;
+    }
+    return normalizedRefs;
+}
+function buildTagSuffix(tags) {
+    const normalizedTags = Array.isArray(tags) ? tags : [];
+    if (normalizedTags.length === 0) {
+        return '';
+    }
+    const label = normalizedTags
+        .slice(0, 3)
+        .map((tag) => tag.ref)
+        .join(', ');
+    return ` | tags ${label}`;
+}
+function buildSearchRequest(input) {
+    return {
+        q: input.trimmedQuery,
+        mode: 'flat',
+        kind: (0, refs_1.contentKindToSearchKind)(input.kind),
+        page: 1,
+        pageSize: input.limit + input.offset,
+        ...(input.sort ? { sort: input.sort } : {}),
+        appType: input.appType,
+        assetCategory: input.assetCategory,
+        assetSubcategory: input.assetSubcategory,
+        assetSpec: input.assetSpec,
+        assetSpecOwner: input.assetSpecOwner,
+        assetSpecName: input.assetSpecName,
+        packContainsCategory: input.packContainsCategory,
+        packContainsSubcategory: input.packContainsSubcategory,
+        tags: input.tags,
+    };
+}
 async function search(query, options = {}) {
     const trimmedQuery = typeof query === 'string' ? query.trim() : '';
     if (!trimmedQuery) {
@@ -127,7 +226,7 @@ async function search(query, options = {}) {
     }
     const kind = parseSearchKind(options.kind);
     if (!kind) {
-        (0, messages_1.printErrorWithHelp)(`Kind "${options.kind ?? ''}" is not supported.`, ['Use one of: app, asset, asset-pack, all.'], { command: 'search' });
+        (0, messages_1.printErrorWithHelp)(`Kind "${options.kind ?? ''}" is not supported.`, ['Use one of: app, asset, asset-pack, asset-spec, all.'], { command: 'search' });
         process.exitCode = 1;
         return;
     }
@@ -143,6 +242,12 @@ async function search(query, options = {}) {
         process.exitCode = 1;
         return;
     }
+    const sort = parseSearchSort(options.sort);
+    if (sort === null) {
+        (0, messages_1.printErrorWithHelp)(`Sort "${options.sort ?? ''}" is not supported.`, ['Use one of: relevance, recent, likes, downloads, remixes, comments, assets, apps, alpha.'], { command: 'search' });
+        process.exitCode = 1;
+        return;
+    }
     const appType = options.appType ? (0, types_1.parseAppType)(options.appType.trim().toUpperCase()) : undefined;
     if (options.appType !== undefined && !appType) {
         (0, messages_1.printErrorWithHelp)(`App type "${options.appType}" is not supported.`, ['Use one of: game, demo, tool, template.'], { command: 'search' });
@@ -173,21 +278,30 @@ async function search(query, options = {}) {
         process.exitCode = 1;
         return;
     }
+    const tags = normalizeTagFilters(options.tag);
+    if (tags === null) {
+        (0, messages_1.printErrorWithHelp)('The --tag value is invalid.', ['Use canonical refs like theme/pirate or visual-style/pixel-art.', 'Pass at most 5 unique tag refs.'], { command: 'search' });
+        process.exitCode = 1;
+        return;
+    }
     await (0, commandContext_1.withPublicEnvironment)('search', async ({ client }) => {
         try {
-            const requestLimit = limit + offset;
-            const response = await client.search({
-                q: trimmedQuery,
-                mode: 'flat',
-                kind: (0, refs_1.contentKindToSearchKind)(kind),
-                page: 1,
-                pageSize: requestLimit,
+            const response = await client.search(buildSearchRequest({
+                trimmedQuery,
+                kind,
+                limit,
+                offset,
+                sort: sort ?? undefined,
                 appType: appType,
                 assetCategory: assetCategory ?? undefined,
                 assetSubcategory: assetSubcategory ?? undefined,
+                assetSpec: normalizeOptionalString(options.assetSpec),
+                assetSpecOwner: normalizeOptionalString(options.assetSpecOwner),
+                assetSpecName: normalizeOptionalString(options.assetSpecName),
                 packContainsCategory: packContainsCategory ?? undefined,
                 packContainsSubcategory: packContainsSubcategory ?? undefined,
-            });
+                tags,
+            }));
             const normalizedItems = (response.results ?? [])
                 .map((result) => toSearchItem(result))
                 .filter((item) => Boolean(item));
@@ -210,16 +324,24 @@ async function search(query, options = {}) {
             console.log(`Search results for "${trimmedQuery}":\n`);
             for (const [index, item] of items.entries()) {
                 const displayName = item.item.displayName || item.item.name;
-                console.log(`${index + 1}. [${item.kind}] ${item.ref} | ${displayName} | @${item.item.creatorUsername} | ${itemSummary(item)}${buildCountsSuffix(item)}`);
+                console.log(`${index + 1}. [${item.kind}] ${item.ref} | ${displayName} | @${item.item.creatorUsername} | ${itemSummary(item)}${buildCountsSuffix(item)}${buildTagSuffix(item.item.tags)}`);
             }
             console.log('\nNext: run "playdrop detail <creator>/<kind>/<name>" to inspect one result.');
         }
         catch (error) {
             const handled = (0, errors_1.handleCommandFailure)(error, 'search', 'Search', {
-                apiMessage: (apiError) => ({
-                    problem: `Search failed with status ${apiError.status}.`,
-                    suggestions: ['Retry in a moment.', 'Use "playdrop help search" for usage details.'],
-                }),
+                apiMessage: (apiError) => {
+                    if (apiError.code === 'invalid_tag_ref' || apiError.code === 'duplicate_tag_ref' || apiError.code === 'tag_filter_limit_exceeded') {
+                        return {
+                            problem: 'One or more tag filters are invalid.',
+                            suggestions: ['Use canonical refs like theme/pirate.', 'Pass at most 5 unique --tag values.'],
+                        };
+                    }
+                    return {
+                        problem: `Search failed with status ${apiError.status}.`,
+                        suggestions: ['Retry in a moment.', 'Use "playdrop help search" for usage details.'],
+                    };
+                },
             });
             if (!handled) {
                 throw error;

package/dist/commands/tags.d.ts

@@ -0,0 +1,7 @@
+type BrowseTagsOptions = {
+    group?: string;
+    kind?: string;
+    json?: boolean;
+};
+export declare function browseTags(options: BrowseTagsOptions): Promise<void>;
+export {};

package/dist/commands/tags.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.browseTags = browseTags;
+const types_1 = require("@playdrop/types");
+const commandContext_1 = require("../commandContext");
+const messages_1 = require("../messages");
+function normalizeGroupSlug(value) {
+    const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    return normalized.length > 0 ? normalized : null;
+}
+function normalizeTargetKind(value) {
+    const normalized = typeof value === 'string' ? value.trim().toUpperCase() : '';
+    if (!normalized) {
+        return null;
+    }
+    return types_1.SAVED_ITEM_KIND_VALUES.includes(normalized)
+        ? normalized
+        : null;
+}
+function formatAllowedTargetKinds(kinds) {
+    if (!Array.isArray(kinds) || kinds.length === 0) {
+        return 'all';
+    }
+    return kinds.join(', ');
+}
+async function browseTags(options) {
+    const groupSlug = normalizeGroupSlug(options.group);
+    const targetKind = normalizeTargetKind(options.kind);
+    if (options.group && (!groupSlug || !(0, types_1.isValidTagSlug)(groupSlug))) {
+        (0, messages_1.printErrorWithHelp)(`Invalid group slug "${options.group}".`, ['Use lowercase letters, numbers, and hyphens only.'], { command: 'tags browse' });
+        process.exitCode = 1;
+        return;
+    }
+    if (options.kind && !targetKind) {
+        (0, messages_1.printErrorWithHelp)(`Unsupported target kind "${options.kind}".`, [`Use one of: ${types_1.SAVED_ITEM_KIND_VALUES.join(', ')}.`], { command: 'tags browse' });
+        process.exitCode = 1;
+        return;
+    }
+    await (0, commandContext_1.withPublicEnvironment)('tags browse', async ({ client }) => {
+        const response = await client.fetchTags({
+            ...(groupSlug ? { groupSlug } : {}),
+            ...(targetKind ? { targetKind } : {}),
+        });
+        if (options.json) {
+            console.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        if (response.groups.length === 0) {
+            console.log('No tags found.');
+            return;
+        }
+        for (const [groupIndex, group] of response.groups.entries()) {
+            if (groupIndex > 0) {
+                console.log('');
+            }
+            console.log(`${group.displayName} (${group.slug})`);
+            console.log(`Allowed targets: ${formatAllowedTargetKinds(group.allowedTargetKinds)}`);
+            for (const tag of group.tags) {
+                console.log(`${tag.ref}  ${tag.displayName}`);
+            }
+        }
+    });
+}

package/dist/commands/upload-content.d.ts

@@ -1,6 +1,6 @@
 import type { ApiClient } from '@playdrop/api-client';
 import { type AssetPackUploadedLocalAsset } from '@playdrop/types';
-import type { AssetPackTask, AssetTask, EmbeddedAssetTask } from '../catalogue';
+import type { AssetPackTask, AssetSpecTask, AssetTask, EmbeddedAssetTask } from '../catalogue';
 import type { CliTask } from '../taskUtils';
 export type CurrentUserRole = 'USER' | 'CREATOR' | 'ADMIN' | null;
 export type UploadedAssetInfo = {
@@ -10,6 +10,11 @@ export type UploadedAssetInfo = {
     ref: string;
     versionNodeId: string;
 };
+export type UploadedAssetSpecInfo = {
+    creatorUsername: string;
+    name: string;
+    version: string;
+};
 export type UploadedAppInfo = {
     creatorUsername: string;
     name: string;
@@ -65,6 +70,11 @@ export declare function parseUnversionedAssetTaskRef(rawRef: string, fallbackCre
     name: string;
 } | null;
 export declare function buildAssetPackUploadPlans(tasks: CliTask[], defaultCreator: string, currentUserRole: CurrentUserRole): PackUploadPlanningResult;
-export declare function uploadAssetTask(client: ApiClient, task: AssetTask | EmbeddedAssetTask, sourceAppVersionId?: number, creatorUsername?: string): Promise<UploadedAssetInfo>;
-export declare function uploadAssetPackTask(client: ApiClient, task: AssetPackTask, creatorUsername: string, uploadedAssets: Map<string, UploadedAssetInfo>, localAssetTasks: AssetTask[], uploadKeyByAssetKey: Map<string, string>, targetCreatorUsername?: string): Promise<UploadedPackInfo>;
+export declare function uploadAssetTask(client: ApiClient, task: AssetTask | EmbeddedAssetTask, sourceAppVersionId?: number, creatorUsername?: string, options?: {
+    clearTags?: boolean;
+}): Promise<UploadedAssetInfo>;
+export declare function uploadAssetSpecTask(client: ApiClient, task: AssetSpecTask, creatorUsername?: string): Promise<UploadedAssetSpecInfo>;
+export declare function uploadAssetPackTask(client: ApiClient, task: AssetPackTask, creatorUsername: string, uploadedAssets: Map<string, UploadedAssetInfo>, localAssetTasks: AssetTask[], uploadKeyByAssetKey: Map<string, string>, targetCreatorUsername?: string, options?: {
+    clearTags?: boolean;
+}): Promise<UploadedPackInfo>;
 export {};

package/dist/commands/upload-content.js

@@ -6,6 +6,7 @@ exports.getTaskCreatorResult = getTaskCreatorResult;
 exports.parseUnversionedAssetTaskRef = parseUnversionedAssetTaskRef;
 exports.buildAssetPackUploadPlans = buildAssetPackUploadPlans;
 exports.uploadAssetTask = uploadAssetTask;
+exports.uploadAssetSpecTask = uploadAssetSpecTask;
 exports.uploadAssetPackTask = uploadAssetPackTask;
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
@@ -316,6 +317,22 @@ function validateAssetSubcategoryCompatibility(task, format) {
     return subcategory;
 }
 async function prepareAssetTaskUploadData(task) {
+    if ('assetSpec' in task && typeof task.assetSpec === 'string' && task.assetSpec.trim().length > 0) {
+        const uploadFiles = Object.entries(task.filePaths)
+            .sort(([leftRole], [rightRole]) => leftRole.localeCompare(rightRole))
+            .map(([role, filePath]) => prepareUploadFile(filePath, role));
+        return {
+            assetSpec: task.assetSpec.trim(),
+            uploadFiles,
+            manifestFiles: uploadFiles.map((entry) => ({
+                role: entry.fieldName,
+                filename: entry.filename,
+                contentType: entry.contentType,
+                sizeBytes: entry.sizeBytes,
+                sha256: entry.sha256,
+            })),
+        };
+    }
     const format = resolveAssetFormat(task);
     const subcategory = validateAssetSubcategoryCompatibility(task, format);
     await (0, model_artifacts_1.prepareModel3DAssetArtifacts)(task);
@@ -335,7 +352,7 @@ async function prepareAssetTaskUploadData(task) {
         })),
     };
 }
-async function uploadAssetTask(client, task, sourceAppVersionId, creatorUsername) {
+async function uploadAssetTask(client, task, sourceAppVersionId, creatorUsername, options) {
     const prepared = await prepareAssetTaskUploadData(task);
     const visibility = task.visibility;
     const files = prepared.uploadFiles.map((entry) => ({
@@ -347,19 +364,35 @@ async function uploadAssetTask(client, task, sourceAppVersionId, creatorUsername
     if (!targetCreatorUsername) {
         throw new Error(`Asset "${task.name}" upload is missing creator username.`);
     }
-    const response = await client.createAssetVersion(targetCreatorUsername, task.name, {
-        displayName: task.kind === 'asset' ? task.displayName : undefined,
-        category: task.category,
-        subcategory: prepared.subcategory,
-        format: prepared.format,
-        remixRef: task.kind === 'asset' ? task.remix : undefined,
-        visibility: visibility,
-        sourceKind: sourceAppVersionId ? 'APP_EMBEDDED' : 'UPLOAD',
-        sourceAppVersionId,
-        shopListed: task.shopListed,
-        shopPriceCredits: task.shopPriceCredits,
-        files,
-    });
+    const response = await client.createAssetVersion(targetCreatorUsername, task.name, prepared.assetSpec
+        ? {
+            displayName: task.kind === 'asset' ? task.displayName : undefined,
+            assetSpec: prepared.assetSpec,
+            remixRef: task.kind === 'asset' ? task.remix : undefined,
+            visibility: visibility,
+            sourceKind: sourceAppVersionId ? 'APP_EMBEDDED' : 'UPLOAD',
+            sourceAppVersionId,
+            tags: task.kind === 'asset' ? task.tags : undefined,
+            clearTags: task.kind === 'asset' ? options?.clearTags : undefined,
+            shopListed: task.shopListed,
+            shopPriceCredits: task.shopPriceCredits,
+            files,
+        }
+        : {
+            displayName: task.kind === 'asset' ? task.displayName : undefined,
+            category: task.category,
+            subcategory: prepared.subcategory,
+            format: prepared.format,
+            remixRef: task.kind === 'asset' ? task.remix : undefined,
+            visibility: visibility,
+            sourceKind: sourceAppVersionId ? 'APP_EMBEDDED' : 'UPLOAD',
+            sourceAppVersionId,
+            tags: task.kind === 'asset' ? task.tags : undefined,
+            clearTags: task.kind === 'asset' ? options?.clearTags : undefined,
+            shopListed: task.shopListed,
+            shopPriceCredits: task.shopPriceCredits,
+            files,
+        });
     const uploadedCreatorUsername = response.asset.creatorUsername;
     const name = response.asset.name;
     const revision = response.version.revision;
@@ -378,6 +411,35 @@ async function uploadAssetTask(client, task, sourceAppVersionId, creatorUsername
         versionNodeId,
     };
 }
+async function uploadAssetSpecTask(client, task, creatorUsername) {
+    const targetCreatorUsername = typeof creatorUsername === 'string' ? creatorUsername.trim() : '';
+    if (!targetCreatorUsername) {
+        throw new Error(`Asset spec "${task.name}@${task.version}" upload is missing creator username.`);
+    }
+    const symbol = prepareUploadFile(task.symbolPath, 'symbol', 'image/svg+xml');
+    const contract = prepareUploadFile(task.contractPath, 'contract', 'application/json');
+    const documentation = task.documentationPath
+        ? prepareUploadFile(task.documentationPath, 'documentation', 'text/markdown')
+        : null;
+    await client.createAssetSpecVersion(targetCreatorUsername, task.name, {
+        version: task.version,
+        displayName: task.displayName,
+        description: task.description,
+        visibility: task.visibility,
+        validationKind: task.validationKind,
+        status: task.status,
+        releaseNotes: task.releaseNotes,
+        successorVersion: task.successorVersion,
+        symbol: symbol.file,
+        contract: contract.file,
+        ...(documentation ? { documentation: documentation.file } : {}),
+    });
+    return {
+        creatorUsername: targetCreatorUsername,
+        name: task.name,
+        version: task.version,
+    };
+}
 function parseAssetRef(raw) {
     const trimmed = raw.trim();
     const canonicalMatch = /^asset:([^/]+)\/([^@]+)@r(\d+)$/i.exec(trimmed);
@@ -459,11 +521,13 @@ function buildLocalAssetManifestEntries(preparedLocalAssets) {
             uploadKey,
             name: localAsset.task.name,
             displayName: localAsset.task.displayName,
-            category: localAsset.task.category,
-            subcategory: localAsset.prepared.subcategory,
-            format: localAsset.prepared.format,
+            category: (localAsset.task.assetSpec ? 'CUSTOM' : localAsset.task.category),
+            subcategory: localAsset.prepared.subcategory ?? null,
+            format: (localAsset.prepared.format ?? 'CUSTOM'),
+            ...(localAsset.task.assetSpec ? { assetSpec: localAsset.task.assetSpec } : {}),
             visibility: localAsset.task.visibility,
             remixRef: localAsset.task.remix,
+            tags: localAsset.task.tags,
             shopListed: localAsset.task.shopListed,
             shopPriceCredits: localAsset.task.shopPriceCredits,
             files: localAsset.prepared.manifestFiles,
@@ -534,12 +598,14 @@ function buildPackListingPayload(listingUploads) {
         videosLandscape: listingUploads.filter((entry) => entry.mediaKey.startsWith('videosLandscape:')).map((entry) => entry.entry),
     };
 }
-function buildPackInitializeRequest(task, localAssets, existingAssets, members, listingUploads) {
+function buildPackInitializeRequest(task, localAssets, existingAssets, members, listingUploads, options) {
     return {
         version: task.version,
         displayName: task.displayName,
         remixRef: task.remix,
         visibility: task.visibility,
+        tags: task.tags,
+        clearTags: options?.clearTags,
         hostingMode: task.hostingMode,
         externalUrl: task.externalUrl,
         downloadUrl: task.downloadUrl,
@@ -586,13 +652,13 @@ function buildUploadedPackInfo(creatorUsername, task, versionNodeId, versionAsse
         uploadedLocalAssets: uploadedLocalAssets ?? [],
     };
 }
-async function uploadAssetPackTask(client, task, creatorUsername, uploadedAssets, localAssetTasks, uploadKeyByAssetKey, targetCreatorUsername) {
+async function uploadAssetPackTask(client, task, creatorUsername, uploadedAssets, localAssetTasks, uploadKeyByAssetKey, targetCreatorUsername, options) {
     const mutationCreatorUsername = resolveMutationCreatorUsername(task, creatorUsername, targetCreatorUsername);
     const preparedLocalAssets = await prepareLocalPackAssets(task, mutationCreatorUsername, localAssetTasks, uploadKeyByAssetKey);
     const localAssets = buildLocalAssetManifestEntries(preparedLocalAssets);
     const { existingAssets, members } = await buildPackMembersAndExistingAssets(client, task, mutationCreatorUsername, uploadedAssets, uploadKeyByAssetKey);
     const listingUploads = buildPackListingUploads(task);
-    const initializeBody = buildPackInitializeRequest(task, localAssets, existingAssets, members, listingUploads);
+    const initializeBody = buildPackInitializeRequest(task, localAssets, existingAssets, members, listingUploads, options);
     const initializeResponse = await client.initializeAssetPackUpload(mutationCreatorUsername, task.name, initializeBody);
     if (initializeResponse.status === 'finalized') {
         if (!initializeResponse.versionNodeId || !initializeResponse.version) {

package/dist/commands/upload.d.ts

@@ -1,4 +1,6 @@
 export type UploadCommandOptions = {
     skipEcs?: boolean;
+    skipReview?: boolean;
+    clearTags?: boolean;
 };
 export declare function upload(pathOrName: string, options?: UploadCommandOptions): Promise<void>;