@playdrop/playdrop-cli 0.12.12 → 0.12.13

package/config/client-meta.json

@@ -1,6 +1,6 @@
 {
   "version": "0.12.8",
-  "build": 2,
+  "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/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/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/listingPreflight.d.ts

@@ -0,0 +1,16 @@
+import type { RecordAppUploadMediaCaptureRequest } from '@playdrop/types';
+import type { AppTask } from './catalogue';
+export type ListingMediaFile = {
+    fileKey: string;
+    sha256: string;
+};
+export declare function readMediaCaptureProof(input: {
+    task: AppTask;
+    preparedSessionFiles: ListingMediaFile[];
+}): RecordAppUploadMediaCaptureRequest;
+export declare function assertAgentGameHeroListingPreflight(task: AppTask): void;
+export declare function assertAgentGameScreenshotListingPreflight(task: AppTask): void;
+export declare function assertAgentGameListingPreflight(task: AppTask, options: {
+    requireCaptureReport: boolean;
+}): void;
+export declare function assertProjectListingPreflight(task: AppTask): void;