@playdrop/playdrop-cli 0.5.1 → 0.5.3

package/dist/commands/upload.js

@@ -1,16 +1,135 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.upload = upload;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
 const types_1 = require("@playdrop/types");
 const apps_1 = require("../apps");
 const commandContext_1 = require("../commandContext");
 const http_1 = require("../http");
+const catalogue_1 = require("../catalogue");
+const messages_1 = require("../messages");
 const taskSelection_1 = require("../taskSelection");
 const taskUtils_1 = require("../taskUtils");
 const uploadLog_1 = require("../uploadLog");
 const upload_content_1 = require("./upload-content");
 const appUrls_1 = require("../appUrls");
 const upload_graph_1 = require("./upload-graph");
+function normalizeSavedItemKinds(kinds) {
+    return [...new Set(Array.isArray(kinds) ? kinds : [])].sort();
+}
+function sameSavedItemKinds(left, right) {
+    const normalizedLeft = normalizeSavedItemKinds(left);
+    const normalizedRight = normalizeSavedItemKinds(right);
+    if (normalizedLeft.length !== normalizedRight.length) {
+        return false;
+    }
+    return normalizedLeft.every((value, index) => value === normalizedRight[index]);
+}
+function resolveCatalogueWorkspaceRoot(startPath) {
+    const absoluteStart = (0, node_path_1.resolve)(startPath);
+    const currentStats = (0, node_fs_1.existsSync)(absoluteStart) ? (0, node_fs_1.statSync)(absoluteStart) : null;
+    let currentDir = currentStats?.isFile() ? (0, node_path_1.dirname)(absoluteStart) : absoluteStart;
+    while (true) {
+        const parentDir = (0, node_path_1.dirname)(currentDir);
+        if (parentDir === currentDir) {
+            return currentDir;
+        }
+        const parentCataloguePath = (0, node_path_1.join)(parentDir, 'catalogue.json');
+        if (!(0, node_fs_1.existsSync)(parentCataloguePath)) {
+            return currentDir;
+        }
+        currentDir = parentDir;
+    }
+}
+function resolveUploadWorkspaceRoot(pathOrName, resolution) {
+    if (resolution === 'name') {
+        return resolveCatalogueWorkspaceRoot(process.cwd());
+    }
+    return resolveCatalogueWorkspaceRoot(pathOrName);
+}
+function buildTagGroupLogEntry(status, entityId, detail) {
+    return {
+        action: 'upload',
+        status,
+        entityType: 'tag-group',
+        entityId,
+        catalogue: 'catalogue:tag-groups',
+        detail,
+    };
+}
+function buildTagLogEntry(status, entityId, detail) {
+    return {
+        action: 'upload',
+        status,
+        entityType: 'tag',
+        entityId,
+        catalogue: 'catalogue:tag-groups',
+        detail,
+    };
+}
+async function syncTagGroupsFromCatalogue(client, groups) {
+    const entries = [];
+    if (groups.length === 0) {
+        return entries;
+    }
+    const live = await client.fetchAdminTagGroups();
+    const liveGroupsBySlug = new Map(live.groups.map((group) => [group.slug, group]));
+    for (const groupDefinition of groups) {
+        let liveGroup = liveGroupsBySlug.get(groupDefinition.slug) ?? null;
+        if (!liveGroup) {
+            const created = await client.createAdminTagGroup({
+                slug: groupDefinition.slug,
+                displayName: groupDefinition.displayName,
+                ...(groupDefinition.allowedTargetKinds ? { allowedTargetKinds: groupDefinition.allowedTargetKinds } : {}),
+            });
+            liveGroup = {
+                ...created.group,
+                tags: [],
+            };
+            liveGroupsBySlug.set(liveGroup.slug, liveGroup);
+            entries.push(buildTagGroupLogEntry('success', liveGroup.slug, `created "${liveGroup.displayName}"`));
+        }
+        else if (liveGroup.displayName !== groupDefinition.displayName
+            || !sameSavedItemKinds(liveGroup.allowedTargetKinds, groupDefinition.allowedTargetKinds)) {
+            const updated = await client.updateAdminTagGroup(groupDefinition.slug, {
+                displayName: groupDefinition.displayName,
+                allowedTargetKinds: normalizeSavedItemKinds(groupDefinition.allowedTargetKinds),
+            });
+            liveGroup = {
+                ...updated.group,
+                tags: liveGroup.tags,
+            };
+            liveGroupsBySlug.set(liveGroup.slug, liveGroup);
+            entries.push(buildTagGroupLogEntry('success', liveGroup.slug, `updated "${liveGroup.displayName}"`));
+        }
+        if (!liveGroup) {
+            throw new Error(`tag_group_sync_failed:${groupDefinition.slug}`);
+        }
+        const liveTagsBySlug = new Map(liveGroup.tags.map((tag) => [tag.slug, tag]));
+        for (const tagDefinition of groupDefinition.tags) {
+            const liveTag = liveTagsBySlug.get(tagDefinition.slug) ?? null;
+            const tagRef = `${groupDefinition.slug}/${tagDefinition.slug}`;
+            if (!liveTag) {
+                const created = await client.createAdminTag(groupDefinition.slug, {
+                    slug: tagDefinition.slug,
+                    displayName: tagDefinition.displayName,
+                });
+                liveTagsBySlug.set(created.tag.slug, created.tag);
+                entries.push(buildTagLogEntry('success', tagRef, `created "${created.tag.displayName}"`));
+                continue;
+            }
+            if (liveTag.displayName !== tagDefinition.displayName) {
+                const updated = await client.updateAdminTag(groupDefinition.slug, tagDefinition.slug, {
+                    displayName: tagDefinition.displayName,
+                });
+                liveTagsBySlug.set(updated.tag.slug, updated.tag);
+                entries.push(buildTagLogEntry('success', tagRef, `updated "${updated.tag.displayName}"`));
+            }
+        }
+    }
+    return entries;
+}
 function buildApiUnavailableMessage(apiBase) {
     if (apiBase && typeof apiBase === 'string') {
         return `Could not reach the Playdrop API at ${apiBase}. Check your internet connection, then ensure the server is running before retrying.`;
@@ -86,6 +205,9 @@ function appendOverviewLink(entry, task, portalBase, creator) {
     if (task.kind === 'app') {
         url = buildAppOverviewUrl(portalBase, creator, task);
     }
+    else if (task.kind === 'asset-spec') {
+        url = null;
+    }
     else if (task.kind === 'asset' || task.kind === 'embedded-asset') {
         url = buildAssetOverviewUrl(portalBase, creator, task.name);
     }
@@ -107,11 +229,18 @@ function pushLoggedEntry(results, entry) {
     console.log((0, uploadLog_1.formatTaskLogLine)(entry));
 }
 function buildUploadErrorDetail(error) {
-    const message = typeof error?.message === 'string' && error.message.trim()
+    if (error instanceof types_1.ApiError && error.code === 'tag_clear_confirmation_required') {
+        return 'tag_clear_confirmation_required: This publish would remove existing live tags. Re-run with --clear-tags to confirm.';
+    }
+    const rawMessage = typeof error?.message === 'string' && error.message.trim()
         ? error.message.trim()
         : 'upload failed';
+    const message = rawMessage.replace(/^Upload failed for [^:]+:\s*/i, '');
+    if (/^[a-z0-9_]+:\s+/i.test(message)) {
+        return message;
+    }
     if (/status\s+413/i.test(message)) {
-        return 'upload failed: asset bundle too large (HTTP 413). Reduce the size of your app files and try again.';
+        return 'upload_too_large: Upload exceeded the Playdrop HTTP 413 limit. Reduce the size of your bundle, source archive, or listing media and try again.';
     }
     if (!message.startsWith('upload failed')) {
         return `upload failed: ${message}`;
@@ -150,6 +279,8 @@ function appendTaskRelations(graphState, fromNodeId, relations, contextLabel) {
 async function uploadAppTask(state, task, taskCreator, options) {
     const { upload } = await (0, apps_1.runAppPipeline)(state.client, task, {
         skipEcs: options?.skipEcs,
+        skipReview: options?.skipReview,
+        clearTags: options?.clearTags,
         creatorUsername: taskCreator,
     });
     if (!upload.versionCreated || !upload.version) {
@@ -196,7 +327,18 @@ async function uploadAppTask(state, task, taskCreator, options) {
     appendOverviewLink(entry, task, state.portalBase, taskCreator);
     return entry;
 }
-async function uploadStandaloneAssetTask(state, task, taskCreator) {
+async function uploadAssetSpecDefinitionTask(state, task, taskCreator) {
+    const uploaded = await (0, upload_content_1.uploadAssetSpecTask)(state.client, task, taskCreator);
+    return {
+        action: 'upload',
+        status: 'success',
+        entityType: 'asset-spec',
+        entityId: buildTaskEntityId(task, taskCreator),
+        catalogue: task.cataloguePath,
+        detail: `asset-spec:${uploaded.creatorUsername}/${uploaded.name}@${uploaded.version}`,
+    };
+}
+async function uploadStandaloneAssetTask(state, task, taskCreator, options) {
     const ownedPack = state.packPlanning.ownedPackByAssetKey.get((0, upload_content_1.buildAssetKey)(taskCreator, task.name));
     if (ownedPack) {
         return {
@@ -208,7 +350,9 @@ async function uploadStandaloneAssetTask(state, task, taskCreator) {
             detail: `staged with asset pack ${ownedPack.packTask.name}@${ownedPack.packTask.version}`,
         };
     }
-    const uploaded = await (0, upload_content_1.uploadAssetTask)(state.client, task, undefined, taskCreator);
+    const uploaded = await (0, upload_content_1.uploadAssetTask)(state.client, task, undefined, taskCreator, {
+        clearTags: options?.clearTags,
+    });
     state.uploadedAssetsByKey.set(`${uploaded.creatorUsername}/${uploaded.name}`, uploaded);
     (0, upload_graph_1.registerCanonicalNode)(state.graphState, uploaded.ref, uploaded.versionNodeId);
     (0, upload_graph_1.registerLocalRef)(state.graphState.localAssetNodeByName, state.graphState.ambiguousAssetNames, task.name, uploaded.versionNodeId);
@@ -286,12 +430,12 @@ function registerUploadedLocalPackAssets(state, task, taskCreator, packPlan, loc
         appendTaskRelations(state.graphState, uploadedLocalRef.versionNodeId, localTask.relations, `[${localTask.cataloguePath}] asset "${localTask.name}"`);
     }
 }
-async function uploadPackTask(state, task, taskCreator) {
+async function uploadPackTask(state, task, taskCreator, options) {
     const { packPlan, localAssetTasks } = collectPackLocalAssetTasks(state, task, taskCreator);
     const mutationTargetCreator = typeof task.username === 'string' && task.username.trim().length > 0
         ? taskCreator
         : undefined;
-    const uploadedPack = await (0, upload_content_1.uploadAssetPackTask)(state.client, task, taskCreator, state.uploadedAssetsByKey, localAssetTasks, packPlan.uploadKeyByAssetKey, mutationTargetCreator);
+    const uploadedPack = await (0, upload_content_1.uploadAssetPackTask)(state.client, task, taskCreator, state.uploadedAssetsByKey, localAssetTasks, packPlan.uploadKeyByAssetKey, mutationTargetCreator, { clearTags: options?.clearTags });
     (0, upload_graph_1.registerCanonicalNode)(state.graphState, uploadedPack.ref, uploadedPack.versionNodeId);
     (0, upload_graph_1.registerLocalRef)(state.graphState.localPackNodeByNameVersion, state.graphState.ambiguousPackNameVersions, `${task.name}@${task.version}`, uploadedPack.versionNodeId);
     registerUploadedLocalPackAssets(state, task, taskCreator, packPlan, localAssetTasks, uploadedPack);
@@ -311,14 +455,17 @@ async function processSingleUploadTask(state, task, taskCreator, options) {
     if (task.kind === 'app') {
         return await uploadAppTask(state, task, taskCreator, options);
     }
+    if (task.kind === 'asset-spec') {
+        return await uploadAssetSpecDefinitionTask(state, task, taskCreator);
+    }
     if (task.kind === 'asset') {
-        return await uploadStandaloneAssetTask(state, task, taskCreator);
+        return await uploadStandaloneAssetTask(state, task, taskCreator, options);
     }
     if (task.kind === 'embedded-asset') {
         return await uploadEmbeddedAssetTask(state, task, taskCreator);
     }
     if (task.kind === 'asset-pack') {
-        return await uploadPackTask(state, task, taskCreator);
+        return await uploadPackTask(state, task, taskCreator, options);
     }
     throw new Error(`Unsupported task kind "${task.kind}".`);
 }
@@ -412,6 +559,23 @@ async function upload(pathOrName, options) {
             ? userInfo.username.trim()
             : 'unknown';
         const selection = (0, taskSelection_1.selectTasks)(pathOrName);
+        const workspaceRoot = resolveUploadWorkspaceRoot(pathOrName, selection.resolution);
+        const tagGroupLoad = (0, catalogue_1.resolveCatalogueTagGroups)(workspaceRoot);
+        if (tagGroupLoad.errors.length > 0) {
+            (0, taskSelection_1.reportTaskErrors)(tagGroupLoad.errors.map((message) => ({
+                type: 'invalid-catalogue',
+                message,
+                help: ['Update the tagGroups entries noted above, then retry the publish.'],
+            })), 'project publish');
+            process.exitCode = 1;
+            return;
+        }
+        if (selection.errors.length > 0) {
+            const canPublishTagGroupsOnly = selection.errors.every((error) => error.type === 'no-tasks') && tagGroupLoad.groups.length > 0;
+            if (canPublishTagGroupsOnly) {
+                selection.errors.length = 0;
+            }
+        }
         if (selection.errors.length > 0) {
             (0, taskSelection_1.reportTaskErrors)(selection.errors, 'project publish');
             process.exitCode = 1;
@@ -419,11 +583,23 @@ async function upload(pathOrName, options) {
         }
         const warnings = selection.warnings;
         const tasks = selection.tasks;
-        if (tasks.length === 0) {
-            (0, uploadLog_1.printTaskSummary)([], warnings, { action: 'upload', environment: env });
+        if (tagGroupLoad.groups.length > 0 && userInfo.role !== 'ADMIN') {
+            (0, messages_1.printErrorWithHelp)('Publishing tagGroups requires an admin account.', [
+                'Log in as an admin before publishing taxonomy changes.',
+                'Remove tagGroups from catalogue.json if this publish should only upload content.',
+            ], { command: 'project publish' });
+            process.exitCode = 1;
             return;
         }
-        const results = await processUploadTasks(client, tasks, owner, userInfo.username, userInfo.role, envConfig.webBase, options);
+        const results = [];
+        if (tagGroupLoad.groups.length > 0) {
+            const taxonomyEntries = await syncTagGroupsFromCatalogue(client, tagGroupLoad.groups);
+            taxonomyEntries.forEach((entry) => pushLoggedEntry(results, entry));
+        }
+        if (tasks.length > 0) {
+            const uploadEntries = await processUploadTasks(client, tasks, owner, userInfo.username, userInfo.role, envConfig.webBase, options);
+            results.push(...uploadEntries);
+        }
         (0, uploadLog_1.printTaskSummary)(results, warnings, { action: 'upload', environment: env });
         (0, uploadLog_1.printPublishedAppNextSteps)(results);
     });

package/dist/commands/validate.js

@@ -1,11 +1,158 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validate = validate;
+const types_1 = require("@playdrop/types");
+const types_2 = require("@playdrop/types");
+const apiClient_1 = require("../apiClient");
+const config_1 = require("../config");
+const environment_1 = require("../environment");
 const taskSelection_1 = require("../taskSelection");
 const taskUtils_1 = require("../taskUtils");
 const uploadLog_1 = require("../uploadLog");
 const apps_1 = require("../apps");
+const assetSpecs_1 = require("../assetSpecs");
 const externalAssetPackValidation_1 = require("../externalAssetPackValidation");
+const upload_content_1 = require("./upload-content");
+function buildLocalAssetSpecLookups(tasks) {
+    const exactByRef = new Map();
+    const uniqueByNameVersion = new Map();
+    for (const task of tasks) {
+        if (task.username) {
+            exactByRef.set(`asset-spec:${task.username}/${task.name}@${task.version}`, task);
+        }
+        const nameVersionKey = `${task.name}@${task.version}`;
+        if (!uniqueByNameVersion.has(nameVersionKey)) {
+            uniqueByNameVersion.set(nameVersionKey, task);
+        }
+        else {
+            uniqueByNameVersion.set(nameVersionKey, null);
+        }
+    }
+    return { exactByRef, uniqueByNameVersion };
+}
+function resolveLocalAssetSpecTask(task, lookups) {
+    if (!task.assetSpec) {
+        return null;
+    }
+    const direct = lookups.exactByRef.get(task.assetSpec);
+    if (direct) {
+        return direct;
+    }
+    const parsed = (0, types_2.parseAssetSpecVersionRef)(task.assetSpec);
+    if (!parsed) {
+        return null;
+    }
+    const fallback = lookups.uniqueByNameVersion.get(`${parsed.name}@${parsed.version}`);
+    return fallback ?? null;
+}
+function validateAssetTask(task, assetSpecLookups) {
+    if (!task.assetSpec) {
+        return;
+    }
+    const localAssetSpecTask = resolveLocalAssetSpecTask(task, assetSpecLookups);
+    if (!localAssetSpecTask) {
+        return;
+    }
+    const errors = [];
+    (0, assetSpecs_1.validateCustomAssetFilesAgainstContract)(localAssetSpecTask.contract, task.filePaths, errors, `Asset "${task.name}"`);
+    if (errors.length > 0) {
+        throw new Error(errors.join(' '));
+    }
+}
+async function loadAuthenticatedValidationContext() {
+    const config = (0, config_1.loadConfig)();
+    const token = typeof config.token === 'string' ? config.token.trim() : '';
+    if (!token) {
+        return null;
+    }
+    const envName = typeof config.env === 'string' && config.env.trim().length > 0 ? config.env.trim() : 'prod';
+    const envConfig = (0, environment_1.resolveEnvironmentConfig)(envName);
+    if (!envConfig) {
+        return null;
+    }
+    const client = (0, apiClient_1.createCliApiClient)({
+        baseUrl: envConfig.apiBase,
+        token,
+    });
+    try {
+        const me = await client.me();
+        const username = typeof me?.user?.username === 'string' ? me.user.username.trim() : '';
+        if (!username) {
+            return null;
+        }
+        return {
+            client,
+            currentUserRole: me.user.role ?? null,
+            username,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function formatLiveTagClearWarning(input) {
+    const countLabel = input.liveTagCount === 1 ? '1 existing live tag' : `${input.liveTagCount} existing live tags`;
+    return `${input.entityLabel} "${input.displayName}" would remove ${countLabel} on publish. Add a tags field or pass --clear-tags to confirm.`;
+}
+// eslint-disable-next-line complexity
+async function collectLiveTagClearWarnings(tasks) {
+    const context = await loadAuthenticatedValidationContext();
+    if (!context) {
+        return [];
+    }
+    const warnings = [];
+    for (const task of tasks) {
+        if ((task.kind !== 'app' && task.kind !== 'asset' && task.kind !== 'asset-pack')
+            || task.tags.length > 0) {
+            continue;
+        }
+        const creatorResult = (0, upload_content_1.getTaskCreatorResult)(task, context.username, context.currentUserRole);
+        if (creatorResult.creatorTargetError) {
+            continue;
+        }
+        try {
+            if (task.kind === 'app') {
+                const response = await context.client.fetchAppBySlug(creatorResult.taskCreator, task.name);
+                const liveTagCount = Array.isArray(response.app.tags) ? response.app.tags.length : 0;
+                if (liveTagCount > 0) {
+                    warnings.push(formatLiveTagClearWarning({
+                        entityLabel: 'App',
+                        displayName: `${creatorResult.taskCreator}/${task.name}`,
+                        liveTagCount,
+                    }));
+                }
+                continue;
+            }
+            if (task.kind === 'asset') {
+                const response = await context.client.fetchAssetBySlug(creatorResult.taskCreator, task.name);
+                const liveTagCount = Array.isArray(response.asset.tags) ? response.asset.tags.length : 0;
+                if (liveTagCount > 0) {
+                    warnings.push(formatLiveTagClearWarning({
+                        entityLabel: 'Asset',
+                        displayName: `${creatorResult.taskCreator}/${task.name}`,
+                        liveTagCount,
+                    }));
+                }
+                continue;
+            }
+            const response = await context.client.fetchAssetPackBySlug(creatorResult.taskCreator, task.name);
+            const liveTagCount = Array.isArray(response.pack.tags) ? response.pack.tags.length : 0;
+            if (liveTagCount > 0) {
+                warnings.push(formatLiveTagClearWarning({
+                    entityLabel: 'Asset pack',
+                    displayName: `${creatorResult.taskCreator}/${task.name}`,
+                    liveTagCount,
+                }));
+            }
+        }
+        catch (error) {
+            if (error instanceof types_1.ApiError && (error.status === 404 || error.status === 401 || error.status === 403)) {
+                continue;
+            }
+        }
+    }
+    return warnings;
+}
 async function validate(pathOrName) {
     const selection = (0, taskSelection_1.selectTasks)(pathOrName);
     if (selection.errors.length > 0) {
@@ -30,14 +177,26 @@ async function validate(pathOrName) {
         return;
     }
     const results = [];
-    for (const task of (0, taskUtils_1.sortTasks)(tasks)) {
+    const assetSpecTasks = tasks.filter((task) => task.kind === 'asset-spec');
+    const assetSpecLookups = buildLocalAssetSpecLookups(assetSpecTasks);
+    const sortedTasks = (0, taskUtils_1.sortTasks)(tasks);
+    for (const task of sortedTasks) {
         const entityId = task.name;
         try {
             if (task.kind === 'app') {
                 await (0, apps_1.validateAppTask)(task);
             }
+            else if (task.kind === 'asset-spec') {
+                // Parsing already validates the contract, symbol, and documentation files.
+            }
+            else if (task.kind === 'asset') {
+                validateAssetTask(task, assetSpecLookups);
+            }
+            else if (task.kind === 'embedded-asset' || task.kind === 'asset-pack') {
+                // Structural validation already ran during catalogue parsing.
+            }
             else {
-                throw new Error(`project validate does not support ${task.kind} "${entityId}".`);
+                throw new Error(`project validate does not support "${entityId}".`);
             }
             const entry = {
                 action: 'validate',
@@ -63,5 +222,7 @@ async function validate(pathOrName) {
             console.log((0, uploadLog_1.formatTaskLogLine)(entry));
         }
     }
+    const liveTagWarnings = await collectLiveTagClearWarnings(sortedTasks);
+    liveTagWarnings.forEach((warning) => warnings.add(warning));
     (0, uploadLog_1.printTaskSummary)(results, warnings, { action: 'validate' });
 }