@playdrop/playdrop-cli 0.13.16 → 0.13.17

package/config/client-meta.json

@@ -1,7 +1,7 @@
 {
-  "version": "0.13.16",
+  "version": "0.13.17",
   "build": 1,
-  "runtimeSdkVersion": "0.13.16",
+  "runtimeSdkVersion": "0.13.17",
   "runtimeSdkBuild": 1,
   "clients": {
     "all": {

package/dist/apps/staticHtml.js

@@ -240,6 +240,7 @@ function buildStaticAppTask(input) {
         hasValidateScript: false,
         hasFormatScript: false,
         displayName: input.metadata.title,
+        ...(input.metadata.description ? { subtitle: input.metadata.description } : {}),
         ...(input.metadata.description ? { description: input.metadata.description } : {}),
         type: 'GAME',
         surfaceTargets: [...STATIC_GAME_SURFACES],

package/dist/commandContext.js

@@ -154,7 +154,7 @@ function resolveWorkspaceSelectedAccount(cfg, currentAccount, workspaceAuth, req
                 matchingSessions,
             };
         }
-        if (workspaceAuth.config.taskToken && currentAccount) {
+        if (currentAccount) {
             if (currentAccount.env === preferredEnv) {
                 return {
                     account: currentAccount,

package/dist/commands/captureListing.d.ts

@@ -22,6 +22,7 @@ type ParsedCaptureListingOptions = {
     posterAtSeconds: number;
     audio: boolean;
     outputDir: string | null;
+    outputDirInput: string | null;
     keepRaw: boolean;
     explicitDimensions: boolean;
 };
@@ -70,6 +71,43 @@ type ListingRecorderMetadata = {
     recordedDurationSeconds: number;
     recordedFileSizeBytes: number;
 };
+type ListingCaptureSurfaceReport = {
+    surface: AppSurface;
+    targetUrl: string;
+    command: {
+        durationSeconds: number;
+        width: number;
+        height: number;
+        fps: number;
+        posterAtSeconds: number;
+        audio: boolean;
+        keepRaw: boolean;
+    };
+    measurement: HostedGameMeasurement;
+    recorder: ListingRecorderMetadata;
+    crop: CropRect;
+    rawVideo: {
+        path: string | null;
+        width: number;
+        height: number;
+        durationSeconds: number;
+        audioTrackCount: number;
+    };
+    finalVideo: {
+        path: string;
+        width: number;
+        height: number;
+        durationSeconds: number;
+        audioTrackCount: number;
+        fps: number | null;
+    };
+    posterPath: string;
+    warnings: string[];
+};
+export type ExportedListingAudio = {
+    mimeType: string;
+    base64: string;
+};
 export declare function resolveListingCaptureRouteSegment(previewable: boolean): 'dev-preview';
 export declare function resolveCaptureListingDevRouterPort(env?: NodeJS.ProcessEnv): number;
 export declare function resolveListingCaptureLocalDevPort(devRouterPort: number): number | null;
@@ -84,6 +122,7 @@ export declare function buildListingCaptureFrameUrl({ webBase, currentUsername,
 }): 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 resolveCaptureListingExplicitOutputDir(outputDirInput: string | null, cwdResolvedOutputDir: string | null, projectDir: string): string | null;
 export declare function assertSupportedListingEnvironment(platform?: NodeJS.Platform, macosVersion?: string): void;
 export declare function resolveListingRecorderPath(workerHome?: string): string;
 export declare function buildSurfaceOutputPaths(outputDir: string, surface: AppSurface, useSurfacePrefix: boolean): {
@@ -92,6 +131,7 @@ export declare function buildSurfaceOutputPaths(outputDir: string, surface: AppS
     posterPath: string;
     finalVideoPath: string;
 };
+export declare function resolveWorkerCaptureOutputDir(projectDir: string, isWorkerGameTask: boolean): string | null;
 export declare function resolveCaptureDimensions(surface: AppSurface, parsedOptions: ParsedCaptureListingOptions): {
     width: number;
     height: number;
@@ -100,7 +140,10 @@ export declare function resolveListingCaptureBrowserContextOptions(surface: AppS
     width: number;
     height: number;
 }): BrowserContextOptions;
+export declare function assertExportedListingAudio(value: unknown): ExportedListingAudio;
 export declare function computeRecordedCrop(measurement: HostedGameMeasurement, recorder: ListingRecorderMetadata, rawWidth: number, rawHeight: number): CropRect;
 export declare function runListingRecorder(recorderPath: string, pid: number, durationSeconds: number, rawOutputPath: string, metadataPath: string, audio: boolean, deadlineAt: number): Promise<ListingRecorderMetadata>;
+export declare function captureCommandMatchesExceptPoster(capture: ListingCaptureSurfaceReport, surface: AppSurface, parsedOptions: ParsedCaptureListingOptions): boolean;
+export declare function resolveCurrentCaptureReuseAction(captures: ListingCaptureSurfaceReport[], surfaces: AppSurface[], parsedOptions: ParsedCaptureListingOptions): 'reuse' | 'refresh_poster';
 export declare function captureListing(targetArg: string | undefined, options?: CaptureListingOptions): Promise<void>;
 export {};

package/dist/commands/captureListing.js

@@ -39,13 +39,18 @@ exports.resolveListingCaptureLocalDevPort = resolveListingCaptureLocalDevPort;
 exports.buildListingCaptureFrameUrl = buildListingCaptureFrameUrl;
 exports.resolveListingCaptureSceneId = resolveListingCaptureSceneId;
 exports.parseCaptureListingOptions = parseCaptureListingOptions;
+exports.resolveCaptureListingExplicitOutputDir = resolveCaptureListingExplicitOutputDir;
 exports.assertSupportedListingEnvironment = assertSupportedListingEnvironment;
 exports.resolveListingRecorderPath = resolveListingRecorderPath;
 exports.buildSurfaceOutputPaths = buildSurfaceOutputPaths;
+exports.resolveWorkerCaptureOutputDir = resolveWorkerCaptureOutputDir;
 exports.resolveCaptureDimensions = resolveCaptureDimensions;
 exports.resolveListingCaptureBrowserContextOptions = resolveListingCaptureBrowserContextOptions;
+exports.assertExportedListingAudio = assertExportedListingAudio;
 exports.computeRecordedCrop = computeRecordedCrop;
 exports.runListingRecorder = runListingRecorder;
+exports.captureCommandMatchesExceptPoster = captureCommandMatchesExceptPoster;
+exports.resolveCurrentCaptureReuseAction = resolveCurrentCaptureReuseAction;
 exports.captureListing = captureListing;
 const types_1 = require("@playdrop/types");
 const node_child_process_1 = require("node:child_process");
@@ -53,10 +58,12 @@ const node_crypto_1 = require("node:crypto");
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
 const appUrls_1 = require("../appUrls");
+const build_1 = require("../apps/build");
 const catalogue_1 = require("../catalogue");
 const catalogue_utils_1 = require("../catalogue-utils");
 const commandContext_1 = require("../commandContext");
 const http_1 = require("../http");
+const listingPreflight_1 = require("../listingPreflight");
 const messages_1 = require("../messages");
 const playwright_1 = require("../playwright");
 const recorderRelease_1 = require("../recorderRelease");
@@ -66,6 +73,7 @@ const devRuntimeAssets_1 = require("./devRuntimeAssets");
 const devServer_1 = require("./devServer");
 const devShared_1 = require("./devShared");
 const taskCaptureSession_1 = require("./taskCaptureSession");
+const workerAppProject_1 = require("../workerAppProject");
 const CAPTURE_FRAME_SELECTOR = 'iframe[title="Game"]';
 const DEFAULT_DURATION_SECONDS = 8;
 const DEFAULT_WIDTH = 1280;
@@ -158,7 +166,8 @@ function parseCaptureListingOptions(targetArg, options = {}) {
         minimum: 0,
         maximum: durationSeconds,
     });
-    const outputDir = options.outputDir?.trim() ? (0, node_path_1.resolve)(process.cwd(), options.outputDir.trim()) : null;
+    const outputDirInput = options.outputDir?.trim() || null;
+    const outputDir = outputDirInput ? (0, node_path_1.resolve)(process.cwd(), outputDirInput) : null;
     return {
         targetArg,
         appName: options.app?.trim() || undefined,
@@ -169,10 +178,18 @@ function parseCaptureListingOptions(targetArg, options = {}) {
         posterAtSeconds,
         audio: Boolean(options.audio),
         outputDir,
+        outputDirInput,
         keepRaw: Boolean(options.keepRaw),
         explicitDimensions,
     };
 }
+function resolveCaptureListingExplicitOutputDir(outputDirInput, cwdResolvedOutputDir, projectDir) {
+    if (!outputDirInput || !cwdResolvedOutputDir)
+        return null;
+    return (0, node_path_1.isAbsolute)(outputDirInput)
+        ? cwdResolvedOutputDir
+        : (0, node_path_1.resolve)(projectDir, outputDirInput);
+}
 function readMacOsVersion() {
     const result = (0, node_child_process_1.spawnSync)('sw_vers', ['-productVersion'], {
         encoding: 'utf8',
@@ -231,6 +248,11 @@ function buildSurfaceOutputPaths(outputDir, surface, useSurfacePrefix) {
         finalVideoPath: (0, node_path_1.join)(outputDir, `${prefix}listing.mp4`),
     };
 }
+function resolveWorkerCaptureOutputDir(projectDir, isWorkerGameTask) {
+    return isWorkerGameTask
+        ? (0, node_path_1.join)(projectDir, 'assets', 'marketing', 'playdrop', 'capture')
+        : null;
+}
 function resolveCaptureDimensions(surface, parsedOptions) {
     if (parsedOptions.explicitDimensions) {
         return {
@@ -432,6 +454,21 @@ async function startHostedListingAudioCapture(page) {
         await hook.startAudioCapture();
     });
 }
+function assertExportedListingAudio(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('listing_audio_capture_export_missing');
+    }
+    const mimeType = typeof value.mimeType === 'string'
+        ? value.mimeType.trim()
+        : '';
+    const base64 = typeof value.base64 === 'string'
+        ? value.base64.trim()
+        : '';
+    if (!mimeType || !base64) {
+        throw new Error('listing_audio_capture_export_missing');
+    }
+    return { mimeType, base64 };
+}
 function resolveExportedAudioFileName(mimeType) {
     if (mimeType.includes('webm')) {
         return 'listing-audio.webm';
@@ -443,18 +480,23 @@ function resolveExportedAudioFileName(mimeType) {
 }
 async function stopHostedListingAudioCapture(page, outputDir) {
     const frame = await waitForHostedGameFrame(page, 20000);
-    const exportedAudio = await frame.evaluate(async () => {
+    const exportedAudio = assertExportedListingAudio(await frame.evaluate(async () => {
         const captureWindow = window;
         const hook = captureWindow.__listingCapture;
         if (!hook || typeof hook.stopAudioCapture !== 'function') {
             throw new Error('listing_audio_capture_hook_missing');
         }
         return hook.stopAudioCapture();
-    });
+    }));
     const filePath = (0, node_path_1.join)(outputDir, resolveExportedAudioFileName(exportedAudio.mimeType));
     await (0, promises_1.writeFile)(filePath, Buffer.from(exportedAudio.base64, 'base64'));
     return filePath;
 }
+async function assertHostedListingAudioCaptureContract(page, outputDir) {
+    await startHostedListingAudioCapture(page);
+    await page.waitForTimeout(300);
+    await stopHostedListingAudioCapture(page, outputDir);
+}
 async function fitWindowToRequestedGameplay(page, requestedWidth, requestedHeight) {
     const cdpSession = await page.context().newCDPSession(page);
     let measurement = await waitForHostedGameMeasurement(page, 15000);
@@ -666,6 +708,24 @@ function formatCommandError(error) {
             suggestions: ['Set previewable: true in catalogue.json, implement the preview scene and __listingCapture hooks, then rerun "playdrop project capture".'],
         };
     }
+    if (error.message === 'listing_audio_capture_export_missing') {
+        return {
+            message: 'The game preview audio hook did not export recorded audio.',
+            suggestions: ['Make window.__listingCapture.stopAudioCapture() resolve { mimeType, base64 }; toggling game audio on or off is not an export.'],
+        };
+    }
+    if (error.message === 'listing_capture_runtime_already_recorded') {
+        return {
+            message: 'This exact game runtime already has a canonical recording with different capture settings.',
+            suggestions: ['Use the existing video, or change and revalidate the preview implementation before recording the changed runtime once.'],
+        };
+    }
+    if (error.message === 'listing_capture_current_report_incomplete') {
+        return {
+            message: 'The canonical capture report is incomplete for this runtime.',
+            suggestions: ['Fix or remove the incomplete canonical capture directory, then record the runtime once.'],
+        };
+    }
     if (error.message.startsWith('listing_recorder_failed:')) {
         return {
             message: error.message.slice('listing_recorder_failed:'.length),
@@ -710,6 +770,77 @@ async function encodeListingVideo(rawVideoPath, finalVideoPath, posterPath, crop
         posterPath,
     ], 'ffmpeg_failed', deadlineAt);
 }
+function captureCommandMatchesExceptPoster(capture, surface, parsedOptions) {
+    const dimensions = resolveCaptureDimensions(surface, parsedOptions);
+    return capture.command.durationSeconds === parsedOptions.durationSeconds
+        && capture.command.width === dimensions.width
+        && capture.command.height === dimensions.height
+        && capture.command.fps === parsedOptions.fps
+        && capture.command.audio === parsedOptions.audio
+        && capture.command.keepRaw === parsedOptions.keepRaw;
+}
+function resolveCurrentCaptureReuseAction(captures, surfaces, parsedOptions) {
+    if (captures.length !== surfaces.length) {
+        throw new Error('listing_capture_current_report_incomplete');
+    }
+    const orderedCaptures = surfaces.map((surface) => captures.find((candidate) => candidate.surface === surface));
+    if (orderedCaptures.some((capture) => !capture)) {
+        throw new Error('listing_capture_current_report_incomplete');
+    }
+    if (orderedCaptures.some((capture, index) => !captureCommandMatchesExceptPoster(capture, surfaces[index], parsedOptions))) {
+        throw new Error('listing_capture_runtime_already_recorded');
+    }
+    return orderedCaptures.some((capture) => capture.command.posterAtSeconds !== parsedOptions.posterAtSeconds)
+        ? 'refresh_poster'
+        : 'reuse';
+}
+async function reuseCurrentListingCapture(input) {
+    let report;
+    try {
+        report = JSON.parse(await (0, promises_1.readFile)(input.outputPaths.reportPath, 'utf8'));
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT') {
+            return false;
+        }
+        throw new Error(`listing_capture_report_invalid:${input.outputPaths.reportPath}`);
+    }
+    if (report.appName !== input.appName) {
+        throw new Error(`listing_capture_report_app_mismatch:${report.appName}:${input.appName}`);
+    }
+    if (!input.runtimeBundleHash || report.binding?.runtimeBundleHash !== input.runtimeBundleHash) {
+        return false;
+    }
+    const action = resolveCurrentCaptureReuseAction(report.captures, input.surfaces, input.parsedOptions);
+    const captures = input.surfaces.map((surface) => report.captures.find((candidate) => candidate.surface === surface));
+    for (const capture of captures) {
+        await (0, promises_1.access)(capture.finalVideo.path);
+    }
+    if (action === 'reuse') {
+        console.log('[listing] The current runtime already has a matching canonical capture; reusing it.');
+        console.log(`[listing] Existing report: ${(0, node_path_1.relative)(process.cwd(), input.outputPaths.reportPath) || input.outputPaths.reportPath}`);
+        return true;
+    }
+    for (const capture of captures) {
+        runTool('ffmpeg', [
+            '-y',
+            '-ss',
+            String(input.parsedOptions.posterAtSeconds),
+            '-i',
+            capture.finalVideo.path,
+            '-frames:v',
+            '1',
+            capture.posterPath,
+        ], 'ffmpeg_failed', input.deadlineAt);
+        capture.command.posterAtSeconds = input.parsedOptions.posterAtSeconds;
+        const artifactKey = (0, node_path_1.relative)(input.outputPaths.outputDir, capture.posterPath) || 'poster.png';
+        report.binding.artifactHashes[artifactKey] = await computeFileSha256(capture.posterPath);
+    }
+    await (0, promises_1.writeFile)(input.outputPaths.reportPath, `${JSON.stringify(report, null, 2)}\n`, 'utf8');
+    console.log(`[listing] Refreshed the canonical poster at ${input.parsedOptions.posterAtSeconds}s without relaunching the game.`);
+    console.log(`[listing] Updated report: ${(0, node_path_1.relative)(process.cwd(), input.outputPaths.reportPath) || input.outputPaths.reportPath}`);
+    return true;
+}
 async function muxListingAudio(finalVideoPath, audioPath, deadlineAt) {
     const muxedVideoPath = `${finalVideoPath}.muxed.mp4`;
     runTool('ffmpeg', [
@@ -824,8 +955,20 @@ async function captureListing(targetArg, options = {}) {
         process.exitCode = 1;
         return;
     }
-    const outputPaths = await ensureOutputPaths(appName, parsedOptions.outputDir);
     const projectInfo = (0, devShared_1.findProjectInfo)(resolvedTarget.htmlPath);
+    const projectDir = projectInfo.projectDir ?? (0, node_path_1.dirname)(resolvedTarget.htmlPath);
+    let isWorkerGameTask = false;
+    try {
+        isWorkerGameTask = Boolean((0, listingPreflight_1.readWorkerUploadPreflightContext)(projectDir));
+    }
+    catch (error) {
+        const detail = formatCommandError(error instanceof Error ? error : new Error(String(error)));
+        (0, messages_1.printErrorWithHelp)(detail.message, detail.suggestions, { command: 'project capture' });
+        process.exitCode = 1;
+        return;
+    }
+    const explicitOutputDir = resolveCaptureListingExplicitOutputDir(parsedOptions.outputDirInput, parsedOptions.outputDir, projectDir);
+    const outputPaths = await ensureOutputPaths(appName, explicitOutputDir ?? resolveWorkerCaptureOutputDir(projectDir, isWorkerGameTask));
     const devScriptAvailable = Boolean(projectInfo.projectDir && projectInfo.packageJson && typeof projectInfo.packageJson.scripts?.dev === 'string');
     await (0, commandContext_1.withEnvironment)('project capture', 'Capturing game media', async ({ client, env, envConfig, account, workspaceAuth }) => {
         let currentUsername = '';
@@ -902,6 +1045,40 @@ async function captureListing(targetArg, options = {}) {
             process.exitCode = 1;
             return;
         }
+        let runtimeBundleHash = null;
+        if (taskLookup.task) {
+            try {
+                const captureTask = (0, listingPreflight_1.readWorkerUploadPreflightContext)(taskLookup.task.projectDir)
+                    ? (0, workerAppProject_1.prepareWorkerAppTask)(taskLookup.task)
+                    : taskLookup.task;
+                runtimeBundleHash = (await (0, build_1.buildApp)(captureTask)).bundleHash;
+            }
+            catch (error) {
+                (0, messages_1.printErrorWithHelp)(error instanceof Error ? error.message : String(error), ['Fix the game build before recording final gameplay.'], { command: 'project capture' });
+                process.exitCode = 1;
+                return;
+            }
+        }
+        const captureDeadlineAt = Date.now() + listingCaptureLease_1.LISTING_CAPTURE_MAX_DURATION_MS;
+        try {
+            const reused = await reuseCurrentListingCapture({
+                appName,
+                outputPaths,
+                parsedOptions,
+                runtimeBundleHash,
+                surfaces: resolvedTarget.surfaceTargets.list,
+                deadlineAt: captureDeadlineAt,
+            });
+            if (reused) {
+                return;
+            }
+        }
+        catch (error) {
+            const detail = formatCommandError(error instanceof Error ? error : new Error(String(error)));
+            (0, messages_1.printErrorWithHelp)(detail.message, detail.suggestions, { command: 'project capture' });
+            process.exitCode = 1;
+            return;
+        }
         const localDevAppUrl = (0, devServer_1.buildLocalDevAppUrl)({
             creatorUsername: currentUsername,
             appType: appTypeSlug,
@@ -926,7 +1103,6 @@ async function captureListing(targetArg, options = {}) {
                 return;
             }
         }
-        const captureDeadlineAt = Date.now() + listingCaptureLease_1.LISTING_CAPTURE_MAX_DURATION_MS;
         let serverAlreadyRunning = false;
         let devServerStartedByCapture = false;
         let serverHandle = null;
@@ -1020,6 +1196,8 @@ async function captureListing(targetArg, options = {}) {
                         await browserHandle.page.waitForTimeout(1000);
                     }
                     if (shouldExportPreviewAudio) {
+                        console.log('[listing] Checking the in-app preview audio export contract.');
+                        await assertHostedListingAudioCaptureContract(browserHandle.page, outputPaths.outputDir);
                         console.log('[listing] Starting in-app preview audio capture.');
                         await startHostedListingAudioCapture(browserHandle.page);
                     }
@@ -1126,6 +1304,7 @@ async function captureListing(targetArg, options = {}) {
                 binding: {
                     artifactHashes,
                     capturedSurfaces,
+                    runtimeBundleHash,
                 },
             };
             await (0, promises_1.writeFile)(outputPaths.reportPath, `${JSON.stringify(report, null, 2)}\n`, 'utf8');

package/dist/commands/upload.d.ts

@@ -1,5 +1,5 @@
 import type { ApiClient } from '@playdrop/api-client';
-import type { AgentExecutionTarget, UserResponse } from '@playdrop/types';
+import type { AgentExecutionTarget, AppSurface, UserResponse } from '@playdrop/types';
 import { type AppTask } from '../catalogue';
 export type UploadCommandOptions = {
     env?: string;
@@ -17,6 +17,9 @@ export type WorkerAppPublishInput = {
     kind: 'NEW_GAME' | 'REMIX_GAME' | 'GAME_UPDATE';
     executionTarget?: AgentExecutionTarget;
     expectedAppName?: string | null;
+    expectedDisplayName?: string | null;
+    expectedSubtitle?: string | null;
+    expectedPrimarySurface?: AppSurface | null;
     remixSourceRef?: string | null;
     playdropAssetRequirement?: WorkerPlaydropAssetRequirement | null;
     creatorRequest?: string | null;
@@ -69,6 +72,14 @@ export declare function assertWorkerAppLocalUploadPreflight(input: {
     creatorUsername?: string | null;
     playdropAssetRequirement?: WorkerPlaydropAssetRequirement | null;
     creatorRequest?: string | null;
+    stage?: 'PRE_CAPTURE' | 'COMPLETE';
+    expectedRuntimeBundleHash?: string;
 }): Promise<void>;
+export type WorkerAppPreflightResult = {
+    appName: string;
+    creatorUsername: string;
+    warnings: string[];
+};
+export declare function preflightWorkerAppProject(input: WorkerAppPublishInput): Promise<WorkerAppPreflightResult>;
 export declare function publishWorkerAppProject(input: WorkerAppPublishInput): Promise<WorkerAppPublishResult>;
 export declare function publishStaticHtmlProject(input: StaticHtmlPublishInput): Promise<StaticHtmlPublishResult>;