@playdrop/playdrop-cli 0.11.9 → 0.12.1

package/dist/commands/check.d.ts

@@ -0,0 +1,8 @@
+type ProjectCheckOptions = {
+    app?: string;
+    timeout?: string | number;
+    screenshot?: string;
+    actions?: string;
+};
+export declare function check(targetArg: string | undefined, options?: ProjectCheckOptions): Promise<void>;
+export {};

package/dist/commands/check.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.check = check;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const types_1 = require("@playdrop/types");
+const commandContext_1 = require("../commandContext");
+const catalogue_1 = require("../catalogue");
+const catalogue_utils_1 = require("../catalogue-utils");
+const http_1 = require("../http");
+const messages_1 = require("../messages");
+const loadCheck_1 = require("../apps/loadCheck");
+const devShared_1 = require("./devShared");
+function resolveProjectCheckTarget(targetArg, appOption) {
+    try {
+        return (0, devShared_1.resolveDevTarget)(targetArg, appOption);
+    }
+    catch (error) {
+        const code = error?.code;
+        const message = error?.message || 'Unable to resolve project check target.';
+        const suggestions = code === 'app_required'
+            ? ['Use "--app <name>" to choose which app to check.']
+            : code === 'catalogue_missing'
+                ? ['Run the command inside a Playdrop workspace with catalogue.json.']
+                : ['Provide a valid catalogue-backed app target.'];
+        (0, messages_1.printErrorWithHelp)(message, suggestions, { command: 'project check' });
+        process.exitCode = 1;
+        return null;
+    }
+}
+function parseProjectCheckTimeoutMs(value) {
+    if (value === undefined || value === null || value === '') {
+        return 15000;
+    }
+    const numeric = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(numeric) || numeric <= 0) {
+        throw new Error('Timeout must be a positive number of seconds.');
+    }
+    if (numeric > 600) {
+        throw new Error('Timeout cannot exceed 600 seconds.');
+    }
+    return Math.round(numeric * 1000);
+}
+function readProjectCheckActions(actionsPath) {
+    const normalizedPath = actionsPath?.trim() ?? '';
+    if (!normalizedPath) {
+        return [];
+    }
+    const raw = (0, node_fs_1.readFileSync)(normalizedPath, 'utf8');
+    return (0, loadCheck_1.normalizeProjectCheckActions)(JSON.parse(raw));
+}
+function defaultProjectCheckScreenshotPath(appName) {
+    return (0, node_path_1.join)('assets', 'marketing', 'playdrop', 'check', `${appName}.png`);
+}
+async function check(targetArg, options = {}) {
+    let timeoutMs;
+    let actions;
+    try {
+        timeoutMs = parseProjectCheckTimeoutMs(options.timeout);
+        actions = readProjectCheckActions(options.actions);
+    }
+    catch (error) {
+        (0, messages_1.printErrorWithHelp)(error?.message || 'Invalid project check options.', ['Use --actions with a JSON array of click, press, and wait actions.'], { command: 'project check' });
+        process.exitCode = 1;
+        return;
+    }
+    const resolvedTarget = resolveProjectCheckTarget(targetArg, options.app);
+    if (!resolvedTarget) {
+        return;
+    }
+    const filePath = resolvedTarget.htmlPath;
+    if (!(0, node_fs_1.existsSync)(filePath) || !(0, node_fs_1.statSync)(filePath).isFile()) {
+        (0, messages_1.printErrorWithHelp)(`App HTML was not found at ${filePath}.`, ['Run the app build first or fix the catalogue file path.'], { command: 'project check' });
+        process.exitCode = 1;
+        return;
+    }
+    const taskLookup = (0, catalogue_1.findAppTaskByFile)(filePath);
+    if (taskLookup.errors.length > 0) {
+        (0, messages_1.printErrorWithHelp)(taskLookup.errors[0] || 'Failed to resolve the app task from catalogue.json.', taskLookup.errors.slice(1), { command: 'project check' });
+        process.exitCode = 1;
+        return;
+    }
+    if (!taskLookup.task) {
+        (0, messages_1.printErrorWithHelp)('project check requires a catalogue-backed app target.', ['Add this app to catalogue.json, then rerun "playdrop project check".'], { command: 'project check' });
+        process.exitCode = 1;
+        return;
+    }
+    let appName = resolvedTarget.appName;
+    try {
+        const match = (0, catalogue_utils_1.findAppDefinition)(filePath);
+        appName = match.name;
+    }
+    catch (error) {
+        if (resolvedTarget.cataloguePath) {
+            (0, messages_1.printErrorWithHelp)(error?.message || 'Catalogue lookup failed.', ['Ensure the HTML file is listed exactly once in catalogue.json with a valid type.'], { command: 'project check' });
+            process.exitCode = 1;
+            return;
+        }
+    }
+    const screenshotPath = options.screenshot?.trim() || defaultProjectCheckScreenshotPath(appName);
+    const workspacePath = resolvedTarget.cataloguePath ?? (0, node_path_1.dirname)(filePath);
+    await (0, commandContext_1.withEnvironment)('project check', 'Checking the Playdrop hosted game shell', async ({ client, env, envConfig, account, token }) => {
+        let currentUsername = account?.username?.trim() ?? '';
+        if (!currentUsername) {
+            try {
+                currentUsername = await (0, devShared_1.fetchDevUsername)(client);
+            }
+            catch (error) {
+                if (error instanceof http_1.CLIUnsupportedClientError) {
+                    return;
+                }
+                if (error instanceof types_1.UnsupportedClientError) {
+                    (0, http_1.handleUnsupportedError)(error, 'Authentication');
+                    process.exitCode = 1;
+                    return;
+                }
+                if (error instanceof types_1.ApiError) {
+                    (0, messages_1.printErrorWithHelp)(`Could not fetch your account (status ${error.status}).`, ['Run "playdrop auth login" to refresh your session.'], { command: 'project check' });
+                    process.exitCode = 1;
+                    return;
+                }
+                if ((0, devShared_1.isNetworkError)(error)) {
+                    (0, messages_1.printNetworkIssue)('Could not reach the Playdrop API to resolve your account.', 'project check');
+                    process.exitCode = 1;
+                    return;
+                }
+                throw error;
+            }
+        }
+        try {
+            await (0, devShared_1.assertAppRegistered)(client, currentUsername, appName);
+        }
+        catch (error) {
+            if (error instanceof http_1.CLIUnsupportedClientError) {
+                return;
+            }
+            if (error instanceof types_1.UnsupportedClientError) {
+                (0, http_1.handleUnsupportedError)(error, 'Project check');
+                process.exitCode = 1;
+                return;
+            }
+            if (error instanceof types_1.ApiError && error.status === 404) {
+                (0, messages_1.printErrorWithHelp)(`App ${currentUsername}/${appName} is not registered on ${env}.`, [`Run "playdrop project create app ${appName}" before using project check.`], { command: 'project check' });
+                process.exitCode = 1;
+                return;
+            }
+            if ((0, devShared_1.isNetworkError)(error)) {
+                (0, messages_1.printNetworkIssue)('Could not reach the Playdrop API to verify the app registration.', 'project check');
+                process.exitCode = 1;
+                return;
+            }
+            throw error;
+        }
+        const projectInfo = (0, devShared_1.findProjectInfo)(filePath);
+        const devScriptAvailable = Boolean(projectInfo.projectDir
+            && projectInfo.packageJson
+            && typeof projectInfo.packageJson.scripts?.dev === 'string');
+        const entryLabel = (0, node_path_1.relative)(process.cwd(), filePath) || filePath;
+        console.log(`[check] Preparing ${entryLabel}.`);
+        if (projectInfo.projectDir && !devScriptAvailable && projectInfo.packageJsonPath) {
+            const projectLabel = (0, devShared_1.formatProjectLabel)(projectInfo);
+            if (projectLabel) {
+                console.log(`[check] package.json detected at ${projectLabel}, but no "dev" script was found. Run your app build manually if needed.`);
+            }
+        }
+        const result = await (0, loadCheck_1.runLocalHostedLoadCheck)({
+            client,
+            apiBase: envConfig.apiBase,
+            webBase: envConfig.webBase,
+            creatorUsername: currentUsername,
+            task: taskLookup.task,
+            timeoutMs,
+            token,
+            currentUser: null,
+            screenshotPath,
+            actions,
+        });
+        if (result.status !== 'PASSED') {
+            (0, messages_1.printErrorWithHelp)((0, loadCheck_1.formatHostedLoadCheckFailure)(appName, result, 'local'), result.screenshotPath ? [`Screenshot: ${result.screenshotPath}`] : [], { command: 'project check' });
+            process.exitCode = 1;
+            return;
+        }
+        console.log(`[check] Passed ${currentUsername}/${appName}.`);
+        if (result.webglRenderer) {
+            console.log(`[check] Hardware renderer: ${result.webglRenderer}`);
+        }
+    }, { workspacePath });
+}

package/dist/commands/review.d.ts

@@ -33,6 +33,26 @@ export type ReviewRatingCardOptions = {
     punchline?: string;
     title?: string;
 };
+export type ReviewListWindowsOptions = {
+    pid: string;
+};
+export type ReviewScreenshotOptions = {
+    metadata?: string;
+    out: string;
+    pid: string;
+    windowId?: string;
+};
+export declare function buildReviewListWindowsRecorderArgs(options: ReviewListWindowsOptions): string[];
+export declare function buildReviewScreenshotRecorderArgs(options: ReviewScreenshotOptions): {
+    args: string[];
+    metadataPath: string;
+    outputPath: string;
+};
+export declare function listReviewCaptureWindows(options: ReviewListWindowsOptions): Promise<void>;
+export declare function captureReviewScreenshot(options: ReviewScreenshotOptions): Promise<{
+    metadataPath: string;
+    outputPath: string;
+}>;
 export declare function validateGameReviewResult(input: ValidateGameReviewResultInput): Promise<ReviewValidationResult>;
 export declare function validateReviewResultCommand(options: ReviewValidateResultOptions): Promise<void>;
 export declare function composeReviewEvidence(options: ReviewComposeEvidenceOptions): Promise<{

package/dist/commands/review.js

@@ -4,14 +4,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.REQUIRED_REVIEW_EVIDENCE_FILES = exports.REVIEW_CRITERIA = void 0;
+exports.buildReviewListWindowsRecorderArgs = buildReviewListWindowsRecorderArgs;
+exports.buildReviewScreenshotRecorderArgs = buildReviewScreenshotRecorderArgs;
+exports.listReviewCaptureWindows = listReviewCaptureWindows;
+exports.captureReviewScreenshot = captureReviewScreenshot;
 exports.validateGameReviewResult = validateGameReviewResult;
 exports.validateReviewResultCommand = validateReviewResultCommand;
 exports.composeReviewEvidence = composeReviewEvidence;
 exports.createReviewRatingCard = createReviewRatingCard;
 const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
 const sharp_1 = __importDefault(require("sharp"));
 const output_1 = require("../output");
+const captureListing_1 = require("./captureListing");
 exports.REVIEW_CRITERIA = [
     'Gameplay / Core Loop',
     'Depth / Replayability',
@@ -46,6 +52,7 @@ exports.REQUIRED_REVIEW_EVIDENCE_FILES = [
     'rating-card.png',
 ];
 const REVIEW_EVIDENCE_MAX_BYTES = 10 * 1024 * 1024;
+const REVIEW_RECORDER_TIMEOUT_MS = 15000;
 function resolveFilePath(filePath, code) {
     const normalized = typeof filePath === 'string' ? filePath.trim() : '';
     if (!normalized) {
@@ -167,6 +174,111 @@ async function assertPngFile(filePath) {
         }
     }
 }
+async function assertNonBlankPngFile(filePath) {
+    await assertPngFile(filePath);
+    const image = (0, sharp_1.default)(filePath);
+    const metadata = await image.metadata();
+    if (!metadata.width || !metadata.height) {
+        throw new Error(`review_screenshot_invalid_image:${filePath}`);
+    }
+    const stats = await image.stats();
+    const colorChannels = stats.channels.slice(0, 3);
+    const brightest = Math.max(...colorChannels.map((channel) => channel.max));
+    if (brightest <= 5) {
+        throw new Error(`review_screenshot_blank:${filePath}`);
+    }
+}
+function parsePositiveInteger(value, code) {
+    const normalized = typeof value === 'string' ? value.trim() : '';
+    const parsed = Number.parseInt(normalized, 10);
+    if (!Number.isSafeInteger(parsed) || parsed <= 0 || String(parsed) !== normalized) {
+        throw new Error(code);
+    }
+    return parsed;
+}
+function buildReviewListWindowsRecorderArgs(options) {
+    const pid = parsePositiveInteger(options.pid, 'invalid_review_window_pid');
+    return ['--list-windows', '--pid', String(pid)];
+}
+function buildReviewScreenshotRecorderArgs(options) {
+    const pid = parsePositiveInteger(options.pid, 'invalid_review_window_pid');
+    const outputPath = resolveFilePath(options.out, 'missing_out');
+    const metadataPath = options.metadata
+        ? resolveFilePath(options.metadata, 'invalid_review_screenshot_metadata')
+        : outputPath.replace(/\.png$/i, '') + '.metadata.json';
+    const args = [
+        '--pid',
+        String(pid),
+        '--screenshot',
+        outputPath,
+        '--metadata',
+        metadataPath,
+    ];
+    if (options.windowId !== undefined && options.windowId !== '') {
+        const windowId = parsePositiveInteger(options.windowId, 'invalid_review_window_id');
+        args.push('--window-id', String(windowId));
+    }
+    return { args, metadataPath, outputPath };
+}
+function runRecorder(args) {
+    return new Promise((resolve, reject) => {
+        const recorderPath = (0, captureListing_1.resolveListingRecorderPath)();
+        const child = (0, node_child_process_1.spawn)(recorderPath, args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            child.kill('SIGKILL');
+            reject(new Error(`review_recorder_timeout:${REVIEW_RECORDER_TIMEOUT_MS}`));
+        }, REVIEW_RECORDER_TIMEOUT_MS);
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on('error', (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            reject(new Error(`review_recorder_unavailable:${recorderPath}:${error.message}`));
+        });
+        child.on('close', (code) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            if (code === 0) {
+                resolve(stdout);
+                return;
+            }
+            const detail = (stderr || stdout || `exit ${code}`).trim();
+            reject(new Error(`review_recorder_failed:${detail}`));
+        });
+    });
+}
+async function listReviewCaptureWindows(options) {
+    const output = await runRecorder(buildReviewListWindowsRecorderArgs(options));
+    process.stdout.write(output);
+}
+async function captureReviewScreenshot(options) {
+    const { args, metadataPath, outputPath } = buildReviewScreenshotRecorderArgs(options);
+    await node_fs_1.promises.mkdir(node_path_1.default.dirname(outputPath), { recursive: true });
+    await node_fs_1.promises.mkdir(node_path_1.default.dirname(metadataPath), { recursive: true });
+    await runRecorder(args);
+    await assertNonBlankPngFile(outputPath);
+    (0, output_1.printSuccess)(`Review screenshot written to ${outputPath}`);
+    return { metadataPath, outputPath };
+}
 async function validateGameReviewResult(input) {
     const normalizedState = String(input.reviewState || '').trim().toUpperCase();
     if (!TERMINAL_REVIEW_STATES.has(normalizedState)) {

package/dist/commands/upload-content.d.ts

@@ -2,7 +2,7 @@ import type { ApiClient } from '@playdrop/api-client';
 import { type AssetPackUploadedLocalAsset } from '@playdrop/types';
 import type { AssetPackTask, AssetSpecTask, AssetTask, OwnedAssetTask, PackOwnedAssetTask } from '../catalogue';
 import type { CliTask } from '../taskUtils';
-export type CurrentUserRole = 'USER' | 'CREATOR' | 'ADMIN' | null;
+export type CurrentUserRole = 'CREATOR' | 'ADMIN' | null;
 export type UploadedAssetInfo = {
     creatorUsername: string;
     name: string;

package/dist/commands/upload.d.ts

@@ -1,5 +1,5 @@
 import type { ApiClient } from '@playdrop/api-client';
-import type { UserResponse } from '@playdrop/types';
+import type { AgentExecutionTarget, UserResponse } from '@playdrop/types';
 export type UploadCommandOptions = {
     env?: string;
     skipReview?: boolean;
@@ -10,6 +10,7 @@ export type WorkerAppPublishInput = {
     client: ApiClient;
     taskId: number;
     kind: 'NEW_GAME' | 'REMIX_GAME' | 'GAME_UPDATE';
+    executionTarget?: AgentExecutionTarget;
     expectedAppName?: string | null;
     remixSourceRef?: string | null;
     playdropAssetRequirement?: WorkerPlaydropAssetRequirement | null;

package/dist/commands/upload.js

@@ -50,7 +50,6 @@ const taskUtils_1 = require("../taskUtils");
 const uploadLog_1 = require("../uploadLog");
 const upload_content_1 = require("./upload-content");
 const appUrls_1 = require("../appUrls");
-const launchCheck_1 = require("../apps/launchCheck");
 const devRuntimeAssets_1 = require("./devRuntimeAssets");
 const upload_graph_1 = require("./upload-graph");
 function normalizeSavedItemKinds(kinds) {
@@ -856,8 +855,6 @@ async function uploadAppTask(state, task, taskCreator, options) {
         webBase: state.portalBase,
         token: state.token,
         user: state.currentUser,
-        runLocalLaunchCheck: true,
-        runStagedUploadLaunchCheck: true,
         ensureRegisteredAppShell: true,
     });
     if (!upload.versionCreated || !upload.version) {
@@ -2137,7 +2134,7 @@ function assertNewGameListingScreenshots(task) {
 function readPlaytestEvidenceManifest(task) {
     const manifestPath = (0, node_path_1.join)(task.projectDir, 'playtest-evidence.json');
     if (!(0, node_fs_1.existsSync)(manifestPath)) {
-        throw new Error(formatMissingPlaytestEvidenceManifestError('new game tasks must include playtest-evidence.json before upload.'));
+        throw new Error(formatMissingPlaytestEvidenceManifestError('task uploads must include playtest-evidence.json before upload.'));
     }
     try {
         const value = JSON.parse((0, node_fs_1.readFileSync)(manifestPath, 'utf8'));
@@ -2183,7 +2180,7 @@ function assertPlaytestCapturePaths(task, captures) {
         }
     }
 }
-function assertNewGamePlaytestEvidenceManifest(task) {
+function assertTaskPlaytestEvidenceManifest(task) {
     const manifest = readPlaytestEvidenceManifest(task);
     const entries = Array.isArray(manifest.entries) ? manifest.entries : [];
     if (entries.length === 0) {
@@ -2222,28 +2219,6 @@ function assertNewGamePlaytestEvidenceManifest(task) {
         throw new Error(formatPlaytestEvidenceManifestError(`playtest-evidence.json must include a non-final self-playtest checkedAt after the last source change${sourceLastModifiedAt ? ` (${sourceLastModifiedAt})` : ''}.`));
     }
 }
-function writeFinalPublishedRouteEvidence(input) {
-    const manifest = readPlaytestEvidenceManifest(input.task);
-    const entries = Array.isArray(manifest.entries) ? manifest.entries : [];
-    const finalEntry = {
-        environment: 'final',
-        url: input.url,
-        surface: 'DESKTOP',
-        captures: [],
-        actions: ['open owner draft play URL'],
-        statesObserved: input.status === 'PASSED' ? ['ready', 'nonblank-first-frame'] : [],
-        consoleErrors: input.message ? [input.message] : [],
-        checkedAt: input.checkedAt,
-        sourceLastModifiedAt: readRuntimeSourceLastModifiedAt(input.task.projectDir),
-    };
-    const nextManifest = {
-        ...manifest,
-        version: 1,
-        entries: [...entries, finalEntry],
-        finalPublishedRoute: finalEntry,
-    };
-    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(input.task.projectDir, 'playtest-evidence.json'), `${JSON.stringify(nextManifest, null, 2)}\n`, 'utf8');
-}
 function readRuntimeSourceLastModifiedAt(rootDir) {
     const root = (0, node_path_1.resolve)(rootDir);
     let latest = 0;
@@ -2313,6 +2288,9 @@ async function publishWorkerAppProject(input) {
             throw new Error(`agent_task_remix_ref_mismatch:${catalogueRemixRef}:${expectedRemixRef}`);
         }
     }
+    if (input.kind === 'GAME_UPDATE') {
+        assertTaskPlaytestEvidenceManifest(task);
+    }
     if (input.kind === 'NEW_GAME' || input.kind === 'REMIX_GAME') {
         assertNewGameHeroListingArt(task);
     }
@@ -2355,7 +2333,7 @@ async function publishWorkerAppProject(input) {
     }
     if (input.kind === 'NEW_GAME' || input.kind === 'REMIX_GAME') {
         assertNewGameListingScreenshots(task);
-        assertNewGamePlaytestEvidenceManifest(task);
+        assertTaskPlaytestEvidenceManifest(task);
     }
     const { upload: uploadResult, warnings } = await (0, apps_1.runAppPipeline)(input.client, task, {
         creatorUsername,
@@ -2363,10 +2341,11 @@ async function publishWorkerAppProject(input) {
         webBase: normalizePortalBase(input.webBase ?? undefined),
         token: input.token,
         user: input.user,
-        runLocalLaunchCheck: true,
-        runStagedUploadLaunchCheck: true,
+        runLocalLoadCheck: true,
+        runStagedUploadLoadCheck: true,
         ensureRegisteredAppShell: true,
         agentTaskId: input.taskId,
+        mediaCaptureRequired: input.executionTarget === 'FIRST_PARTY',
     });
     if (!uploadResult.versionCreated || !uploadResult.version) {
         throw new Error(`App "${task.name}" upload did not return a created version.`);
@@ -2377,28 +2356,6 @@ async function publishWorkerAppProject(input) {
     if (typeof uploadResult.versionNodeId !== 'string' || uploadResult.versionNodeId.trim().length === 0) {
         throw new Error(`App "${task.name}" upload did not return versionNodeId.`);
     }
-    const finalPlayUrl = (0, appUrls_1.buildPlatformPrivateDraftPlayUrl)(input.webBase ?? null, {
-        creatorUsername,
-        appName: task.name,
-        appType: task.type ?? 'GAME',
-        version: uploadResult.version,
-    });
-    const finalPlayCheck = await (0, launchCheck_1.runPublishedHostedPlayCheck)({
-        targetUrl: finalPlayUrl,
-        surfaceTargets: task.surfaceTargets,
-        token: input.token,
-        currentUser: input.user,
-    });
-    writeFinalPublishedRouteEvidence({
-        task,
-        url: finalPlayUrl,
-        checkedAt: finalPlayCheck.checkedAt,
-        status: finalPlayCheck.status,
-        message: finalPlayCheck.message,
-    });
-    if (finalPlayCheck.status !== 'PASSED') {
-        throw new Error((0, launchCheck_1.formatHostedLaunchCheckFailure)(task.name, finalPlayCheck, 'final'));
-    }
     return {
         appId: app.id,
         appVersionId: uploadResult.versionId,