@playdrop/playdrop-cli 0.12.26 → 0.12.28

package/config/client-meta.json

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

package/dist/apps/build.js

@@ -226,8 +226,41 @@ function appendIncludedProjectFile(rootDir, includePath, excludedRelativeFiles,
     results.push(record);
     fileByRelativePath.set(record.relativePath, record);
 }
+function appendIncludedProjectDirectory(rootDir, includeDirectory, excludedRelativeFiles, fileByRelativePath, results, enforceReservedBundleNames) {
+    const normalizedDirectory = (0, node_path_1.normalize)(includeDirectory).split(node_path_1.sep).join('/').replace(/\/+$/, '');
+    if (!normalizedDirectory || normalizedDirectory === '.' || normalizedDirectory.startsWith('..')) {
+        throw new Error(`[apps][build] Invalid include directory path "${includeDirectory}".`);
+    }
+    const absoluteDirectory = (0, node_path_1.resolve)(rootDir, normalizedDirectory);
+    if (!isPathWithinRoot(rootDir, absoluteDirectory)) {
+        throw new Error(`[apps][build] Included directory "${includeDirectory}" escapes the project root.`);
+    }
+    if (!(0, node_fs_1.existsSync)(absoluteDirectory) || !(0, node_fs_1.statSync)(absoluteDirectory).isDirectory()) {
+        return;
+    }
+    const stack = [absoluteDirectory];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        for (const entry of readProjectDirEntries(current)) {
+            const absolutePath = (0, node_path_1.join)(current, entry.name);
+            const relativePath = normalizeRelativePath(rootDir, absolutePath);
+            if (isExcludedRelativePath(entry.isDirectory() ? `${relativePath}/` : relativePath, excludedRelativeFiles)) {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                stack.push(absolutePath);
+                continue;
+            }
+            if (!entry.isFile()) {
+                continue;
+            }
+            appendIncludedProjectFile(rootDir, relativePath, excludedRelativeFiles, fileByRelativePath, results, enforceReservedBundleNames);
+        }
+    }
+}
 function collectProjectFiles(rootDir, rules, options) {
     const includeRelativeFiles = options?.includeRelativeFiles ?? [];
+    const includeRelativeDirectories = options?.includeRelativeDirectories ?? [];
     const excludeRelativeFiles = new Set(Array.from(options?.excludeRelativeFiles ?? [])
         .map((filePath) => (0, node_path_1.normalize)(filePath).split(node_path_1.sep).join('/'))
         .filter((filePath) => filePath.length > 0 && filePath !== '.'));
@@ -285,6 +318,9 @@ function collectProjectFiles(rootDir, rules, options) {
     for (const includePath of includeRelativeFiles) {
         appendIncludedProjectFile(rootDir, includePath, excludeRelativeFiles, fileByRelativePath, results, enforceReservedBundleNames);
     }
+    for (const includeDirectory of includeRelativeDirectories) {
+        appendIncludedProjectDirectory(rootDir, includeDirectory, excludeRelativeFiles, fileByRelativePath, results, enforceReservedBundleNames);
+    }
     results.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
     return results;
 }
@@ -496,6 +532,11 @@ function createZipArchive(entries) {
 function createSourceArchive(task) {
     const rules = buildIgnoreRules(task.projectDir);
     const includeFiles = ['README.md', 'AGENTS.md'];
+    for (const heroPath of [task.listing?.heroPortraitPath, task.listing?.heroLandscapePath]) {
+        if (heroPath) {
+            includeFiles.push(normalizeRelativePath(task.projectDir, heroPath));
+        }
+    }
     const excludedFiles = task.sourceArchiveExcludeRelativeFiles ?? [];
     if (task.catalogueAbsolutePath && (0, node_fs_1.existsSync)(task.catalogueAbsolutePath)) {
         const relativeCataloguePath = normalizeRelativePath(task.projectDir, task.catalogueAbsolutePath) || 'catalogue.json';
@@ -509,6 +550,7 @@ function createSourceArchive(task) {
         }
         const entries = collectProjectFiles(task.projectDir, rules, {
             includeRelativeFiles: includeFiles,
+            includeRelativeDirectories: ['assets/art-direction'],
             excludeRelativeFiles: excludedFiles,
         });
         const buffer = createZipArchive(entries);
@@ -519,6 +561,7 @@ function createSourceArchive(task) {
     }
     const entries = collectProjectFiles(task.projectDir, rules, {
         includeRelativeFiles: includeFiles,
+        includeRelativeDirectories: ['assets/art-direction'],
         excludeRelativeFiles: excludedFiles,
     });
     const buffer = createZipArchive(entries);

package/dist/apps/index.d.ts

@@ -1,5 +1,5 @@
 import type { ApiClient } from '@playdrop/api-client';
-import type { UserResponse } from '@playdrop/types';
+import type { AgentTaskPlaytestProof, UserResponse } from '@playdrop/types';
 import type { AppTask } from '../catalogue';
 import type { TaskCaptureSession } from '../appUrls';
 import { collectAppValidationWarnings, validateAppTask, runFormatScript } from './validate';
@@ -23,6 +23,7 @@ export type AppPipelineOptions = {
     loadCheckTimeoutMs?: number;
     ensureRegisteredAppShell?: boolean;
     agentTaskId?: number;
+    playtestProof?: AgentTaskPlaytestProof;
     mediaCaptureRequired?: boolean;
     captureSession?: TaskCaptureSession | null;
 };

package/dist/apps/index.js

@@ -64,6 +64,7 @@ async function runAppPipeline(client, task, options) {
         runStagedUploadLoadCheck: options?.runStagedUploadLoadCheck,
         loadCheckTimeoutMs: options?.loadCheckTimeoutMs,
         agentTaskId: options?.agentTaskId,
+        playtestProof: options?.playtestProof,
         mediaCaptureRequired: options?.mediaCaptureRequired,
         captureSession: options?.captureSession,
     };

package/dist/apps/upload.d.ts

@@ -1,5 +1,5 @@
 import type { ApiClient } from '@playdrop/api-client';
-import type { UserResponse } from '@playdrop/types';
+import type { AgentTaskPlaytestProof, UserResponse } from '@playdrop/types';
 import type { AppTask } from '../catalogue';
 import type { TaskCaptureSession } from '../appUrls';
 import type { AppBuildArtifacts } from './build';
@@ -21,6 +21,7 @@ export type AppUploadOptions = {
     runStagedUploadLoadCheck?: boolean;
     loadCheckTimeoutMs?: number;
     agentTaskId?: number;
+    playtestProof?: AgentTaskPlaytestProof;
     mediaCaptureRequired?: boolean;
     captureSession?: TaskCaptureSession | null;
 };

package/dist/apps/upload.js

@@ -232,6 +232,7 @@ async function uploadAppVersion(client, task, artifacts, options) {
     const initializeRequest = {
         version: task.version,
         agentTaskId: options?.agentTaskId,
+        playtestProof: options?.playtestProof,
         releaseNotes: task.releaseNotes,
         visibility: task.versionVisibility,
         setAsCurrent: task.versionVisibility === 'PRIVATE' ? false : undefined,

package/dist/commands/devRuntimeAssets.js

@@ -37,6 +37,7 @@ const CONTENT_TYPE_BY_EXTENSION = {
     '.png': 'image/png',
     '.jpg': 'image/jpeg',
     '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
     '.svg': 'image/svg+xml',
     '.webp': 'image/webp',
     '.glb': 'model/gltf-binary',
@@ -52,25 +53,6 @@ function inferContentType(filePath) {
     const extension = (0, node_path_1.extname)(filePath).toLowerCase();
     return CONTENT_TYPE_BY_EXTENSION[extension] ?? null;
 }
-function normalizeManifestFiles(fileManifest) {
-    const files = fileManifest && typeof fileManifest === 'object' && Array.isArray(fileManifest.files)
-        ? fileManifest.files
-        : [];
-    return files
-        .filter((entry) => Boolean(entry && typeof entry === 'object'))
-        .map((entry) => ({
-        role: typeof entry.role === 'string' ? entry.role.trim().toLowerCase() : '',
-        key: typeof entry.key === 'string' ? entry.key.trim() : '',
-        contentType: typeof entry.contentType === 'string' ? entry.contentType : null,
-        sizeBytes: typeof entry.sizeBytes === 'number' && Number.isFinite(entry.sizeBytes) ? entry.sizeBytes : null,
-        sha256: typeof entry.sha256 === 'string' ? entry.sha256 : null,
-    }))
-        .filter((entry) => entry.role.length > 0);
-}
-function buildPublishedAssetFileUrl(apiBase, creatorUsername, assetName, revision, role) {
-    const path = `/assets/${encodeURIComponent(creatorUsername)}/${encodeURIComponent(assetName)}/versions/${encodeURIComponent(`r${revision}`)}/file?role=${encodeURIComponent(role)}`;
-    return new URL(path, apiBase).toString();
-}
 function buildSyntheticLocalAssetRef(creatorUsername, appName, ownedAssetName) {
     return (0, types_1.formatContentVersionRef)({
         kind: 'asset',
@@ -87,86 +69,6 @@ function buildLocalDevRuntimeAssetFileUrl(appBaseUrl, ownedAssetName, role) {
     const base = appBaseUrl.endsWith('/') ? appBaseUrl.slice(0, -1) : appBaseUrl;
     return `${base}/_playdrop/runtime-assets/files/${encodeURIComponent(ownedAssetName)}?role=${encodeURIComponent(role)}`;
 }
-async function findAssetVersionByRevision(client, creatorUsername, assetName, revision) {
-    let offset = 0;
-    for (let page = 0; page < 200; page += 1) {
-        const response = await client.listAssetVersions(creatorUsername, assetName, {
-            limit: 100,
-            offset,
-        });
-        const version = (response.versions ?? []).find((entry) => entry.revision === revision);
-        if (version) {
-            return version;
-        }
-        if (!response.pagination?.hasMore) {
-            break;
-        }
-        offset += response.pagination.limit;
-    }
-    throw new Error(`dev_runtime_asset_version_not_found:${creatorUsername}/${assetName}@r${revision}`);
-}
-async function findPackVersion(client, creatorUsername, packName, versionString) {
-    let offset = 0;
-    for (let page = 0; page < 200; page += 1) {
-        const response = await client.listAssetPackVersions(creatorUsername, packName, {
-            limit: 100,
-            offset,
-        });
-        const version = (response.versions ?? []).find((entry) => entry.version === versionString);
-        if (version) {
-            return version;
-        }
-        if (!response.pagination?.hasMore) {
-            break;
-        }
-        offset += response.pagination.limit;
-    }
-    throw new Error(`dev_runtime_pack_version_not_found:${creatorUsername}/${packName}@${versionString}`);
-}
-function createPublishedAssetSummary(input) {
-    const files = normalizeManifestFiles(input.version.fileManifest).map((file) => ({
-        role: file.role,
-        url: buildPublishedAssetFileUrl(input.apiBase, input.creatorUsername, input.assetName, input.revision, file.role),
-        contentType: file.contentType ?? null,
-        sizeBytes: file.sizeBytes ?? null,
-        sha256: file.sha256 ?? null,
-    }));
-    if (files.length === 0) {
-        throw new Error(`dev_runtime_asset_files_missing:${input.creatorUsername}/${input.assetName}@r${input.revision}`);
-    }
-    return {
-        assetRef: (0, types_1.formatContentVersionRef)({
-            kind: 'asset',
-            creatorUsername: input.creatorUsername,
-            name: input.assetName,
-            revision: input.revision,
-        }),
-        runtimeKey: input.runtimeKey?.trim() || null,
-        sourceType: input.sourceType,
-        ...(input.sourcePackRef ? { sourcePackRef: input.sourcePackRef } : {}),
-        files,
-    };
-}
-async function resolvePublishedAssetSummary(client, apiBase, assetRef, options) {
-    const parsed = (0, types_1.parseContentVersionRef)(assetRef);
-    if (!parsed || parsed.kind !== 'asset') {
-        throw new Error(`dev_runtime_asset_ref_invalid:${assetRef}`);
-    }
-    const version = await findAssetVersionByRevision(client, parsed.creatorUsername, parsed.name, parsed.revision);
-    if (version.visibility !== 'PUBLIC') {
-        throw new Error(`dev_runtime_asset_not_public:${assetRef}`);
-    }
-    return createPublishedAssetSummary({
-        apiBase,
-        creatorUsername: parsed.creatorUsername,
-        assetName: parsed.name,
-        revision: parsed.revision,
-        version,
-        runtimeKey: options.runtimeKey,
-        sourceType: options.sourceType,
-        sourcePackRef: options.sourcePackRef,
-    });
-}
 function createLocalOwnedAssetSummary(task, creatorUsername, appBaseUrl, ownedAsset) {
     const files = {};
     const runtimeFiles = [];
@@ -260,41 +162,41 @@ async function buildDevRuntimeAssetManifest(input) {
         assets.push(localAsset.asset);
         ownedAssetFiles[ownedAsset.name] = localAsset.files;
     }
-    for (const dependency of input.task.uses.assets) {
+    const directDependencies = input.task.uses.assets.map((dependency) => {
         assertRuntimeKeyAvailable(seenRuntimeKeys, dependency.runtimeKey, dependency.ref);
         const parsedDependencyRef = (0, types_1.parseContentVersionRef)(dependency.ref);
         if (!parsedDependencyRef || parsedDependencyRef.kind !== 'asset') {
             throw new Error(`dev_runtime_asset_ref_invalid:${dependency.ref}`);
         }
-        const dependencyVersion = await findAssetVersionByRevision(input.client, parsedDependencyRef.creatorUsername, parsedDependencyRef.name, parsedDependencyRef.revision);
-        assertCustomAssetVersionSupported(input.task, dependency.ref, dependencyVersion);
-        assets.push(await resolvePublishedAssetSummary(input.client, input.apiBase, dependency.ref, {
-            runtimeKey: dependency.runtimeKey,
-            sourceType: 'DIRECT',
-        }));
-    }
-    for (const packRef of input.task.uses.packs) {
+        return {
+            ref: (0, types_1.formatContentVersionRef)(parsedDependencyRef),
+            runtimeKey: dependency.runtimeKey?.trim() || null,
+        };
+    });
+    const packDependencies = input.task.uses.packs.map((packRef) => {
         const parsedPackRef = (0, types_1.parseContentVersionRef)(packRef);
         if (!parsedPackRef || parsedPackRef.kind !== 'pack') {
             throw new Error(`dev_runtime_pack_ref_invalid:${packRef}`);
         }
-        const packVersion = await findPackVersion(input.client, parsedPackRef.creatorUsername, parsedPackRef.name, parsedPackRef.version);
-        if (packVersion.visibility !== 'PUBLIC') {
-            throw new Error(`dev_runtime_pack_not_public:${packRef}`);
-        }
-        for (const member of packVersion.assets) {
-            const memberRef = (0, types_1.formatContentVersionRef)({
-                kind: 'asset',
-                creatorUsername: member.creatorUsername,
-                name: member.name,
-                revision: member.revision,
+        return (0, types_1.formatContentVersionRef)(parsedPackRef);
+    });
+    if (directDependencies.length > 0 || packDependencies.length > 0) {
+        const resolved = await input.client.resolveRuntimeAssets({
+            assets: directDependencies,
+            packs: packDependencies,
+        });
+        for (const entry of resolved.assets) {
+            if (entry.sourceType !== 'DIRECT' && entry.sourceType !== 'PACK') {
+                throw new Error(`dev_runtime_asset_source_type_invalid:${entry.assetRef}:${entry.sourceType}`);
+            }
+            assertCustomAssetVersionSupported(input.task, entry.assetRef, entry);
+            assets.push({
+                assetRef: entry.assetRef,
+                runtimeKey: entry.runtimeKey,
+                sourceType: entry.sourceType,
+                ...(entry.sourcePackRef ? { sourcePackRef: entry.sourcePackRef } : {}),
+                files: entry.files,
             });
-            const memberVersion = await findAssetVersionByRevision(input.client, member.creatorUsername, member.name, member.revision);
-            assertCustomAssetVersionSupported(input.task, memberRef, memberVersion);
-            assets.push(await resolvePublishedAssetSummary(input.client, input.apiBase, memberRef, {
-                sourceType: 'PACK',
-                sourcePackRef: packRef,
-            }));
         }
     }
     return {

package/dist/commands/ownedRuntimeImageValidation.d.ts

@@ -0,0 +1,7 @@
+import type { AppTask } from '../catalogue';
+export declare function validateOwnedRuntimeImageFile(input: {
+    assetName: string;
+    filePath: string;
+    declaredFormat?: string;
+}): Promise<void>;
+export declare function assertOwnedRuntimeImagesAreValid(task: AppTask): Promise<void>;

package/dist/commands/ownedRuntimeImageValidation.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateOwnedRuntimeImageFile = validateOwnedRuntimeImageFile;
+exports.assertOwnedRuntimeImagesAreValid = assertOwnedRuntimeImagesAreValid;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const sharp_1 = __importDefault(require("sharp"));
+const IMAGE_BY_EXTENSION = {
+    '.png': { format: 'png', contentType: 'image/png' },
+    '.jpg': { format: 'jpeg', contentType: 'image/jpeg' },
+    '.jpeg': { format: 'jpeg', contentType: 'image/jpeg' },
+    '.webp': { format: 'webp', contentType: 'image/webp' },
+    '.gif': { format: 'gif', contentType: 'image/gif' },
+    '.svg': { format: 'svg', contentType: 'image/svg+xml' },
+};
+const SHARP_FORMAT_BY_DECLARED_FORMAT = {
+    PNG: 'png',
+    JPEG: 'jpeg',
+    WEBP: 'webp',
+    GIF: 'gif',
+};
+async function validateOwnedRuntimeImageFile(input) {
+    let stats;
+    try {
+        stats = (0, node_fs_1.statSync)(input.filePath);
+    }
+    catch {
+        throw new Error(`agent_task_owned_image_file_missing:${input.assetName}:${input.filePath}`);
+    }
+    if (!stats.isFile()) {
+        throw new Error(`agent_task_owned_image_file_missing:${input.assetName}:${input.filePath}`);
+    }
+    const extension = (0, node_path_1.extname)(input.filePath).toLowerCase();
+    const expected = IMAGE_BY_EXTENSION[extension];
+    if (!expected) {
+        throw new Error(`agent_task_owned_image_format_unsupported:${input.assetName}:${extension || 'missing_extension'}`);
+    }
+    let metadata;
+    try {
+        metadata = await (0, sharp_1.default)(input.filePath, { failOn: 'error' }).metadata();
+    }
+    catch {
+        throw new Error(`agent_task_owned_image_decode_failed:${input.assetName}:${input.filePath}`);
+    }
+    if (!Number.isInteger(metadata.width) || Number(metadata.width) <= 0
+        || !Number.isInteger(metadata.height) || Number(metadata.height) <= 0) {
+        throw new Error(`agent_task_owned_image_dimensions_invalid:${input.assetName}:${input.filePath}`);
+    }
+    if (metadata.format !== expected.format) {
+        throw new Error(`agent_task_owned_image_format_mismatch:${input.assetName}:extension=${extension}:contentType=${expected.contentType}:decoded=${metadata.format ?? 'unknown'}`);
+    }
+    const declaredFormat = input.declaredFormat?.trim().toUpperCase() ?? '';
+    const declaredSharpFormat = SHARP_FORMAT_BY_DECLARED_FORMAT[declaredFormat];
+    if (declaredSharpFormat && declaredSharpFormat !== metadata.format) {
+        throw new Error(`agent_task_owned_image_format_mismatch:${input.assetName}:declared=${declaredFormat}:decoded=${metadata.format}`);
+    }
+}
+async function assertOwnedRuntimeImagesAreValid(task) {
+    for (const ownedAsset of task.ownedAssets) {
+        if (!ownedAsset.runtimeKey || ownedAsset.category !== 'IMAGE') {
+            continue;
+        }
+        const primaryPath = ownedAsset.filePaths?.primary;
+        if (!primaryPath) {
+            throw new Error(`agent_task_owned_image_file_missing:${ownedAsset.name}:primary`);
+        }
+        await validateOwnedRuntimeImageFile({
+            assetName: ownedAsset.name,
+            filePath: primaryPath,
+            declaredFormat: ownedAsset.format,
+        });
+    }
+}

package/dist/commands/upload.d.ts

@@ -1,10 +1,13 @@
 import type { ApiClient } from '@playdrop/api-client';
-import type { AgentExecutionTarget, UserResponse } from '@playdrop/types';
+import type { AgentExecutionTarget, AgentTaskPlaytestProof, UserResponse } from '@playdrop/types';
+import { type AppTask } from '../catalogue';
 export type UploadCommandOptions = {
     env?: string;
     skipReview?: boolean;
     clearTags?: boolean;
 };
+export declare function resolveUploadOwner(actorUsername: string | null | undefined, workspaceOwnerUsername: string | null | undefined): string;
+export declare function resolveDefaultUploadCreator(owner: string | null | undefined, actorUsername: string | null | undefined): string;
 export declare function upload(pathOrName: string, options?: UploadCommandOptions): Promise<void>;
 export type WorkerAppPublishInput = {
     client: ApiClient;
@@ -33,4 +36,7 @@ export type WorkerAppPublishResult = {
     warnings: string[];
 };
 export type WorkerPlaydropAssetRequirement = 'PACK' | 'ASSET_OR_PACK';
+export declare function assertTaskPlaytestEvidenceManifest(task: AppTask, options?: {
+    requireOutcomeProof?: boolean;
+}): AgentTaskPlaytestProof | null;
 export declare function publishWorkerAppProject(input: WorkerAppPublishInput): Promise<WorkerAppPublishResult>;