@playdrop/playdrop-cli 0.5.2 → 0.5.4

package/config/client-meta.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.5.1",
+  "version": "0.5.4",
   "build": 1,
   "platforms": {
     "ios": {
@@ -26,11 +26,11 @@
   },
   "clients": {
     "web": {
-      "minimumVersion": "0.5.1",
+      "minimumVersion": "0.5.4",
       "minimumBuild": 1
     },
     "admin": {
-      "minimumVersion": "0.5.1",
+      "minimumVersion": "0.5.4",
       "minimumBuild": 1
     },
     "apple": {
@@ -38,7 +38,7 @@
       "minimumBuild": 1
     },
     "cli": {
-      "minimumVersion": "0.5.1"
+      "minimumVersion": "0.5.4"
     }
   }
 }

package/dist/apps/build.js

@@ -190,7 +190,7 @@ function readProjectDirEntries(current) {
         return [];
     }
 }
-function appendIncludedProjectFile(rootDir, includePath, fileByRelativePath, results, enforceReservedBundleNames) {
+function appendIncludedProjectFile(rootDir, includePath, excludedRelativeFiles, fileByRelativePath, results, enforceReservedBundleNames) {
     const normalizedIncludePath = (0, node_path_1.normalize)(includePath).split(node_path_1.sep).join('/');
     if (!normalizedIncludePath || normalizedIncludePath === '.') {
         return;
@@ -198,6 +198,9 @@ function appendIncludedProjectFile(rootDir, includePath, fileByRelativePath, res
     if (normalizedIncludePath.startsWith('..')) {
         throw new Error(`[apps][build] Invalid include file path "${includePath}".`);
     }
+    if (excludedRelativeFiles.has(normalizedIncludePath)) {
+        return;
+    }
     if (fileByRelativePath.has(normalizedIncludePath)) {
         return;
     }
@@ -223,8 +226,12 @@ function appendIncludedProjectFile(rootDir, includePath, fileByRelativePath, res
     results.push(record);
     fileByRelativePath.set(record.relativePath, record);
 }
+// eslint-disable-next-line complexity -- Source archive collection needs one pass to enforce ignore/include/exclude rules deterministically.
 function collectProjectFiles(rootDir, rules, options) {
     const includeRelativeFiles = options?.includeRelativeFiles ?? [];
+    const excludeRelativeFiles = new Set(Array.from(options?.excludeRelativeFiles ?? [])
+        .map((filePath) => (0, node_path_1.normalize)(filePath).split(node_path_1.sep).join('/'))
+        .filter((filePath) => filePath.length > 0 && filePath !== '.'));
     const enforceReservedBundleNames = options?.enforceReservedBundleNames ?? false;
     const results = [];
     const fileByRelativePath = new Map();
@@ -263,6 +270,8 @@ function collectProjectFiles(rootDir, rules, options) {
             }
             if (!stats.isFile())
                 continue;
+            if (excludeRelativeFiles.has(relativePath))
+                continue;
             const record = {
                 absolutePath,
                 relativePath: relativePath.split('/').join('/'),
@@ -273,7 +282,7 @@ function collectProjectFiles(rootDir, rules, options) {
         }
     }
     for (const includePath of includeRelativeFiles) {
-        appendIncludedProjectFile(rootDir, includePath, fileByRelativePath, results, enforceReservedBundleNames);
+        appendIncludedProjectFile(rootDir, includePath, excludeRelativeFiles, fileByRelativePath, results, enforceReservedBundleNames);
     }
     results.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
     return results;
@@ -288,6 +297,32 @@ function isReservedBundlePath(relativePath) {
 function resolveRuntimeRoot(task) {
     return (0, node_path_1.resolve)((0, node_path_1.dirname)(task.filePath));
 }
+function collectSeparatelyUploadedSourceFiles(task) {
+    const excludedFiles = new Set();
+    const addFile = (filePath) => {
+        if (!filePath) {
+            return;
+        }
+        const absolutePath = (0, node_path_1.resolve)(filePath);
+        if (!isPathWithinRoot(task.projectDir, absolutePath)) {
+            return;
+        }
+        const relativePath = normalizeRelativePath(task.projectDir, absolutePath);
+        if (!relativePath || relativePath.startsWith('..')) {
+            return;
+        }
+        excludedFiles.add(relativePath);
+    };
+    addFile(task.listing?.iconPath);
+    addFile(task.listing?.heroPortraitPath);
+    addFile(task.listing?.heroLandscapePath);
+    task.listing?.screenshotPortraitPaths?.forEach(addFile);
+    task.listing?.screenshotLandscapePaths?.forEach(addFile);
+    task.listing?.videoPortraitPaths?.forEach(addFile);
+    task.listing?.videoLandscapePaths?.forEach(addFile);
+    task.achievements?.forEach((definition) => addFile(definition.iconPath));
+    return Array.from(excludedFiles).sort((left, right) => left.localeCompare(right));
+}
 function resolveBundleEntryPoint(task, runtimeRoot) {
     const entryPoint = normalizeRelativePath(runtimeRoot, task.filePath);
     if (!entryPoint || entryPoint.startsWith('..')) {
@@ -451,23 +486,31 @@ function createZipArchive(entries) {
 function createSourceArchive(task) {
     const rules = buildIgnoreRules(task.projectDir);
     const includeFiles = ['README.md', 'AGENTS.md'];
+    const excludedFiles = collectSeparatelyUploadedSourceFiles(task);
     if (task.catalogueAbsolutePath && (0, node_fs_1.existsSync)(task.catalogueAbsolutePath)) {
         const relativeCataloguePath = normalizeRelativePath(task.projectDir, task.catalogueAbsolutePath) || 'catalogue.json';
         includeFiles.push(relativeCataloguePath);
     }
     if (task.isTypescriptProject) {
-        const cached = typescriptSourceCache.get(task.projectDir);
+        const cacheKey = [task.projectDir, ...excludedFiles].join('\u0000');
+        const cached = typescriptSourceCache.get(cacheKey);
         if (cached) {
             return cached;
         }
-        const entries = collectProjectFiles(task.projectDir, rules, { includeRelativeFiles: includeFiles });
+        const entries = collectProjectFiles(task.projectDir, rules, {
+            includeRelativeFiles: includeFiles,
+            excludeRelativeFiles: excludedFiles,
+        });
         const buffer = createZipArchive(entries);
         const hash = (0, node_crypto_1.createHash)('sha256').update(buffer).digest('hex');
         const record = { buffer, hash };
-        typescriptSourceCache.set(task.projectDir, record);
+        typescriptSourceCache.set(cacheKey, record);
         return record;
     }
-    const entries = collectProjectFiles(task.projectDir, rules, { includeRelativeFiles: includeFiles });
+    const entries = collectProjectFiles(task.projectDir, rules, {
+        includeRelativeFiles: includeFiles,
+        excludeRelativeFiles: excludedFiles,
+    });
     const buffer = createZipArchive(entries);
     const hash = (0, node_crypto_1.createHash)('sha256').update(buffer).digest('hex');
     return { buffer, hash };

package/dist/apps/index.d.ts

@@ -9,6 +9,8 @@ export type AppPipelineResult = {
 };
 export type AppPipelineOptions = {
     skipEcs?: boolean;
+    skipReview?: boolean;
+    clearTags?: boolean;
     creatorUsername?: string;
 };
 export declare function runAppPipeline(client: ApiClient, task: AppTask, options?: AppPipelineOptions): Promise<AppPipelineResult>;

package/dist/apps/index.js

@@ -16,6 +16,8 @@ async function runAppPipeline(client, task, options) {
     const artifacts = isExternal ? null : await (0, build_1.buildApp)(task);
     const uploadOptions = {
         skipEcs: options?.skipEcs,
+        skipReview: options?.skipReview,
+        clearTags: options?.clearTags,
         creatorUsername: options?.creatorUsername,
     };
     const upload = await (0, upload_1.uploadApp)(client, task, artifacts, uploadOptions);

package/dist/apps/upload.d.ts

@@ -14,6 +14,8 @@ export type AppUploadResult = {
 };
 export type AppUploadOptions = {
     skipEcs?: boolean;
+    skipReview?: boolean;
+    clearTags?: boolean;
     creatorUsername?: string;
 };
 export declare function uploadApp(client: ApiClient, task: AppTask, artifacts: AppBuildArtifacts | null, options?: AppUploadOptions): Promise<AppUploadResult>;

package/dist/apps/upload.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.uploadApp = uploadApp;
 const types_1 = require("@playdrop/types");
+const config_1 = require("@playdrop/config");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const http_1 = require("../http");
@@ -24,16 +25,68 @@ function isMp4Signature(content) {
     }
     return content.toString('ascii', 4, 8) === 'ftyp';
 }
-/**
- * Create a File object from a file path with specified MIME type.
- */
-function createFileFromPath(filePath, mimeType, validator) {
+function createUploadValidationError(code, message) {
+    const error = new Error(`${code}: ${message}`);
+    error.code = code;
+    return error;
+}
+function formatLimitBytes(maxBytes) {
+    if (maxBytes >= 1024 * 1024) {
+        return `${maxBytes / 1024 / 1024}MB`;
+    }
+    return `${maxBytes / 1024}KB`;
+}
+function createFileFromPath(filePath, mimeType, maxBytes, sizeCode, typeCode, label, validator) {
     const content = (0, node_fs_1.readFileSync)(filePath);
+    if (content.length > maxBytes) {
+        throw createUploadValidationError(sizeCode, `${label} must be under ${formatLimitBytes(maxBytes)}. Received ${content.length} bytes from ${filePath}.`);
+    }
     if (validator && !validator(content)) {
-        throw new Error(`Invalid listing file signature for ${filePath}. Expected ${mimeType}.`);
+        throw createUploadValidationError(typeCode, `${label} must match ${mimeType}. Invalid file signature at ${filePath}.`);
     }
     const name = (0, node_path_1.basename)(filePath);
-    return new File([content], name, { type: mimeType });
+    return {
+        file: new File([content], name, { type: mimeType }),
+        size: content.length,
+    };
+}
+// eslint-disable-next-line complexity -- Source archive failures need distinct guidance when publish-only media is already excluded.
+function ensurePreparedArtifactSize(file, maxBytes, code, label, task) {
+    if (!file) {
+        return 0;
+    }
+    if (file.size > maxBytes) {
+        if (code === 'source_too_large' && task) {
+            const hasSeparatePublishMedia = Boolean(task.listing?.iconPath
+                || task.listing?.heroPortraitPath
+                || task.listing?.heroLandscapePath
+                || task.listing?.screenshotPortraitPaths?.length
+                || task.listing?.screenshotLandscapePaths?.length
+                || task.listing?.videoPortraitPaths?.length
+                || task.listing?.videoLandscapePaths?.length
+                || task.achievements?.length);
+            const suffix = hasSeparatePublishMedia
+                ? ' Listing and achievement media are uploaded separately and excluded from source.zip. The remaining source archive is still too large.'
+                : '';
+            throw createUploadValidationError(code, `${label} must be under ${formatLimitBytes(maxBytes)}. Received ${file.size} bytes.${suffix}`);
+        }
+        throw createUploadValidationError(code, `${label} must be under ${formatLimitBytes(maxBytes)}. Received ${file.size} bytes.`);
+    }
+    return file.size;
+}
+function accumulateUploadBytes(taskName, currentTotal, nextBytes) {
+    const nextTotal = currentTotal + nextBytes;
+    if (nextTotal > config_1.MAX_VERSION_TOTAL_BYTES) {
+        throw createUploadValidationError('upload_too_large', `Total upload for "${taskName}" exceeds ${formatLimitBytes(config_1.MAX_VERSION_TOTAL_BYTES)}. Received ${nextTotal} bytes.`);
+    }
+    return nextTotal;
+}
+function pushPreparedFile(taskName, currentTotal, prepared) {
+    return accumulateUploadBytes(taskName, currentTotal, prepared.size);
+}
+function pushPreparedArtifact(task, currentTotal, file, maxBytes, code, label) {
+    const bytes = ensurePreparedArtifactSize(file, maxBytes, code, label, task);
+    return accumulateUploadBytes(task.name, currentTotal, bytes);
 }
 async function uploadApp(client, task, artifacts, options) {
     // Version is required - no legacy fallback
@@ -46,28 +99,37 @@ async function uploadApp(client, task, artifacts, options) {
 /**
  * Upload an app version using the versioned API.
  */
+// eslint-disable-next-line complexity -- Upload assembly mirrors the versioned multipart contract in one place.
 async function uploadAppVersion(client, task, artifacts, options) {
     const creatorUsername = typeof options?.creatorUsername === 'string' ? options.creatorUsername.trim() : '';
     if (!creatorUsername) {
         throw new Error(`Missing creator username for app "${task.name}" upload.`);
     }
+    let totalUploadBytes = 0;
+    const achievements = task.achievements ?? [];
+    const leaderboards = task.leaderboards ?? [];
+    const listing = task.listing;
     const versionOptions = {
         version: task.version,
         releaseNotes: task.releaseNotes,
         visibility: task.versionVisibility,
         remixRef: task.remix,
+        tags: task.tags,
+        clearTags: options?.clearTags,
         surfaceTargets: task.surfaceTargets,
+        assetSpecSupport: task.assetSpecSupport,
         entryPoint: artifacts?.metadata?.entryPoint ?? undefined,
         authMode: task.authMode,
         controllerMode: task.controllerMode,
         previewable: task.previewable,
+        skipReview: options?.skipReview,
         // App metadata (used when creating app if it doesn't exist)
         displayName: task.displayName,
         description: task.description,
         type: task.type,
         emoji: task.emoji ?? undefined,
         color: task.color ?? undefined,
-        achievements: task.achievements.map((definition) => ({
+        achievements: achievements.map((definition) => ({
             key: definition.key,
             displayName: definition.displayName,
             description: definition.description,
@@ -77,7 +139,7 @@ async function uploadAppVersion(client, task, artifacts, options) {
             icon: definition.icon,
             status: definition.status,
         })),
-        leaderboards: task.leaderboards.map((definition) => ({
+        leaderboards: leaderboards.map((definition) => ({
             key: definition.key,
             displayName: definition.displayName,
             description: definition.description,
@@ -86,10 +148,14 @@ async function uploadAppVersion(client, task, artifacts, options) {
             ...(definition.unitLabel ? { unitLabel: definition.unitLabel } : {}),
             status: definition.status,
         })),
-        achievementIconFiles: task.achievements.map((definition) => ({
-            key: definition.key,
-            file: createFileFromPath(definition.iconPath, 'image/png', isPngSignature),
-        })),
+        achievementIconFiles: achievements.map((definition) => {
+            const prepared = createFileFromPath(definition.iconPath, 'image/png', config_1.MAX_VERSION_ICON_BYTES, 'achievement_icon_too_large', 'invalid_achievement_icon_content_type', `Achievement icon "${definition.key}"`, isPngSignature);
+            totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
+            return {
+                key: definition.key,
+                file: prepared.file,
+            };
+        }),
     };
     // For EXTERNAL hosting mode, use externalUrl instead of bundle
     if (task.hostingMode === 'EXTERNAL') {
@@ -97,40 +163,66 @@ async function uploadAppVersion(client, task, artifacts, options) {
     }
     else if (artifacts) {
         // HOSTED mode - include bundle and optional files
+        totalUploadBytes = pushPreparedArtifact(task, totalUploadBytes, artifacts.bundleFile, config_1.MAX_VERSION_BUNDLE_BYTES, 'bundle_too_large', 'Bundle');
+        totalUploadBytes = pushPreparedArtifact(task, totalUploadBytes, artifacts.sourceFile, config_1.MAX_APP_SOURCE_BYTES, 'source_too_large', 'Source archive');
         versionOptions.bundle = artifacts.bundleFile;
         versionOptions.source = artifacts.sourceFile;
         // Include ecs/server files unless skipEcs is set
         if (!options?.skipEcs) {
             if (artifacts.ecsFile) {
+                totalUploadBytes = pushPreparedArtifact(task, totalUploadBytes, artifacts.ecsFile, config_1.MAX_APP_ECS_BYTES, 'ecs_too_large', 'ECS config');
                 versionOptions.ecs = artifacts.ecsFile;
             }
             if (artifacts.serverFile) {
+                totalUploadBytes = pushPreparedArtifact(task, totalUploadBytes, artifacts.serverFile, config_1.MAX_APP_SERVER_BYTES, 'server_too_large', 'Server.js');
                 versionOptions.server = artifacts.serverFile;
             }
         }
     }
     // Add listing assets if provided
-    if (task.listing) {
-        if (task.listing.iconPath) {
-            versionOptions.icon = createFileFromPath(task.listing.iconPath, 'image/png', isPngSignature);
+    if (listing) {
+        if (listing.iconPath) {
+            const prepared = createFileFromPath(listing.iconPath, 'image/png', config_1.MAX_VERSION_ICON_BYTES, 'icon_too_large', 'invalid_icon_content_type', 'Icon', isPngSignature);
+            totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
+            versionOptions.icon = prepared.file;
         }
-        if (task.listing.heroPortraitPath) {
-            versionOptions.heroPortrait = createFileFromPath(task.listing.heroPortraitPath, 'image/png', isPngSignature);
+        if (listing.heroPortraitPath) {
+            const prepared = createFileFromPath(listing.heroPortraitPath, 'image/png', config_1.MAX_VERSION_HERO_BYTES, 'hero_portrait_too_large', 'invalid_hero_portrait_content_type', 'Hero portrait', isPngSignature);
+            totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
+            versionOptions.heroPortrait = prepared.file;
         }
-        if (task.listing.heroLandscapePath) {
-            versionOptions.heroLandscape = createFileFromPath(task.listing.heroLandscapePath, 'image/png', isPngSignature);
+        if (listing.heroLandscapePath) {
+            const prepared = createFileFromPath(listing.heroLandscapePath, 'image/png', config_1.MAX_VERSION_HERO_BYTES, 'hero_landscape_too_large', 'invalid_hero_landscape_content_type', 'Hero landscape', isPngSignature);
+            totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
+            versionOptions.heroLandscape = prepared.file;
         }
-        if (task.listing.screenshotPortraitPaths.length > 0) {
-            versionOptions.screenshotsPortrait = task.listing.screenshotPortraitPaths.map((p) => createFileFromPath(p, 'image/png', isPngSignature));
+        if ((listing.screenshotPortraitPaths ?? []).length > 0) {
+            versionOptions.screenshotsPortrait = listing.screenshotPortraitPaths.map((filePath, index) => {
+                const prepared = createFileFromPath(filePath, 'image/png', config_1.MAX_VERSION_SCREENSHOT_BYTES, 'screenshot_portrait_too_large', 'invalid_screenshot_portrait_content_type', `Portrait screenshot ${index + 1}`, isPngSignature);
+                totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
+                return prepared.file;
+            });
         }
-        if (task.listing.screenshotLandscapePaths.length > 0) {
-            versionOptions.screenshotsLandscape = task.listing.screenshotLandscapePaths.map((p) => createFileFromPath(p, 'image/png', isPngSignature));
+        if ((listing.screenshotLandscapePaths ?? []).length > 0) {
+            versionOptions.screenshotsLandscape = listing.screenshotLandscapePaths.map((filePath, index) => {
+                const prepared = createFileFromPath(filePath, 'image/png', config_1.MAX_VERSION_SCREENSHOT_BYTES, 'screenshot_landscape_too_large', 'invalid_screenshot_landscape_content_type', `Landscape screenshot ${index + 1}`, isPngSignature);
+                totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
+                return prepared.file;
+            });
         }
-        if (task.listing.videoPortraitPaths.length > 0) {
-            versionOptions.videosPortrait = task.listing.videoPortraitPaths.map((p) => createFileFromPath(p, 'video/mp4', isMp4Signature));
+        if ((listing.videoPortraitPaths ?? []).length > 0) {
+            versionOptions.videosPortrait = listing.videoPortraitPaths.map((filePath, index) => {
+                const prepared = createFileFromPath(filePath, 'video/mp4', config_1.MAX_VERSION_VIDEO_BYTES, 'video_portrait_too_large', 'invalid_video_portrait_content_type', `Portrait video ${index + 1}`, isMp4Signature);
+                totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
+                return prepared.file;
+            });
         }
-        if (task.listing.videoLandscapePaths.length > 0) {
-            versionOptions.videosLandscape = task.listing.videoLandscapePaths.map((p) => createFileFromPath(p, 'video/mp4', isMp4Signature));
+        if ((listing.videoLandscapePaths ?? []).length > 0) {
+            versionOptions.videosLandscape = listing.videoLandscapePaths.map((filePath, index) => {
+                const prepared = createFileFromPath(filePath, 'video/mp4', config_1.MAX_VERSION_VIDEO_BYTES, 'video_landscape_too_large', 'invalid_video_landscape_content_type', `Landscape video ${index + 1}`, isMp4Signature);
+                totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
+                return prepared.file;
+            });
         }
     }
     try {
@@ -164,7 +256,13 @@ async function uploadAppVersion(client, task, artifacts, options) {
             }
             const statusText = `status ${unknownError.status}`;
             const message = detail ? `${statusText} - ${detail}` : statusText;
-            throw new Error(`Upload failed for ${task.name}: ${message}`);
+            const errorCode = typeof unknownError.code === 'string' && unknownError.code.trim().length > 0
+                ? unknownError.code.trim()
+                : '';
+            const annotatedMessage = detail
+                ? `${errorCode ? `${errorCode}: ` : ''}${detail}`
+                : `${statusText}${errorCode ? ` (${errorCode})` : ''}`;
+            throw new Error(`Upload failed for ${task.name}: ${annotatedMessage}`);
         }
         throw unknownError;
     }

package/dist/assetSpecs.d.ts

@@ -0,0 +1,16 @@
+import { type AssetSpecCapability, type AssetSpecContract, type AssetSpecValidationKind } from '@playdrop/types';
+export type AssetSpecSupportDeclaration = {
+    assetSpec: string;
+    versionRange: string;
+    capabilities: AssetSpecCapability[];
+};
+export type LoadedAssetSpecContract = {
+    contract: AssetSpecContract;
+    validationKind: AssetSpecValidationKind;
+    contractPath: string;
+};
+export declare function normalizeAssetSpecSupportEntries(raw: unknown, errors: string[], context: string): AssetSpecSupportDeclaration[];
+export declare function loadAndValidateAssetSpecContract(catalogueDir: string, relativeContractPath: string, errors: string[], context: string): LoadedAssetSpecContract | null;
+export declare function validateCustomAssetFilesAgainstContract(contract: AssetSpecContract, filePaths: Record<string, string>, errors: string[], context: string): void;
+export declare function normalizeAssetSpecVersionRef(raw: unknown, errors: string[], context: string): string | undefined;
+export declare function validateAssetSpecName(name: string, errors: string[], context: string): boolean;