@playdrop/playdrop-cli 0.12.27 → 0.12.28

package/config/client-meta.json

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

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

@@ -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;