@playdrop/playdrop-cli 0.12.11 → 0.12.13

package/config/client-meta.json

@@ -1,6 +1,6 @@
 {
   "version": "0.12.8",
-  "build": 1,
+  "build": 5,
   "runtimeSdkVersion": "0.12.5",
   "runtimeSdkBuild": 2,
   "clients": {

package/dist/apps/upload.js

@@ -8,6 +8,7 @@ const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const http_1 = require("../http");
 const loadCheck_1 = require("./loadCheck");
+const listingPreflight_1 = require("../listingPreflight");
 const EXTENSION_TO_MIME = {
     '.png': 'image/png',
     '.jpg': 'image/jpeg',
@@ -74,89 +75,6 @@ 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 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 {
-        artifactHashes,
-        capturedSurfaces,
-    };
-}
 function resolveMimeType(filename, fallback = 'application/octet-stream') {
     const type = EXTENSION_TO_MIME[(0, node_path_1.extname)(filename).toLowerCase()];
     return type ?? fallback;
@@ -425,7 +343,7 @@ async function uploadAppVersion(client, task, artifacts, options) {
             if (options?.mediaCaptureRequired === true
                 && task.hostingMode !== 'EXTERNAL'
                 && !task.externalUrl) {
-                const mediaCaptureProof = readMediaCaptureProof({
+                const mediaCaptureProof = (0, listingPreflight_1.readMediaCaptureProof)({
                     task,
                     preparedSessionFiles,
                 });

package/dist/commands/create.d.ts

@@ -1,3 +1,8 @@
+export declare function resolveNpmInstallInvocation(platform?: NodeJS.Platform, nodeExecutable?: string): {
+    command: string;
+    args: string[];
+};
+export declare function runNpmInstall(projectDir: string): boolean;
 type CreateOptions = {
     template?: string;
     remix?: string;

package/dist/commands/create.js

@@ -3,6 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveNpmInstallInvocation = resolveNpmInstallInvocation;
+exports.runNpmInstall = runNpmInstall;
 exports.createAssetSpecProject = createAssetSpecProject;
 exports.create = create;
 const types_1 = require("@playdrop/types");
@@ -22,6 +24,7 @@ const messages_1 = require("../messages");
 const loadCheck_1 = require("../apps/loadCheck");
 const devShared_1 = require("./devShared");
 const init_1 = require("./init");
+const npmProcess_1 = require("./npmProcess");
 const taskCaptureSession_1 = require("./taskCaptureSession");
 const CATALOGUE_FILENAME = 'catalogue.json';
 const LEGACY_CATALOGUE_VERSION_KEY = ['schema', 'Version'].join('');
@@ -186,9 +189,12 @@ async function promptInstallDependencies(projectDir) {
     rl.close();
     return /^y(es)?$/i.test(answer.trim());
 }
+function resolveNpmInstallInvocation(platform = process.platform, nodeExecutable = process.execPath) {
+    return (0, npmProcess_1.resolveNpmInvocation)(['install'], platform, nodeExecutable);
+}
 function runNpmInstall(projectDir) {
-    const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-    const result = (0, node_child_process_1.spawnSync)(npmCommand, ['install'], {
+    const invocation = resolveNpmInstallInvocation();
+    const result = (0, node_child_process_1.spawnSync)(invocation.command, invocation.args, {
         cwd: projectDir,
         stdio: 'inherit',
     });

package/dist/commands/devServer.d.ts

@@ -34,6 +34,7 @@ export declare function buildLocalDevAppUrl(input: {
 }): string;
 export declare function terminateChildProcessTree(child: ChildProcess | null, timeoutMs?: number): Promise<void>;
 export declare function ensureDevRouterRunning(port?: number): Promise<void>;
+export declare function resolveDevRouterWorkingDirectory(cliEntrypoint: string): string;
 export declare function updateMountedDevRuntimeAssetManifest(input: {
     creatorUsername: string;
     appName: string;

package/dist/commands/devServer.js

@@ -8,6 +8,7 @@ exports.parseMountConflictError = parseMountConflictError;
 exports.buildLocalDevAppUrl = buildLocalDevAppUrl;
 exports.terminateChildProcessTree = terminateChildProcessTree;
 exports.ensureDevRouterRunning = ensureDevRouterRunning;
+exports.resolveDevRouterWorkingDirectory = resolveDevRouterWorkingDirectory;
 exports.updateMountedDevRuntimeAssetManifest = updateMountedDevRuntimeAssetManifest;
 exports.startDevServer = startDevServer;
 exports.isDevServerAvailable = isDevServerAvailable;
@@ -19,6 +20,7 @@ const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const node_http_1 = __importDefault(require("node:http"));
 const node_path_1 = require("node:path");
+const npmProcess_1 = require("./npmProcess");
 exports.DEV_ROUTER_PORT = 8888;
 const DEV_ROUTER_HOST = '127.0.0.1';
 const CONTROL_PREFIX = '/_playdrop';
@@ -248,8 +250,8 @@ function spawnDevScript(projectInfo) {
     if (!projectInfo.projectDir || !projectInfo.packageJson || typeof projectInfo.packageJson.scripts?.dev !== 'string') {
         return null;
     }
-    const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-    const child = (0, node_child_process_1.spawn)(npmCommand, ['run', 'dev'], {
+    const npm = (0, npmProcess_1.resolveNpmInvocation)(['run', 'dev']);
+    const child = (0, node_child_process_1.spawn)(npm.command, npm.args, {
         cwd: projectInfo.projectDir,
         stdio: 'inherit',
         env: { ...process.env },
@@ -341,25 +343,52 @@ async function waitForProcessGroupExit(pid, timeoutMs) {
     }
     return !isProcessGroupAlive(pid);
 }
+async function terminateWindowsProcessTree(pid, timeoutMs) {
+    const windowsRoot = process.env.SystemRoot?.trim() || process.env.WINDIR?.trim() || 'C:\\Windows';
+    const taskkillPath = (0, node_path_1.join)(windowsRoot, 'System32', 'taskkill.exe');
+    await new Promise((resolvePromise) => {
+        let settled = false;
+        const taskkill = (0, node_child_process_1.spawn)(taskkillPath, ['/PID', String(pid), '/T', '/F'], {
+            stdio: 'ignore',
+            windowsHide: true,
+        });
+        const settle = () => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timeout);
+            resolvePromise();
+        };
+        const timeout = setTimeout(() => {
+            taskkill.kill();
+            settle();
+        }, timeoutMs);
+        timeout.unref?.();
+        taskkill.once('error', settle);
+        taskkill.once('close', settle);
+    });
+}
 async function terminateChildProcessTree(child, timeoutMs = 2000) {
     const pid = child?.pid;
     if (!child || !pid || !isPidAlive(pid)) {
         return;
     }
-    const useGroup = process.platform !== 'win32';
-    signalProcess(pid, 'SIGTERM', useGroup);
-    const exited = useGroup
-        ? await waitForProcessGroupExit(pid, timeoutMs)
-        : await waitForChildExit(child, timeoutMs);
-    if (exited) {
+    if (process.platform === 'win32') {
+        await terminateWindowsProcessTree(pid, timeoutMs);
+        if (isPidAlive(pid)) {
+            signalProcess(pid, 'SIGKILL', false);
+            await waitForChildExit(child, timeoutMs);
+        }
         return;
     }
-    signalProcess(pid, 'SIGKILL', useGroup);
-    if (useGroup) {
-        await waitForProcessGroupExit(pid, timeoutMs);
+    signalProcess(pid, 'SIGTERM', true);
+    const exited = await waitForProcessGroupExit(pid, timeoutMs);
+    if (exited) {
         return;
     }
-    await waitForChildExit(child, timeoutMs);
+    signalProcess(pid, 'SIGKILL', true);
+    await waitForProcessGroupExit(pid, timeoutMs);
 }
 async function fetchRouterJson(path, init = {}, port = exports.DEV_ROUTER_PORT) {
     const response = await fetch(`http://${DEV_ROUTER_HOST}:${port}${path}`, init);
@@ -416,6 +445,7 @@ async function ensureDevRouterRunning(port = exports.DEV_ROUTER_PORT) {
     const childEnv = { ...process.env };
     delete childEnv.PLAYDROP_WORKER_CONTEXT;
     const child = (0, node_child_process_1.spawn)(process.execPath, [cliEntrypoint, 'project', '_dev-router', 'serve'], {
+        cwd: resolveDevRouterWorkingDirectory(cliEntrypoint),
         detached: true,
         stdio: 'ignore',
         env: {
@@ -434,6 +464,9 @@ async function ensureDevRouterRunning(port = exports.DEV_ROUTER_PORT) {
     }
     throw new Error('dev_router_start_failed');
 }
+function resolveDevRouterWorkingDirectory(cliEntrypoint) {
+    return (0, node_path_1.dirname)((0, node_path_1.resolve)(cliEntrypoint));
+}
 async function registerDevMount(input, port = exports.DEV_ROUTER_PORT) {
     const response = await fetch(`http://${DEV_ROUTER_HOST}:${port}${CONTROL_PREFIX}/mounts`, {
         method: 'POST',

package/dist/commands/login.d.ts

@@ -7,4 +7,5 @@ type LoginOptions = {
     handoffToken?: string;
     json?: boolean;
 };
+export declare function buildCliLoginTokenName(machineHostname?: string): string;
 export declare function login(env: string, options?: LoginOptions): Promise<void>;

package/dist/commands/login.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setOpenBrowserForTests = exports.resetOpenBrowserForTests = void 0;
+exports.buildCliLoginTokenName = buildCliLoginTokenName;
 exports.login = login;
 const types_1 = require("@playdrop/types");
+const node_os_1 = require("node:os");
 const config_1 = require("../config");
 const apiClient_1 = require("../apiClient");
 const http_1 = require("../http");
@@ -22,6 +24,13 @@ function extractAccessToken(data) {
 function isLoginResponse(data) {
     return typeof data === 'object' && data !== null && 'user' in data;
 }
+function buildCliLoginTokenName(machineHostname = (0, node_os_1.hostname)()) {
+    const normalizedHostname = machineHostname.trim();
+    if (!normalizedHostname) {
+        throw new Error('cli_login_hostname_missing');
+    }
+    return `CLI on ${normalizedHostname}`;
+}
 function storeLogin(env, data, options = {}) {
     const token = extractAccessToken(data);
     if (!token) {
@@ -53,11 +62,50 @@ function storeLogin(env, data, options = {}) {
     console.log(`Logged in as ${username} on ${env}.`);
     console.log('Next: run "playdrop auth whoami" to confirm your session.');
 }
+async function storeDeviceLogin(env, baseUrl, initialLogin, options = {}) {
+    const sessionToken = extractAccessToken(initialLogin);
+    const username = typeof initialLogin.user?.username === 'string'
+        ? initialLogin.user.username.trim()
+        : '';
+    if (!sessionToken) {
+        throw new Error('Login response is missing the session token required to create this computer token.');
+    }
+    if (!username) {
+        throw new Error('Login response is missing the username required to save this computer token.');
+    }
+    try {
+        const sessionClient = (0, apiClient_1.createCliApiClient)({ baseUrl, token: sessionToken });
+        const deviceToken = await sessionClient.createCliApiToken({
+            name: buildCliLoginTokenName(),
+        });
+        const deviceLogin = await (0, apiClient_1.createCliApiClient)({ baseUrl }).loginWithApiKey({
+            apiKey: deviceToken.apiKey,
+        });
+        storeLogin(env, deviceLogin, options);
+    }
+    catch (unknownError) {
+        if (unknownError instanceof types_1.UnsupportedClientError) {
+            (0, http_1.handleUnsupportedError)(unknownError, 'Login');
+            return;
+        }
+        if (unknownError instanceof types_1.ApiError) {
+            const tokenLimitReached = unknownError.code === 'cli_api_token_limit_reached';
+            (0, messages_1.printErrorWithHelp)(tokenLimitReached
+                ? 'Login succeeded, but this account already has the maximum of 25 CLI tokens.'
+                : `Login succeeded, but this computer's CLI token could not be created (status ${unknownError.status}).`, tokenLimitReached
+                ? ['Delete an unused CLI token in account settings, then rerun "playdrop auth login".']
+                : ['Rerun "playdrop auth login" to try again.'], { command: 'login' });
+            process.exitCode = 1;
+            return;
+        }
+        throw unknownError;
+    }
+}
 async function loginWithUsernamePassword(env, baseUrl, username, password, options = {}) {
     const client = (0, apiClient_1.createCliApiClient)({ baseUrl });
     try {
         const data = await client.login({ username, password });
-        storeLogin(env, data, options);
+        await storeDeviceLogin(env, baseUrl, data, options);
     }
     catch (unknownError) {
         if (unknownError instanceof types_1.UnsupportedClientError) {
@@ -101,7 +149,7 @@ async function loginWithHandoff(env, baseUrl, handoffToken, options = {}) {
     const client = (0, apiClient_1.createCliApiClient)({ baseUrl });
     try {
         const data = await client.exchangeAppleOAuthHandoff({ token: handoffToken });
-        storeLogin(env, data, options);
+        await storeDeviceLogin(env, baseUrl, data, options);
     }
     catch (unknownError) {
         if (unknownError instanceof types_1.UnsupportedClientError) {
@@ -163,7 +211,7 @@ async function loginInBrowser(env, baseUrl, options = {}) {
                 await sleep(intervalMs);
                 continue;
             }
-            storeLogin(env, result, options);
+            await storeDeviceLogin(env, baseUrl, result, options);
             return;
         }
         catch (unknownError) {

package/dist/commands/npmProcess.d.ts

@@ -0,0 +1,4 @@
+export declare function resolveNpmInvocation(args: string[], platform?: NodeJS.Platform, nodeExecutable?: string): {
+    command: string;
+    args: string[];
+};

package/dist/commands/npmProcess.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveNpmInvocation = resolveNpmInvocation;
+const node_path_1 = require("node:path");
+const node_process_1 = __importDefault(require("node:process"));
+function resolveNpmInvocation(args, platform = node_process_1.default.platform, nodeExecutable = node_process_1.default.execPath) {
+    if (platform === 'win32') {
+        return {
+            command: nodeExecutable,
+            args: [
+                node_path_1.win32.join(node_path_1.win32.dirname(nodeExecutable), 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+                ...args,
+            ],
+        };
+    }
+    return { command: 'npm', args };
+}

package/dist/commands/upload.js

@@ -51,6 +51,7 @@ const uploadLog_1 = require("../uploadLog");
 const upload_content_1 = require("./upload-content");
 const appUrls_1 = require("../appUrls");
 const devRuntimeAssets_1 = require("./devRuntimeAssets");
+const listingPreflight_1 = require("../listingPreflight");
 const upload_graph_1 = require("./upload-graph");
 function normalizeSavedItemKinds(kinds) {
     return [...new Set(Array.isArray(kinds) ? kinds : [])].sort();
@@ -847,6 +848,7 @@ function appendTaskRelations(graphState, fromNodeId, relations, contextLabel) {
     });
 }
 async function uploadAppTask(state, task, taskCreator, options) {
+    (0, listingPreflight_1.assertProjectListingPreflight)(task);
     const { upload, warnings } = await (0, apps_1.runAppPipeline)(state.client, task, {
         skipReview: options?.skipReview,
         clearTags: options?.clearTags,
@@ -1230,10 +1232,6 @@ const WORKER_SUPERVISOR_BUNDLE_EXCLUDES = [
     'assets/marketing/',
     'listing/',
 ];
-const MIN_HERO_PORTRAIT_WIDTH = 512;
-const MIN_HERO_PORTRAIT_HEIGHT = 768;
-const MIN_HERO_LANDSCAPE_WIDTH = 768;
-const MIN_HERO_LANDSCAPE_HEIGHT = 432;
 const OWNED_RUNTIME_IMAGE_CHECK_SIZE = 96;
 const OWNED_RUNTIME_IMAGE_GRID_CHECK_SIZE = 512;
 function appTaskSatisfiesPlaydropAssetRequirement(task, requirement) {
@@ -2024,118 +2022,6 @@ async function assertNewGameDeclaredAssetsAreUsedAtRuntime(input) {
         throw new Error('agent_task_game_asset_fallback_disallowed: new game tasks must fail clearly when declared gameplay assets cannot load instead of rendering placeholder or fallback visuals.');
     }
 }
-function readPngDimensions(filePath) {
-    const buffer = (0, node_fs_1.readFileSync)(filePath);
-    if (buffer.length < 24) {
-        throw new Error(`agent_task_listing_hero_art_invalid: ${filePath} is too small to be a valid PNG.`);
-    }
-    const isPng = (buffer[0] === 0x89
-        && buffer[1] === 0x50
-        && buffer[2] === 0x4e
-        && buffer[3] === 0x47
-        && buffer[4] === 0x0d
-        && buffer[5] === 0x0a
-        && buffer[6] === 0x1a
-        && buffer[7] === 0x0a);
-    if (!isPng || buffer.toString('ascii', 12, 16) !== 'IHDR') {
-        throw new Error(`agent_task_listing_hero_art_invalid: ${filePath} must be a PNG with an IHDR header.`);
-    }
-    const width = buffer.readUInt32BE(16);
-    const height = buffer.readUInt32BE(20);
-    if (!Number.isInteger(width) || !Number.isInteger(height) || width <= 0 || height <= 0) {
-        throw new Error(`agent_task_listing_hero_art_invalid: ${filePath} has invalid PNG dimensions.`);
-    }
-    return { width, height };
-}
-function readAgentTaskCatalogueApp(task) {
-    let data;
-    try {
-        data = JSON.parse((0, node_fs_1.readFileSync)(task.catalogueAbsolutePath, 'utf8'));
-    }
-    catch (error) {
-        const reason = error instanceof Error ? error.message : String(error);
-        throw new Error(`agent_task_catalogue_invalid_json: ${task.cataloguePath} must be valid JSON. ${reason}`);
-    }
-    const apps = Array.isArray(data?.apps) ? data.apps : [];
-    const app = apps.find((entry) => entry && typeof entry === 'object' && entry.name === task.name);
-    if (!app || typeof app !== 'object') {
-        throw new Error(`agent_task_catalogue_app_missing: ${task.cataloguePath} must contain apps[] entry "${task.name}".`);
-    }
-    return app;
-}
-function assertNewGameHeroListingKeys(task) {
-    const app = readAgentTaskCatalogueApp(task);
-    const listing = app.listing;
-    if (!listing || typeof listing !== 'object' || Array.isArray(listing)) {
-        return;
-    }
-    const hasLegacyPortrait = typeof listing.heroPortraitPath === 'string' && listing.heroPortraitPath.trim().length > 0;
-    const hasLegacyLandscape = typeof listing.heroLandscapePath === 'string' && listing.heroLandscapePath.trim().length > 0;
-    if (hasLegacyPortrait || hasLegacyLandscape) {
-        throw new Error('agent_task_listing_hero_art_legacy_keys: new game tasks must reference hero art through listing.heroPortrait and listing.heroLandscape, not listing.heroPortraitPath or listing.heroLandscapePath.');
-    }
-}
-function assertNewGameHeroListingPath(task, filePath, field) {
-    const relativePath = (0, node_path_1.relative)((0, node_path_1.resolve)(task.projectDir), (0, node_path_1.resolve)(filePath)).replace(/\\/g, '/');
-    if (relativePath === '' || relativePath === '..' || relativePath.startsWith('../') || relativePath.startsWith('/')) {
-        throw new Error(`agent_task_listing_hero_art_path_invalid: ${field} must point to a PNG inside the project under assets/marketing/playdrop/.`);
-    }
-    if (!relativePath.startsWith('assets/marketing/playdrop/') || (0, node_path_1.extname)(relativePath).toLowerCase() !== '.png') {
-        throw new Error(`agent_task_listing_hero_art_path_invalid: ${field} must point to a PNG under assets/marketing/playdrop/.`);
-    }
-}
-function assertNewGameHeroListingArt(task) {
-    const heroPortraitPath = task.listing?.heroPortraitPath;
-    const heroLandscapePath = task.listing?.heroLandscapePath;
-    if (!heroPortraitPath || !heroLandscapePath) {
-        throw new Error('agent_task_listing_hero_art_missing: new game tasks must include listing.heroPortrait and listing.heroLandscape PNG assets.');
-    }
-    assertNewGameHeroListingKeys(task);
-    assertNewGameHeroListingPath(task, heroPortraitPath, 'listing.heroPortrait');
-    assertNewGameHeroListingPath(task, heroLandscapePath, 'listing.heroLandscape');
-    const portrait = readPngDimensions(heroPortraitPath);
-    if (portrait.width < MIN_HERO_PORTRAIT_WIDTH || portrait.height < MIN_HERO_PORTRAIT_HEIGHT || portrait.height <= portrait.width) {
-        throw new Error(`agent_task_listing_hero_art_invalid: listing.heroPortrait must be a portrait PNG at least ${MIN_HERO_PORTRAIT_WIDTH}x${MIN_HERO_PORTRAIT_HEIGHT}.`);
-    }
-    const landscape = readPngDimensions(heroLandscapePath);
-    if (landscape.width < MIN_HERO_LANDSCAPE_WIDTH || landscape.height < MIN_HERO_LANDSCAPE_HEIGHT || landscape.width <= landscape.height) {
-        throw new Error(`agent_task_listing_hero_art_invalid: listing.heroLandscape must be a landscape PNG at least ${MIN_HERO_LANDSCAPE_WIDTH}x${MIN_HERO_LANDSCAPE_HEIGHT}.`);
-    }
-}
-function assertListingScreenshotPath(task, filePath, field) {
-    const relativePath = (0, node_path_1.relative)((0, node_path_1.resolve)(task.projectDir), (0, node_path_1.resolve)(filePath)).replace(/\\/g, '/');
-    const requiredPrefix = field === 'listing.screenshotsPortrait'
-        ? 'assets/marketing/playdrop/screenshots/portrait/'
-        : 'assets/marketing/playdrop/screenshots/landscape/';
-    if (relativePath === '' || relativePath === '..' || relativePath.startsWith('../') || relativePath.startsWith('/')) {
-        throw new Error(`agent_task_listing_screenshots_path_invalid: ${field} entries must point to PNG files inside the project under ${requiredPrefix}.`);
-    }
-    if (!relativePath.startsWith(requiredPrefix) || (0, node_path_1.extname)(relativePath).toLowerCase() !== '.png') {
-        throw new Error(`agent_task_listing_screenshots_path_invalid: ${field} entries must point to PNG files under ${requiredPrefix}.`);
-    }
-}
-function assertNewGameListingScreenshots(task) {
-    const listing = task.listing;
-    const portraitPaths = listing?.screenshotPortraitPaths ?? [];
-    const landscapePaths = listing?.screenshotLandscapePaths ?? [];
-    if (portraitPaths.length === 0 && landscapePaths.length === 0) {
-        throw new Error('agent_task_listing_screenshots_missing: new game tasks must include listing.screenshotsPortrait and/or listing.screenshotsLandscape PNG captures.');
-    }
-    if (task.surfaceTargets.includes('MOBILE_PORTRAIT') && portraitPaths.length === 0) {
-        throw new Error('agent_task_listing_screenshots_missing: mobile portrait games must include at least one listing.screenshotsPortrait PNG capture.');
-    }
-    if ((task.surfaceTargets.includes('DESKTOP') || task.surfaceTargets.includes('MOBILE_LANDSCAPE')) && landscapePaths.length === 0) {
-        throw new Error('agent_task_listing_screenshots_missing: desktop or landscape games must include at least one listing.screenshotsLandscape PNG capture.');
-    }
-    for (const filePath of portraitPaths) {
-        assertListingScreenshotPath(task, filePath, 'listing.screenshotsPortrait');
-        readPngDimensions(filePath);
-    }
-    for (const filePath of landscapePaths) {
-        assertListingScreenshotPath(task, filePath, 'listing.screenshotsLandscape');
-        readPngDimensions(filePath);
-    }
-}
 function readPlaytestEvidenceManifest(task) {
     const manifestPath = (0, node_path_1.join)(task.projectDir, 'playtest-evidence.json');
     if (!(0, node_fs_1.existsSync)(manifestPath)) {
@@ -2297,7 +2183,7 @@ async function publishWorkerAppProject(input) {
         assertTaskPlaytestEvidenceManifest(task);
     }
     if (input.kind === 'NEW_GAME' || input.kind === 'REMIX_GAME') {
-        assertNewGameHeroListingArt(task);
+        (0, listingPreflight_1.assertAgentGameHeroListingPreflight)(task);
     }
     if (!appTaskSatisfiesPlaydropAssetRequirement(task, input.playdropAssetRequirement)) {
         throw new Error('agent_task_playdrop_asset_dependency_missing: the creator asked for PlayDrop assets, but catalogue.json does not declare a matching uses.assets, uses.packs, or ownedAssets dependency.');
@@ -2346,7 +2232,7 @@ async function publishWorkerAppProject(input) {
         taskToken,
     };
     if (input.kind === 'NEW_GAME' || input.kind === 'REMIX_GAME') {
-        assertNewGameListingScreenshots(task);
+        (0, listingPreflight_1.assertAgentGameScreenshotListingPreflight)(task);
         assertTaskPlaytestEvidenceManifest(task);
     }
     const { upload: uploadResult, warnings } = await (0, apps_1.runAppPipeline)(input.client, task, {

package/dist/commands/validate.js

@@ -9,6 +9,7 @@ const externalAssetPackValidation_1 = require("../externalAssetPackValidation");
 const taskSelection_1 = require("../taskSelection");
 const taskUtils_1 = require("../taskUtils");
 const uploadLog_1 = require("../uploadLog");
+const listingPreflight_1 = require("../listingPreflight");
 const upload_content_1 = require("./upload-content");
 function buildLocalAssetSpecLookups(tasks) {
     const exactByRef = new Map();
@@ -191,6 +192,7 @@ async function validate(pathOrName, options = {}) {
         const entityId = task.name;
         try {
             if (task.kind === 'app') {
+                (0, listingPreflight_1.assertProjectListingPreflight)(task);
                 await (0, apps_1.validateAppTask)(task);
                 (0, apps_1.collectAppValidationWarnings)(task, 'source').forEach((warning) => warnings.add(warning));
             }

package/dist/commands/worker.d.ts

@@ -266,6 +266,7 @@ export declare function createLocalPlaydropShim(input: {
 export declare function parseCodexModelCatalog(output: string): string[];
 export declare function parseClaudeModelCatalog(output: string): string[];
 export declare function claudeModelProbeReportsSelection(output: string, expectedDisplayName: string): boolean;
+export declare function probeWorkerProviderIndependently<T>(probe: () => T, unavailable: T): T;
 export declare function buildWorkerSetupActions(input: {
     degradedReasons: string[];
     playwright?: {
@@ -301,6 +302,7 @@ export declare function resolveWorkerSupervisorLockFile(input?: {
     workerHomeDirectory?: string;
 }): string;
 export declare function parseLinuxProcessStartIdentity(stat: string): string | null;
+export declare function parseWindowsProcessStartIdentity(output: string): string | null;
 export declare function removeStaleWorkerSupervisorLockIfUnchanged(file: string, observedHolder: WorkerSupervisorLockOwner): boolean;
 export declare function acquireWorkerSupervisorLock(input: {
     supervisorType: WorkerSupervisorType;