@playdrop/playdrop-cli 0.11.8 → 0.12.0

package/dist/apps/upload.d.ts

@@ -17,8 +17,9 @@ export type AppUploadOptions = {
     creatorUsername?: string;
     token?: string | null;
     user?: UserResponse | null;
-    runStagedUploadLaunchCheck?: boolean;
-    launchCheckTimeoutMs?: number;
+    runStagedUploadLoadCheck?: boolean;
+    loadCheckTimeoutMs?: number;
     agentTaskId?: number;
+    mediaCaptureRequired?: boolean;
 };
 export declare function uploadApp(client: ApiClient, task: AppTask, artifacts: AppBuildArtifacts | null, options?: AppUploadOptions): Promise<AppUploadResult>;

package/dist/apps/upload.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.uploadApp = uploadApp;
-const node_crypto_1 = require("node:crypto");
-const types_1 = require("@playdrop/types");
 const config_1 = require("@playdrop/config");
+const types_1 = require("@playdrop/types");
+const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const http_1 = require("../http");
-const launchCheck_1 = require("./launchCheck");
+const loadCheck_1 = require("./loadCheck");
 const EXTENSION_TO_MIME = {
     '.png': 'image/png',
     '.jpg': 'image/jpeg',
@@ -74,6 +74,97 @@ async function bufferFromFile(file) {
 function computeSha256Hex(buffer) {
     return (0, node_crypto_1.createHash)('sha256').update(buffer).digest('hex');
 }
+function isSha256Hex(value) {
+    return typeof value === 'string' && /^[a-f0-9]{64}$/i.test(value.trim());
+}
+function isCaptureMediaFileKey(fileKey) {
+    return fileKey.startsWith('screenshotsPortrait:')
+        || fileKey.startsWith('screenshotsLandscape:')
+        || fileKey.startsWith('videosPortrait:')
+        || fileKey.startsWith('videosLandscape:');
+}
+function readMediaCaptureProof(input) {
+    const reportPath = input.task.listing?.captureReportPath;
+    if (!reportPath) {
+        throw new Error(`agent_task_media_capture_report_missing: ${input.task.name} must include listing.captureReport from "playdrop project capture".`);
+    }
+    let report;
+    try {
+        report = JSON.parse((0, node_fs_1.readFileSync)(reportPath, 'utf8'));
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`agent_task_media_capture_report_invalid: ${reportPath} must be valid JSON. ${reason}`);
+    }
+    const binding = report?.binding;
+    if (!binding || typeof binding !== 'object' || Array.isArray(binding)) {
+        throw new Error(`agent_task_media_capture_report_invalid: ${reportPath} is missing binding.`);
+    }
+    const contentHash = typeof binding.contentHash === 'string' ? binding.contentHash.trim().toLowerCase() : '';
+    if (!isSha256Hex(contentHash)) {
+        throw new Error(`agent_task_media_capture_report_invalid: ${reportPath} binding.contentHash must be a SHA-256 hex string.`);
+    }
+    if (contentHash !== input.artifacts.bundleHash) {
+        throw new Error(`agent_task_media_capture_build_mismatch: capture report contentHash does not match the bundle being uploaded for ${input.task.name}. Rerun "playdrop project capture" after the final build changes.`);
+    }
+    const rawArtifactHashes = binding.artifactHashes;
+    if (!rawArtifactHashes || typeof rawArtifactHashes !== 'object' || Array.isArray(rawArtifactHashes)) {
+        throw new Error(`agent_task_media_capture_report_invalid: ${reportPath} binding.artifactHashes must be an object.`);
+    }
+    const captureArtifactHashEntries = Object.values(rawArtifactHashes)
+        .map((value) => typeof value === 'string' ? value.trim().toLowerCase() : '')
+        .filter((value) => isSha256Hex(value));
+    const captureArtifactHashes = new Set(captureArtifactHashEntries);
+    if (captureArtifactHashEntries.length === 0) {
+        throw new Error(`agent_task_media_capture_report_invalid: ${reportPath} binding.artifactHashes is empty.`);
+    }
+    const captureArtifactHashCounts = new Map();
+    for (const hash of captureArtifactHashEntries) {
+        captureArtifactHashCounts.set(hash, (captureArtifactHashCounts.get(hash) ?? 0) + 1);
+    }
+    const mediaFiles = input.preparedSessionFiles.filter((file) => isCaptureMediaFileKey(file.fileKey));
+    if (mediaFiles.length === 0) {
+        throw new Error(`agent_task_media_capture_artifacts_missing: ${input.task.name} must upload recorder stills and video in listing.screenshots* and listing.videos*.`);
+    }
+    const uploadedMediaHashCounts = new Map();
+    for (const file of mediaFiles) {
+        uploadedMediaHashCounts.set(file.sha256, (uploadedMediaHashCounts.get(file.sha256) ?? 0) + 1);
+    }
+    const missingUploadedCaptureArtifacts = [...captureArtifactHashCounts.entries()]
+        .filter(([hash, expectedCount]) => (uploadedMediaHashCounts.get(hash) ?? 0) < expectedCount);
+    if (missingUploadedCaptureArtifacts.length > 0) {
+        throw new Error(`agent_task_media_capture_artifact_missing_from_listing: ${input.task.name} must list every recorder poster and video from listing.captureReport in catalogue.json.`);
+    }
+    let hasStill = false;
+    let hasVideo = false;
+    const artifactHashes = {};
+    for (const file of mediaFiles) {
+        if (!captureArtifactHashes.has(file.sha256)) {
+            throw new Error(`agent_task_media_capture_artifact_mismatch: ${file.fileKey} was not produced by listing.captureReport for ${input.task.name}.`);
+        }
+        hasStill = hasStill || file.fileKey.startsWith('screenshots');
+        hasVideo = hasVideo || file.fileKey.startsWith('videos');
+        artifactHashes[file.fileKey] = file.sha256;
+    }
+    if (!hasStill || !hasVideo) {
+        throw new Error(`agent_task_media_capture_artifacts_missing: ${input.task.name} must upload at least one recorder still and one recorder video.`);
+    }
+    const capturedSurfaces = Array.isArray(binding.capturedSurfaces)
+        ? Array.from(new Set(binding.capturedSurfaces
+            .map((surface) => typeof surface === 'string' ? surface.trim().toUpperCase() : '')
+            .filter((surface) => input.task.surfaceTargets.includes(surface))))
+        : [];
+    const capturedSurfaceSet = new Set(capturedSurfaces);
+    const missingSurfaces = input.task.surfaceTargets.filter((surface) => !capturedSurfaceSet.has(surface));
+    if (missingSurfaces.length > 0) {
+        throw new Error(`agent_task_media_capture_surface_missing: listing.captureReport did not capture ${missingSurfaces.join(', ')} for ${input.task.name}.`);
+    }
+    return {
+        contentHash,
+        artifactHashes,
+        capturedSurfaces,
+    };
+}
 function resolveMimeType(filename, fallback = 'application/octet-stream') {
     const type = EXTENSION_TO_MIME[(0, node_path_1.extname)(filename).toLowerCase()];
     return type ?? fallback;
@@ -159,7 +250,6 @@ 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) {
@@ -340,20 +430,33 @@ async function uploadAppVersion(client, task, artifacts, options) {
                     })),
                 });
             }
+            if (options?.mediaCaptureRequired === true
+                && task.hostingMode !== 'EXTERNAL'
+                && !task.externalUrl) {
+                if (!artifacts) {
+                    throw new Error(`agent_task_media_capture_build_missing: ${task.name} has no hosted build artifacts to bind capture media to.`);
+                }
+                const mediaCaptureProof = readMediaCaptureProof({
+                    task,
+                    artifacts,
+                    preparedSessionFiles,
+                });
+                await client.recordAppUploadMediaCapture(creatorUsername, task.name, sessionId, mediaCaptureProof);
+            }
             if (task.hostingMode !== 'EXTERNAL'
                 && !task.externalUrl
-                && options?.runStagedUploadLaunchCheck) {
-                const launchCheck = await (0, launchCheck_1.runUploadedHostedLaunchCheck)({
+                && options?.runStagedUploadLoadCheck) {
+                const loadCheck = await (0, loadCheck_1.runUploadedHostedLoadCheck)({
                     client,
                     creatorUsername,
                     task,
                     sessionId,
-                    timeoutMs: options.launchCheckTimeoutMs,
+                    timeoutMs: options.loadCheckTimeoutMs,
                     token: options?.token ?? null,
                     currentUser: options?.user ?? null,
                 });
-                if (launchCheck.status !== 'PASSED') {
-                    throw new Error((0, launchCheck_1.formatHostedLaunchCheckFailure)(task.name, launchCheck, 'staged'));
+                if (loadCheck.status !== 'PASSED') {
+                    throw new Error((0, loadCheck_1.formatHostedLoadCheckFailure)(task.name, loadCheck, 'staged'));
                 }
             }
         }

package/dist/assetSpecs.js

@@ -9,11 +9,11 @@ exports.loadAndValidateAssetSpecContract = loadAndValidateAssetSpecContract;
 exports.validateCustomAssetFilesAgainstContract = validateCustomAssetFilesAgainstContract;
 exports.normalizeAssetSpecVersionRef = normalizeAssetSpecVersionRef;
 exports.validateAssetSpecName = validateAssetSpecName;
+const types_1 = require("@playdrop/types");
+const ajv_1 = __importDefault(require("ajv"));
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
-const ajv_1 = __importDefault(require("ajv"));
 const semver_1 = require("semver");
-const types_1 = require("@playdrop/types");
 const LOCAL_EXTENSION_TO_MIME = {
     '.png': 'image/png',
     '.jpg': 'image/jpeg',
@@ -75,7 +75,6 @@ function resolveCustomAssetRoleContentType(filePath, roleContract) {
     }
     return resolvedContentType;
 }
-// eslint-disable-next-line complexity
 function normalizeAssetSpecSupportEntries(raw, errors, context) {
     if (raw === undefined || raw === null) {
         return [];
@@ -130,7 +129,6 @@ function normalizeAssetSpecSupportEntries(raw, errors, context) {
     }
     return rows;
 }
-// eslint-disable-next-line complexity
 function loadAndValidateAssetSpecContract(catalogueDir, relativeContractPath, errors, context) {
     const contractPath = (0, node_path_1.resolve)(catalogueDir, relativeContractPath);
     let rawText;
@@ -213,7 +211,6 @@ function loadAndValidateAssetSpecContract(catalogueDir, relativeContractPath, er
         contractPath,
     };
 }
-// eslint-disable-next-line complexity
 function validateCustomAssetFilesAgainstContract(contract, filePaths, errors, context) {
     const contractRoles = new Map(contract.roles.map((role) => [role.name.trim().toLowerCase(), role]));
     const providedRoles = new Set();

package/dist/catalogue-utils.d.ts

@@ -12,6 +12,7 @@ export declare function parseSurfaceTargets(input: unknown): ParsedSurfaceTarget
 export type AppCatalogueInfo = {
     name: string;
     type: string;
+    previewable: boolean;
     surfaceTargets: ParsedSurfaceTargets;
     cataloguePath: string;
 };

package/dist/catalogue-utils.js

@@ -108,6 +108,7 @@ function findAppCatalogueInfo(htmlPath) {
                 return {
                     name,
                     type: parsedType,
+                    previewable: match.previewable === true,
                     surfaceTargets: cloneSurfaceTargets(surfaceTargets),
                     cataloguePath,
                 };

package/dist/catalogue.d.ts

@@ -1,4 +1,4 @@
-import { type AppSurface, type AppType, type AppHostingMode, type AppAuthMode, type AppControllerMode, type AppVersionVisibility, type AppVersionDesign, type AppAchievementCatalogueDefinition, type AppLeaderboardCatalogueDefinition, type PlayerMetaDefinitionStatus, type CatalogueTagGroupDefinition, type AppMetadataAssetSpecSupport, type AssetSpecContract, type AssetSpecStatus, type AssetSpecValidationKind, type ContentLicense } from '@playdrop/types';
+import { type AppAchievementCatalogueDefinition, type AppAuthMode, type AppControllerMode, type AppHostingMode, type AppLeaderboardCatalogueDefinition, type AppMetadataAssetSpecSupport, type AppSurface, type AppType, type AppVersionDesign, type AppVersionVisibility, type AssetSpecContract, type AssetSpecStatus, type AssetSpecValidationKind, type CatalogueTagGroupDefinition, type ContentLicense, type PlayerMetaDefinitionStatus } from '@playdrop/types';
 import { type AssetSpecSupportDeclaration } from './assetSpecs';
 export type CatalogueJson = {
     apps?: Array<Record<string, unknown>>;
@@ -19,6 +19,7 @@ export type AppListingConfig = {
     screenshotsLandscape?: string[];
     videosPortrait?: string[];
     videosLandscape?: string[];
+    captureReport?: string;
 };
 export type ResolvedAppAchievementDefinition = Omit<AppAchievementCatalogueDefinition, 'status'> & {
     iconPath: string;
@@ -152,6 +153,7 @@ export type ResolvedListingAssets = {
     screenshotLandscapePaths: string[];
     videoPortraitPaths: string[];
     videoLandscapePaths: string[];
+    captureReportPath?: string;
 };
 export type AppDependencyAssetRef = {
     ref: string;

package/dist/catalogue.js

@@ -1,5 +1,4 @@
 "use strict";
-/* eslint-disable complexity, max-lines, max-lines-per-function */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateAppMetadata = validateAppMetadata;
 exports.resolveCatalogueTagGroups = resolveCatalogueTagGroups;
@@ -8,11 +7,11 @@ exports.resolveWorkspaceApp = resolveWorkspaceApp;
 exports.formatMetadataWarnings = formatMetadataWarnings;
 exports.formatMissingMetadataWarnings = formatMissingMetadataWarnings;
 exports.findAppTaskByFile = findAppTaskByFile;
+const types_1 = require("@playdrop/types");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
-const types_1 = require("@playdrop/types");
-const catalogue_utils_1 = require("./catalogue-utils");
 const assetSpecs_1 = require("./assetSpecs");
+const catalogue_utils_1 = require("./catalogue-utils");
 const HEX_COLOR_REGEX = /^#?(?:[0-9a-fA-F]{6})$/;
 const SEMVER_REGEX = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
 const LEGACY_CATALOGUE_VERSION_KEY = ['schema', 'Version'].join('');
@@ -1250,6 +1249,23 @@ function buildAppTasks(rootDir, catalogues, options) {
                         }
                     }
                 }
+                if (!listingValidationFailed && typeof rawListing.captureReport === 'string' && rawListing.captureReport.trim()) {
+                    const captureReportPath = rawListing.captureReport.trim();
+                    if ((0, node_path_1.extname)(captureReportPath).toLowerCase() !== '.json') {
+                        errors.push(`[${label}] Skipping ${rawName}: listing.captureReport must point to a JSON file.`);
+                        listingValidationFailed = true;
+                    }
+                    else {
+                        const validationError = validateListingAssetPath(file.directory, captureReportPath, 'listing.captureReport');
+                        if (validationError) {
+                            errors.push(`[${label}] Skipping ${rawName}: ${validationError}`);
+                            listingValidationFailed = true;
+                        }
+                        else {
+                            resolvedListing.captureReportPath = resolveListingAssetPath(file.directory, captureReportPath);
+                        }
+                    }
+                }
                 if (listingValidationFailed) {
                     continue;
                 }

package/dist/commands/browse.js

@@ -380,7 +380,7 @@ function parseBrowseCommandOptions(options) {
     };
 }
 async function loadMergedBrowseResults(input) {
-    const { client, creator, creatorUsername, appType, assetCategory, assetSubcategory, assetSpec, assetSpecOwner, assetSpecName, limit, offset, tags, } = input;
+    const { client, creatorUsername, appType, assetCategory, assetSubcategory, assetSpec, assetSpecOwner, assetSpecName, limit, offset, tags, } = input;
     const appResultsPromise = creatorUsername
         ? collectPaginatedItems((pageLimit, pageOffset) => client.fetchAppsByCreator(creatorUsername, {
             limit: pageLimit,
@@ -546,7 +546,7 @@ async function runAssetPackBrowseCommand(input) {
     };
 }
 async function runBrowseCommand(input) {
-    const { client, kind, creator, creatorUsername, appType, auth, controller, surface, sort, limit, offset, tags, } = input;
+    const { client, kind, creatorUsername, appType, auth, controller, surface, sort, limit, offset, tags, } = input;
     if (kind === 'app') {
         if (creatorUsername) {
             const response = await client.fetchAppsByCreator(creatorUsername, {

package/dist/commands/build.js

@@ -23,9 +23,11 @@ async function build(pathOrName) {
     for (const task of (0, taskUtils_1.sortTasks)(tasks)) {
         const entityId = task.name;
         try {
+            let detail;
             if (task.kind === 'app') {
                 await (0, apps_1.validateAppTask)(task);
-                await (0, apps_1.buildApp)(task);
+                const artifacts = await (0, apps_1.buildApp)(task);
+                detail = `bundleHash=${artifacts.bundleHash}`;
             }
             else if (task.kind === 'asset' || task.kind === 'owned-asset') {
                 const generated = await (0, model_artifacts_1.prepareModel3DAssetArtifacts)(task);
@@ -42,6 +44,7 @@ async function build(pathOrName) {
                 entityType: task.kind,
                 entityId,
                 catalogue: task.cataloguePath,
+                detail,
             };
             results.push(entry);
             console.log((0, uploadLog_1.formatTaskLogLine)(entry));

package/dist/commands/captureListing.d.ts

@@ -1,3 +1,5 @@
+import { type AppSurface } from '@playdrop/types';
+import type { BrowserContextOptions } from 'playwright-core';
 type CaptureListingOptions = {
     app?: string;
     duration?: string | number;
@@ -8,6 +10,7 @@ type CaptureListingOptions = {
     audio?: boolean;
     outputDir?: string;
     keepRaw?: boolean;
+    contentHash?: string;
 };
 type ParsedCaptureListingOptions = {
     targetArg?: string;
@@ -20,6 +23,8 @@ type ParsedCaptureListingOptions = {
     audio: boolean;
     outputDir: string | null;
     keepRaw: boolean;
+    contentHash: string | null;
+    explicitDimensions: boolean;
 };
 type CaptureRect = {
     x: number;
@@ -45,11 +50,35 @@ type CropRect = {
     width: number;
     height: number;
 };
-export declare function resolveListingCaptureRouteSegment(previewable: boolean): 'dev' | 'dev-preview';
+export declare function resolveListingCaptureRouteSegment(previewable: boolean): 'dev-preview';
+export declare function resolveCaptureListingDevRouterPort(env?: NodeJS.ProcessEnv): number;
+export declare function resolveListingCaptureLocalDevPort(devRouterPort: number): number | null;
+export declare function buildListingCaptureFrameUrl({ webBase, currentUsername, appTypeSlug, appName, routeSegment, localDevPort, }: {
+    webBase: string;
+    currentUsername: string;
+    appTypeSlug: string;
+    appName: string;
+    routeSegment: 'dev-preview';
+    localDevPort: number | null;
+}): string;
 export declare function resolveListingCaptureSceneId(width: number, height: number): 'listing-landscape' | 'listing-portrait';
 export declare function parseCaptureListingOptions(targetArg: string | undefined, options?: CaptureListingOptions): ParsedCaptureListingOptions;
 export declare function assertSupportedListingEnvironment(platform?: NodeJS.Platform, macosVersion?: string): void;
 export declare function resolveListingRecorderPath(baseDir?: string): string;
+export declare function buildSurfaceOutputPaths(outputDir: string, surface: AppSurface, useSurfacePrefix: boolean): {
+    rawVideoPath: string;
+    metadataPath: string;
+    posterPath: string;
+    finalVideoPath: string;
+};
+export declare function resolveCaptureDimensions(surface: AppSurface, parsedOptions: ParsedCaptureListingOptions): {
+    width: number;
+    height: number;
+};
+export declare function resolveListingCaptureBrowserContextOptions(surface: AppSurface, dimensions: {
+    width: number;
+    height: number;
+}): BrowserContextOptions;
 export declare function computeRecordedCrop(measurement: HostedGameMeasurement, rawWidth: number, rawHeight: number): CropRect;
 export declare function captureListing(targetArg: string | undefined, options?: CaptureListingOptions): Promise<void>;
 export {};