@playdrop/playdrop-cli 0.11.9 → 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

@@ -7,7 +7,7 @@ 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;
@@ -339,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/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

@@ -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

@@ -1249,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/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 {};