@playdrop/playdrop-cli 0.3.1-build.1

package/dist/commands/upload.js

@@ -0,0 +1,651 @@
+"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 http_1 = require("../http");
+const commandContext_1 = require("../commandContext");
+const uploadLog_1 = require("../uploadLog");
+const apps_1 = require("../apps");
+const taskSelection_1 = require("../taskSelection");
+const taskUtils_1 = require("../taskUtils");
+const DEFAULT_PORTAL_BASE = 'https://www.playdrop.ai';
+const APP_TYPE_TO_SLUG = {
+    GAME: 'game',
+    DEMO: 'demo',
+    TOOL: 'tool',
+    TEMPLATE: 'template',
+};
+const EXTENSION_TO_FORMAT = {
+    '.png': 'PNG',
+    '.jpg': 'JPEG',
+    '.jpeg': 'JPEG',
+    '.webp': 'WEBP',
+    '.gif': 'GIF',
+    '.aseprite': 'ASEPRITE',
+    '.mp4': 'MP4',
+    '.webm': 'WEBM',
+    '.mp3': 'MP3',
+    '.wav': 'WAV',
+    '.ogg': 'OGG',
+    '.gltf': 'GLTF',
+    '.glb': 'GLB',
+    '.json': 'PLAYDROP_MODEL_JSON',
+};
+const EXTENSION_TO_MIME = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.webp': 'image/webp',
+    '.gif': 'image/gif',
+    '.aseprite': 'application/octet-stream',
+    '.mp4': 'video/mp4',
+    '.webm': 'video/webm',
+    '.mp3': 'audio/mpeg',
+    '.wav': 'audio/wav',
+    '.ogg': 'audio/ogg',
+    '.gltf': 'model/gltf+json',
+    '.glb': 'model/gltf-binary',
+    '.json': 'application/json',
+};
+async function fetchCurrentUserInfo(client, apiBase) {
+    try {
+        const data = await client.me();
+        return {
+            username: data?.user?.username ?? null,
+            role: data?.user?.role ?? null,
+        };
+    }
+    catch (error) {
+        if (error instanceof types_1.UnsupportedClientError) {
+            (0, http_1.handleUnsupportedError)(error, 'Upload');
+            return { username: null, role: null };
+        }
+        if (error instanceof http_1.CLIUnsupportedClientError) {
+            throw error;
+        }
+        if (error instanceof types_1.ApiError) {
+            return { username: null, role: null };
+        }
+        const message = apiBase && typeof apiBase === 'string'
+            ? `Could not reach the Playdrop API at ${apiBase}. Check your internet connection, then ensure the server is running before retrying.`
+            : 'Could not reach the Playdrop API. Check your internet connection, then ensure the server is running before retrying.';
+        const networkCode = error?.cause?.code;
+        const aggregateErrors = error?.cause?.errors;
+        if (error instanceof TypeError || networkCode === 'ECONNREFUSED') {
+            throw new Error(message);
+        }
+        if (Array.isArray(aggregateErrors) && aggregateErrors.some((entry) => entry?.code === 'ECONNREFUSED')) {
+            throw new Error(message);
+        }
+        throw error;
+    }
+}
+function normalizePortalBase(webBase) {
+    const base = webBase && webBase.trim().length > 0 ? webBase.trim() : DEFAULT_PORTAL_BASE;
+    return base.replace(/\/$/, '');
+}
+function normalizeCreatorUsername(username) {
+    if (!username)
+        return null;
+    const trimmed = username.trim();
+    if (!trimmed || trimmed.toLowerCase() === 'unknown') {
+        return null;
+    }
+    return trimmed;
+}
+function buildAppOverviewUrl(base, creator, task) {
+    const typeSlug = APP_TYPE_TO_SLUG[task.type ?? 'GAME'] ?? 'game';
+    const encodedCreator = encodeURIComponent(creator);
+    const encodedName = encodeURIComponent(task.name);
+    return `${base}/creators/${encodedCreator}/apps/${typeSlug}/${encodedName}/overview`;
+}
+function buildAssetOverviewUrl(base, creator, name) {
+    const encodedCreator = encodeURIComponent(creator);
+    const encodedName = encodeURIComponent(name);
+    return `${base}/creators/${encodedCreator}/assets/${encodedName}/overview`;
+}
+function buildAssetPackOverviewUrl(base, creator, name) {
+    const encodedCreator = encodeURIComponent(creator);
+    const encodedName = encodeURIComponent(name);
+    return `${base}/creators/${encodedCreator}/asset-packs/${encodedName}/overview`;
+}
+function appendOverviewLink(entry, task, portalBase, creator) {
+    if (!portalBase || !creator || entry.status === 'error') {
+        return;
+    }
+    let url = null;
+    if (task.kind === 'app') {
+        url = buildAppOverviewUrl(portalBase, creator, task);
+    }
+    else if (task.kind === 'asset' || task.kind === 'embedded-asset') {
+        url = buildAssetOverviewUrl(portalBase, creator, task.name);
+    }
+    else if (task.kind === 'asset-pack') {
+        url = buildAssetPackOverviewUrl(portalBase, creator, task.name);
+    }
+    if (!url) {
+        return;
+    }
+    entry.detail = entry.detail ? `${entry.detail} | view: ${url}` : `view: ${url}`;
+}
+function createFileFromPath(filePath) {
+    const extension = (0, node_path_1.extname)(filePath).toLowerCase();
+    const mimeType = EXTENSION_TO_MIME[extension] ?? 'application/octet-stream';
+    const data = (0, node_fs_1.readFileSync)(filePath);
+    return new File([data], (0, node_path_1.basename)(filePath), { type: mimeType });
+}
+function resolveAssetFormat(task) {
+    if (typeof task.format === 'string' && task.format.trim().length > 0) {
+        return task.format.trim().toUpperCase();
+    }
+    if (task.category === 'MODEL_3D') {
+        const entityFile = task.filePaths.entity;
+        if (typeof entityFile === 'string' && (0, node_path_1.extname)(entityFile).toLowerCase() === '.json') {
+            return 'PLAYDROP_MODEL_JSON';
+        }
+        const meshFile = task.filePaths.mesh;
+        if (typeof meshFile === 'string') {
+            const meshExtension = (0, node_path_1.extname)(meshFile).toLowerCase();
+            if (meshExtension === '.glb') {
+                return 'GLB';
+            }
+            if (meshExtension === '.gltf') {
+                return 'GLTF';
+            }
+        }
+    }
+    const filePaths = Object.values(task.filePaths);
+    if (filePaths.length === 0) {
+        throw new Error(`Asset "${task.name}" has no files.`);
+    }
+    if (filePaths.length > 1) {
+        throw new Error(`Asset "${task.name}" is missing format and has multiple files. Set "format" explicitly in catalogue.json.`);
+    }
+    const extension = (0, node_path_1.extname)(filePaths[0]).toLowerCase();
+    const inferred = EXTENSION_TO_FORMAT[extension];
+    if (!inferred) {
+        throw new Error(`Asset "${task.name}" uses unsupported file extension "${extension}". Set "format" explicitly.`);
+    }
+    return inferred;
+}
+function validateAssetSubcategoryCompatibility(task, format) {
+    const category = typeof task.category === 'string' ? task.category.trim().toUpperCase() : '';
+    const subcategory = typeof task.subcategory === 'string' ? task.subcategory.trim().toLowerCase() : '';
+    const definition = types_1.ASSET_SUBCATEGORY_DEFINITIONS_BY_KEY[`${category}:${subcategory}`];
+    if (!definition) {
+        throw new Error(`Asset "${task.name}" uses unsupported subcategory "${task.subcategory}" for category "${task.category}".`);
+    }
+    if (!definition.formats.includes(format)) {
+        throw new Error(`Asset "${task.name}" uses format "${format}" not allowed for subcategory "${subcategory}".`);
+    }
+    if (definition.requiresEntityManifest) {
+        const hasEntityFile = Object.keys(task.filePaths).some((role) => role.trim().toLowerCase() === 'entity');
+        if (!hasEntityFile) {
+            throw new Error(`Asset "${task.name}" subcategory "${subcategory}" requires files.entity.`);
+        }
+    }
+    return subcategory;
+}
+async function uploadAssetTask(client, task, sourceAppVersionId, creatorUsername) {
+    const format = resolveAssetFormat(task);
+    const subcategory = validateAssetSubcategoryCompatibility(task, format);
+    const visibility = task.visibility;
+    const files = Object.entries(task.filePaths).map(([role, filePath]) => ({
+        file: createFileFromPath(filePath),
+        fieldName: role,
+        filename: (0, node_path_1.basename)(filePath),
+    }));
+    const response = await client.createAssetVersion(task.name, {
+        displayName: task.kind === 'asset' ? task.displayName : undefined,
+        category: task.category,
+        subcategory,
+        format,
+        visibility: visibility,
+        sourceKind: sourceAppVersionId ? 'APP_EMBEDDED' : 'UPLOAD',
+        sourceAppVersionId,
+        shopListed: task.shopListed,
+        shopPriceCoins: task.shopPriceCoins,
+        files,
+    }, {
+        creatorUsername,
+    });
+    const uploadedCreatorUsername = response.asset.creatorUsername;
+    const name = response.asset.name;
+    const revision = response.version.revision;
+    const versionNodeId = typeof response.versionNodeId === 'string' ? response.versionNodeId.trim() : '';
+    if (typeof uploadedCreatorUsername !== 'string' || uploadedCreatorUsername.trim().length === 0) {
+        throw new Error(`Asset "${task.name}" upload did not return creatorUsername.`);
+    }
+    if (!versionNodeId) {
+        throw new Error(`Asset "${task.name}" upload did not return versionNodeId.`);
+    }
+    return {
+        creatorUsername: uploadedCreatorUsername,
+        name,
+        revision,
+        ref: `asset:${uploadedCreatorUsername}/${name}@r${revision}`,
+        versionNodeId,
+    };
+}
+function parseAssetRef(raw) {
+    const trimmed = raw.trim();
+    const canonicalMatch = /^asset:([^/]+)\/([^@]+)@r(\d+)$/i.exec(trimmed);
+    if (canonicalMatch) {
+        return {
+            creatorUsername: canonicalMatch[1],
+            name: canonicalMatch[2],
+            revision: Number.parseInt(canonicalMatch[3], 10),
+        };
+    }
+    const plainMatch = /^([^/]+)\/([^@]+)@r(\d+)$/i.exec(trimmed);
+    if (plainMatch) {
+        return {
+            creatorUsername: plainMatch[1],
+            name: plainMatch[2],
+            revision: Number.parseInt(plainMatch[3], 10),
+        };
+    }
+    return null;
+}
+async function resolveAssetReference(client, rawRef, fallbackCreator, uploadedAssets) {
+    const trimmed = rawRef.trim();
+    if (!trimmed) {
+        throw new Error('Asset pack has an empty asset reference.');
+    }
+    const parsed = parseAssetRef(trimmed);
+    if (parsed) {
+        return `asset:${parsed.creatorUsername}/${parsed.name}@r${parsed.revision}`;
+    }
+    if (trimmed.includes('@')) {
+        throw new Error(`Invalid asset ref "${trimmed}". Use "asset:creator/name@rN" format.`);
+    }
+    const slashIndex = trimmed.indexOf('/');
+    const creatorUsername = slashIndex > 0 ? trimmed.slice(0, slashIndex) : fallbackCreator;
+    const name = slashIndex > 0 ? trimmed.slice(slashIndex + 1) : trimmed;
+    if (!creatorUsername || !name) {
+        throw new Error(`Invalid asset reference "${trimmed}".`);
+    }
+    const key = `${creatorUsername}/${name}`;
+    const uploaded = uploadedAssets.get(key);
+    if (uploaded) {
+        return uploaded.ref;
+    }
+    const detail = await client.fetchAssetBySlug(creatorUsername, name);
+    const revision = detail?.asset?.currentVersion?.revision;
+    if (typeof revision !== 'number' || !Number.isInteger(revision) || revision <= 0) {
+        throw new Error(`Asset "${creatorUsername}/${name}" has no current version to reference from asset pack.`);
+    }
+    return `asset:${creatorUsername}/${name}@r${revision}`;
+}
+async function uploadAssetPackTask(client, task, creatorUsername, uploadedAssets, targetCreatorUsername) {
+    const assetRefs = [];
+    for (const ref of task.assets) {
+        assetRefs.push(await resolveAssetReference(client, ref, creatorUsername, uploadedAssets));
+    }
+    const response = await client.uploadAssetPackVersion(task.name, {
+        request: {
+            version: task.version,
+            visibility: task.visibility,
+            releaseNotes: task.releaseNotes,
+            assets: assetRefs.map((assetRef) => ({ assetRef })),
+        },
+        icon: task.listing?.iconPath ? createFileFromPath(task.listing.iconPath) : undefined,
+        heroPortrait: task.listing?.heroPortraitPath ? createFileFromPath(task.listing.heroPortraitPath) : undefined,
+        heroLandscape: task.listing?.heroLandscapePath ? createFileFromPath(task.listing.heroLandscapePath) : undefined,
+        screenshotsPortrait: task.listing?.screenshotPortraitPaths?.map((filePath) => createFileFromPath(filePath)),
+        screenshotsLandscape: task.listing?.screenshotLandscapePaths?.map((filePath) => createFileFromPath(filePath)),
+        videosPortrait: task.listing?.videoPortraitPaths?.map((filePath) => createFileFromPath(filePath)),
+        videosLandscape: task.listing?.videoLandscapePaths?.map((filePath) => createFileFromPath(filePath)),
+    }, {
+        creatorUsername: targetCreatorUsername,
+    });
+    const versionNodeId = typeof response.versionNodeId === 'string' ? response.versionNodeId.trim() : '';
+    if (!versionNodeId) {
+        throw new Error(`Asset pack "${task.name}@${task.version}" upload did not return versionNodeId.`);
+    }
+    return {
+        assetRefs,
+        versionNodeId,
+        ref: `pack:${creatorUsername}/${task.name}@${task.version}`,
+    };
+}
+const RELATION_TYPES = new Set([
+    'USES',
+    'CONTAINS',
+    'REMIXES',
+]);
+function buildEmptyGraphState() {
+    return {
+        canonicalNodeByRef: new Map(),
+        localAppNodeByName: new Map(),
+        localAssetNodeByName: new Map(),
+        localPackNodeByNameVersion: new Map(),
+        ambiguousAppNames: new Set(),
+        ambiguousAssetNames: new Set(),
+        ambiguousPackNameVersions: new Set(),
+        pendingRelations: [],
+    };
+}
+function registerLocalRef(map, ambiguous, key, nodeId) {
+    const normalized = key.trim();
+    if (!normalized) {
+        return;
+    }
+    const existing = map.get(normalized);
+    if (!existing) {
+        map.set(normalized, nodeId);
+        return;
+    }
+    if (existing !== nodeId) {
+        ambiguous.add(normalized);
+    }
+}
+function registerCanonicalNode(state, ref, nodeId) {
+    const normalized = ref.trim();
+    if (!normalized) {
+        return;
+    }
+    state.canonicalNodeByRef.set(normalized, nodeId);
+}
+function appendPendingRelation(state, fromNodeId, type, toRef, context) {
+    state.pendingRelations.push({
+        fromNodeId,
+        type,
+        toRef,
+        context,
+    });
+}
+function parseRelationType(raw, context) {
+    const normalized = raw.trim().toUpperCase();
+    if (!RELATION_TYPES.has(normalized)) {
+        throw new Error(`${context}: relation type "${raw}" is not supported.`);
+    }
+    return normalized;
+}
+function resolveLocalRefNodeId(map, ambiguous, key, context, kindLabel) {
+    if (ambiguous.has(key)) {
+        throw new Error(`${context}: local ${kindLabel} ref "${key}" is ambiguous. Use a canonical ref.`);
+    }
+    const nodeId = map.get(key);
+    if (!nodeId) {
+        throw new Error(`${context}: local ${kindLabel} ref "${key}" was not created in this upload run.`);
+    }
+    return nodeId;
+}
+function resolveRelationTargetNodeId(state, rawRef, context) {
+    const ref = rawRef.trim();
+    if (!ref) {
+        throw new Error(`${context}: relation target ref is empty.`);
+    }
+    if (ref.startsWith('@app/')) {
+        const name = ref.slice('@app/'.length).trim();
+        if (!name) {
+            throw new Error(`${context}: invalid local app ref "${ref}". Use "@app/<name>".`);
+        }
+        return resolveLocalRefNodeId(state.localAppNodeByName, state.ambiguousAppNames, name, context, 'app');
+    }
+    if (ref.startsWith('@asset/')) {
+        const name = ref.slice('@asset/'.length).trim();
+        if (!name) {
+            throw new Error(`${context}: invalid local asset ref "${ref}". Use "@asset/<name>".`);
+        }
+        return resolveLocalRefNodeId(state.localAssetNodeByName, state.ambiguousAssetNames, name, context, 'asset');
+    }
+    if (ref.startsWith('@pack/')) {
+        const target = ref.slice('@pack/'.length).trim();
+        const index = target.lastIndexOf('@');
+        if (index <= 0 || index === target.length - 1) {
+            throw new Error(`${context}: invalid local pack ref "${ref}". Use "@pack/<name>@<semver>".`);
+        }
+        return resolveLocalRefNodeId(state.localPackNodeByNameVersion, state.ambiguousPackNameVersions, target, context, 'pack');
+    }
+    const canonicalPattern = /^(app|asset|pack):[^/]+\/[^@]+@.+$/i;
+    if (!canonicalPattern.test(ref)) {
+        throw new Error(`${context}: invalid relation target ref "${ref}". Use canonical refs (app:/asset:/pack:) or local refs (@app/@asset/@pack).`);
+    }
+    const nodeId = state.canonicalNodeByRef.get(ref);
+    if (!nodeId) {
+        throw new Error(`${context}: canonical ref "${ref}" was not resolved in this upload run.`);
+    }
+    return nodeId;
+}
+async function applyGraphOperations(client, state) {
+    if (state.pendingRelations.length > 0) {
+        const relations = state.pendingRelations.map((row) => ({
+            fromNodeId: row.fromNodeId,
+            toNodeId: resolveRelationTargetNodeId(state, row.toRef, row.context),
+            type: parseRelationType(row.type, row.context),
+        }));
+        await client.batchUpsertGraphRelations({ relations });
+    }
+}
+async function processUploadTasks(client, tasks, owner, ownerUsername, currentUserRole, webBase, options) {
+    const portalBase = webBase ? normalizePortalBase(webBase) : null;
+    const defaultCreator = normalizeCreatorUsername(ownerUsername) ?? owner;
+    const uploadedAppsByName = new Map();
+    const uploadedAssetsByKey = new Map();
+    const graphState = buildEmptyGraphState();
+    const results = [];
+    let aborted = false;
+    for (const task of (0, taskUtils_1.sortTasks)(tasks)) {
+        let taskOwner = defaultCreator;
+        let taskOwnerUsername = defaultCreator;
+        const requestedTaskOwner = 'username' in task && typeof task.username === 'string'
+            ? String(task.username).trim()
+            : '';
+        const creatorTargetError = requestedTaskOwner && currentUserRole !== 'ADMIN'
+            ? `Task "${task.name}" sets username="${requestedTaskOwner}", but only admins can target another creator.`
+            : null;
+        if (requestedTaskOwner && !creatorTargetError) {
+            taskOwner = requestedTaskOwner;
+            taskOwnerUsername = requestedTaskOwner;
+            console.log(`[Admin] Publishing ${task.name} as user: ${requestedTaskOwner}`);
+        }
+        const entityId = task.kind === 'embedded-asset' ? `${taskOwner}/${task.appName}:${task.name}` : `${taskOwner}/${task.name}`;
+        const taskCreator = normalizeCreatorUsername(taskOwnerUsername) ?? taskOwner;
+        try {
+            if (creatorTargetError) {
+                throw new Error(creatorTargetError);
+            }
+            if (task.kind === 'app') {
+                const { upload } = await (0, apps_1.runAppPipeline)(client, task, {
+                    skipEcs: options?.skipEcs,
+                    creatorUsername: task.username,
+                });
+                if (!upload.versionCreated || !upload.version) {
+                    throw new Error(`App "${task.name}" upload did not return a created version.`);
+                }
+                if (typeof upload.versionId !== 'number') {
+                    throw new Error(`App "${task.name}" upload did not return version ID.`);
+                }
+                if (typeof upload.versionNodeId !== 'string' || upload.versionNodeId.trim().length === 0) {
+                    throw new Error(`App "${task.name}" upload did not return versionNodeId.`);
+                }
+                const appRef = `app:${taskCreator}/${task.name}@${upload.version}`;
+                const uploadedApp = {
+                    creatorUsername: taskCreator,
+                    name: task.name,
+                    version: upload.version,
+                    versionId: upload.versionId,
+                    versionNodeId: upload.versionNodeId,
+                    ref: appRef,
+                };
+                uploadedAppsByName.set(task.name, uploadedApp);
+                registerCanonicalNode(graphState, appRef, uploadedApp.versionNodeId);
+                registerLocalRef(graphState.localAppNodeByName, graphState.ambiguousAppNames, task.name, uploadedApp.versionNodeId);
+                task.uses.assets.forEach((toRef, index) => {
+                    appendPendingRelation(graphState, uploadedApp.versionNodeId, 'USES', toRef, `[${task.cataloguePath}] app "${task.name}" uses.assets[${index}]`);
+                });
+                task.uses.packs.forEach((toRef, index) => {
+                    appendPendingRelation(graphState, uploadedApp.versionNodeId, 'USES', toRef, `[${task.cataloguePath}] app "${task.name}" uses.packs[${index}]`);
+                });
+                task.graph.relations.forEach((relation, index) => {
+                    appendPendingRelation(graphState, uploadedApp.versionNodeId, relation.type, relation.to, `[${task.cataloguePath}] app "${task.name}" relations[${index}]`);
+                });
+                const entry = {
+                    action: 'upload',
+                    status: 'success',
+                    entityType: 'app',
+                    entityId,
+                    catalogue: task.cataloguePath,
+                    detail: `version ${upload.version} created`,
+                };
+                appendOverviewLink(entry, task, portalBase, taskCreator);
+                results.push(entry);
+                console.log((0, uploadLog_1.formatTaskLogLine)(entry));
+            }
+            else if (task.kind === 'asset') {
+                const mutationTargetCreator = typeof task.username === 'string' && task.username.trim().length > 0
+                    ? taskCreator
+                    : undefined;
+                const uploaded = await uploadAssetTask(client, task, undefined, mutationTargetCreator);
+                uploadedAssetsByKey.set(`${uploaded.creatorUsername}/${uploaded.name}`, uploaded);
+                registerCanonicalNode(graphState, uploaded.ref, uploaded.versionNodeId);
+                registerLocalRef(graphState.localAssetNodeByName, graphState.ambiguousAssetNames, task.name, uploaded.versionNodeId);
+                (task.relations ?? []).forEach((relation, index) => {
+                    appendPendingRelation(graphState, uploaded.versionNodeId, relation.type, relation.to, `[${task.cataloguePath}] asset "${task.name}" relations[${index}]`);
+                });
+                const entry = {
+                    action: 'upload',
+                    status: 'success',
+                    entityType: 'asset',
+                    entityId,
+                    catalogue: task.cataloguePath,
+                    detail: uploaded.ref,
+                };
+                appendOverviewLink(entry, task, portalBase, uploaded.creatorUsername);
+                results.push(entry);
+                console.log((0, uploadLog_1.formatTaskLogLine)(entry));
+            }
+            else if (task.kind === 'embedded-asset') {
+                const sourceApp = uploadedAppsByName.get(task.appName);
+                if (!sourceApp) {
+                    throw new Error(`Embedded asset "${task.name}" references app "${task.appName}" that was not uploaded in this run.`);
+                }
+                const mutationTargetCreator = sourceApp.creatorUsername !== defaultCreator
+                    ? sourceApp.creatorUsername
+                    : undefined;
+                const uploaded = await uploadAssetTask(client, task, sourceApp.versionId, mutationTargetCreator);
+                uploadedAssetsByKey.set(`${uploaded.creatorUsername}/${uploaded.name}`, uploaded);
+                registerCanonicalNode(graphState, uploaded.ref, uploaded.versionNodeId);
+                registerLocalRef(graphState.localAssetNodeByName, graphState.ambiguousAssetNames, task.name, uploaded.versionNodeId);
+                const entry = {
+                    action: 'upload',
+                    status: 'success',
+                    entityType: 'embedded-asset',
+                    entityId,
+                    catalogue: task.cataloguePath,
+                    detail: `${uploaded.ref} (source app version ${sourceApp.versionId})`,
+                };
+                appendOverviewLink(entry, task, portalBase, uploaded.creatorUsername);
+                results.push(entry);
+                console.log((0, uploadLog_1.formatTaskLogLine)(entry));
+            }
+            else if (task.kind === 'asset-pack') {
+                const mutationTargetCreator = typeof task.username === 'string' && task.username.trim().length > 0
+                    ? taskCreator
+                    : undefined;
+                const uploadedPack = await uploadAssetPackTask(client, task, taskCreator, uploadedAssetsByKey, mutationTargetCreator);
+                registerCanonicalNode(graphState, uploadedPack.ref, uploadedPack.versionNodeId);
+                registerLocalRef(graphState.localPackNodeByNameVersion, graphState.ambiguousPackNameVersions, `${task.name}@${task.version}`, uploadedPack.versionNodeId);
+                (task.relations ?? []).forEach((relation, index) => {
+                    appendPendingRelation(graphState, uploadedPack.versionNodeId, relation.type, relation.to, `[${task.cataloguePath}] assetPack "${task.name}@${task.version}" relations[${index}]`);
+                });
+                const entry = {
+                    action: 'upload',
+                    status: 'success',
+                    entityType: 'asset-pack',
+                    entityId,
+                    catalogue: task.cataloguePath,
+                    detail: `version ${task.version} created (${uploadedPack.assetRefs.length} assets)`,
+                };
+                appendOverviewLink(entry, task, portalBase, taskCreator);
+                results.push(entry);
+                console.log((0, uploadLog_1.formatTaskLogLine)(entry));
+            }
+            else {
+                throw new Error(`Unsupported task kind "${task.kind}".`);
+            }
+        }
+        catch (error) {
+            if (error instanceof http_1.CLIUnsupportedClientError) {
+                throw error;
+            }
+            let message = typeof error?.message === 'string' && error.message.trim() ? error.message.trim() : 'upload failed';
+            if (/status\s+413/i.test(message)) {
+                message = 'upload failed: asset bundle too large (HTTP 413). Reduce the size of your app files and try again.';
+            }
+            else if (!message.startsWith('upload failed')) {
+                message = `upload failed: ${message}`;
+            }
+            const entry = {
+                action: 'upload',
+                status: 'error',
+                entityType: task.kind,
+                entityId,
+                catalogue: task.cataloguePath,
+                detail: message,
+            };
+            results.push(entry);
+            console.log((0, uploadLog_1.formatTaskLogLine)(entry));
+            process.exitCode = process.exitCode || 1;
+            aborted = true;
+            break;
+        }
+    }
+    if (!aborted) {
+        try {
+            await applyGraphOperations(client, graphState);
+        }
+        catch (error) {
+            const message = typeof error?.message === 'string' && error.message.trim().length > 0
+                ? error.message.trim()
+                : 'graph batch upload failed';
+            const entry = {
+                action: 'upload',
+                status: 'error',
+                entityType: 'app',
+                entityId: 'graph',
+                catalogue: 'graph:batch',
+                detail: `upload failed: ${message}`,
+            };
+            results.push(entry);
+            console.log((0, uploadLog_1.formatTaskLogLine)(entry));
+            process.exitCode = process.exitCode || 1;
+        }
+    }
+    return results;
+}
+async function upload(pathOrName, options) {
+    await (0, commandContext_1.withEnvironment)('upload', 'Uploading content', async ({ client, env, envConfig }) => {
+        let userInfo = { username: null, role: null };
+        try {
+            userInfo = await fetchCurrentUserInfo(client, envConfig.apiBase);
+        }
+        catch (error) {
+            if (error instanceof http_1.CLIUnsupportedClientError) {
+                return;
+            }
+            throw error;
+        }
+        const owner = typeof userInfo.username === 'string' && userInfo.username.trim().length > 0
+            ? userInfo.username.trim()
+            : 'unknown';
+        const selection = (0, taskSelection_1.selectTasks)(pathOrName);
+        if (selection.errors.length > 0) {
+            (0, taskSelection_1.reportTaskErrors)(selection.errors, 'upload');
+            process.exitCode = 1;
+            return;
+        }
+        const warnings = selection.warnings;
+        const tasks = selection.tasks;
+        if (tasks.length === 0) {
+            (0, uploadLog_1.printTaskSummary)([], warnings, { action: 'upload', environment: env });
+            return;
+        }
+        const results = await processUploadTasks(client, tasks, owner, userInfo.username, userInfo.role, envConfig.webBase, options);
+        (0, uploadLog_1.printTaskSummary)(results, warnings, { action: 'upload', environment: env });
+    });
+}

package/dist/commands/validate.d.ts

@@ -0,0 +1 @@
+export declare function validate(pathOrName: string): Promise<void>;