@playdrop/playdrop-cli 0.12.27 → 0.12.29

package/config/client-meta.json

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

package/dist/catalogue.js

@@ -1279,9 +1279,7 @@ function buildAppTasks(rootDir, catalogues, options) {
             }
             let design;
             if (Object.prototype.hasOwnProperty.call(entry, 'design')) {
-                const parsedDesign = (0, types_1.normalizeAppVersionDesign)(entry.design, {
-                    allowedPackRefs: usesPacks,
-                });
+                const parsedDesign = (0, types_1.normalizeAppVersionDesign)(entry.design);
                 if (!parsedDesign.ok) {
                     errors.push(`[${label}] App "${rawName}" ${parsedDesign.error}`);
                     continue;

package/dist/commands/devRuntimeAssets.d.ts

@@ -26,7 +26,7 @@ export declare function createEmptyDevRuntimeAssetManifest(): DevRuntimeAssetMan
 export declare function buildLocalDevRuntimeAssetsUrl(appBaseUrl: string): string;
 export declare function buildLocalDevRuntimeAssetFileUrl(appBaseUrl: string, ownedAssetName: string, role: string): string;
 export declare function buildDevRuntimeAssetManifest(input: {
-    client: ApiClient;
+    client?: Pick<ApiClient, 'resolveRuntimeAssets'>;
     apiBase: string;
     task: AppTask;
     creatorUsername: string;

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,44 @@ 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}`);
+        return (0, types_1.formatContentVersionRef)(parsedPackRef);
+    });
+    if (directDependencies.length > 0 || packDependencies.length > 0) {
+        if (!input.client) {
+            throw new Error('dev_runtime_asset_resolver_missing');
         }
-        for (const member of packVersion.assets) {
-            const memberRef = (0, types_1.formatContentVersionRef)({
-                kind: 'asset',
-                creatorUsername: member.creatorUsername,
-                name: member.name,
-                revision: member.revision,
+        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/init.d.ts

@@ -5,7 +5,7 @@ export type InitSummary = {
     directory: string;
     cataloguePath: string;
     readmeStatus: 'created' | 'updated';
-    agentsStatus: 'created' | 'updated';
+    agentsStatus: 'created' | 'skipped';
     catalogueStatus: 'created' | 'skipped';
     gitStatus: 'initialized' | 'skipped' | 'declined';
 };

package/dist/commands/init.js

@@ -246,12 +246,17 @@ async function init(targetPath, options = {}) {
     const renderedReadme = ensureTrailingNewline(renderReadmeTemplate(readmeDownload, replacements));
     (0, node_fs_1.writeFileSync)(readmePath, renderedReadme, 'utf8');
     actions.push(readmeExisted ? 'Updated README.md' : 'Created README.md');
-    const agentsDownload = await downloadBootstrapAsset(envConfig.webBase, normalized.agentsUri, 'AGENTS.md');
-    if (!agentsDownload) {
-        return null;
+    if (agentsExisted) {
+        actions.push('Skipped existing AGENTS.md');
+    }
+    else {
+        const agentsDownload = await downloadBootstrapAsset(envConfig.webBase, normalized.agentsUri, 'AGENTS.md');
+        if (!agentsDownload) {
+            return null;
+        }
+        (0, node_fs_1.writeFileSync)(agentsPath, agentsDownload, 'utf8');
+        actions.push('Created AGENTS.md');
     }
-    (0, node_fs_1.writeFileSync)(agentsPath, agentsDownload, 'utf8');
-    actions.push(agentsExisted ? 'Updated AGENTS.md' : 'Created AGENTS.md');
     if (!catalogueExisted) {
         (0, node_fs_1.writeFileSync)(cataloguePath, normalized.catalogue, 'utf8');
         actions.push('Created catalogue.json');
@@ -294,7 +299,7 @@ async function init(targetPath, options = {}) {
         directory: resolved,
         cataloguePath,
         readmeStatus: readmeExisted ? 'updated' : 'created',
-        agentsStatus: agentsExisted ? 'updated' : 'created',
+        agentsStatus: agentsExisted ? 'skipped' : 'created',
         catalogueStatus: catalogueExisted ? 'skipped' : 'created',
         gitStatus,
     };

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

@@ -6,6 +6,8 @@ export type UploadCommandOptions = {
     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;
@@ -34,7 +36,16 @@ export type WorkerAppPublishResult = {
     warnings: string[];
 };
 export type WorkerPlaydropAssetRequirement = 'PACK' | 'ASSET_OR_PACK';
+export declare function resolveWorkerPlaydropAssetRequirement(value: unknown): WorkerPlaydropAssetRequirement | null;
 export declare function assertTaskPlaytestEvidenceManifest(task: AppTask, options?: {
     requireOutcomeProof?: boolean;
 }): AgentTaskPlaytestProof | null;
+export declare function assertWorkerAppLocalUploadPreflight(input: {
+    task: AppTask;
+    kind: 'NEW_GAME' | 'REMIX_GAME' | 'GAME_UPDATE';
+    executionTarget?: AgentExecutionTarget;
+    creatorUsername?: string | null;
+    playdropAssetRequirement?: WorkerPlaydropAssetRequirement | null;
+    creatorRequest?: string | null;
+}): Promise<AgentTaskPlaytestProof | null>;
 export declare function publishWorkerAppProject(input: WorkerAppPublishInput): Promise<WorkerAppPublishResult>;