@playdrop/playdrop-cli 0.13.16 → 0.14.0

package/dist/commands/upload.js

@@ -6,6 +6,7 @@ exports.upload = upload;
 exports.resolveWorkerPlaydropAssetRequirement = resolveWorkerPlaydropAssetRequirement;
 exports.assertAgentNewGamePlaytestContract = assertAgentNewGamePlaytestContract;
 exports.assertWorkerAppLocalUploadPreflight = assertWorkerAppLocalUploadPreflight;
+exports.preflightWorkerAppProject = preflightWorkerAppProject;
 exports.publishWorkerAppProject = publishWorkerAppProject;
 exports.publishStaticHtmlProject = publishStaticHtmlProject;
 const node_fs_1 = require("node:fs");
@@ -23,6 +24,7 @@ const output_1 = require("../output");
 const taskSelection_1 = require("../taskSelection");
 const taskUtils_1 = require("../taskUtils");
 const uploadLog_1 = require("../uploadLog");
+const workerAppProject_1 = require("../workerAppProject");
 const upload_content_1 = require("./upload-content");
 const appUrls_1 = require("../appUrls");
 const devRuntimeAssets_1 = require("./devRuntimeAssets");
@@ -1275,19 +1277,6 @@ function assertAgentNewGamePlaytestContract(task) {
         }
     }
 }
-const WORKER_SUPERVISOR_SOURCE_EXCLUDES = [
-    'PLAYDROP_TASK.md',
-    'AGENTS.md',
-    'CLAUDE.md',
-    '.playdrop/',
-    '.playdrop-task-events/',
-    'bin/playdrop',
-];
-const WORKER_SUPERVISOR_BUNDLE_EXCLUDES = [
-    ...WORKER_SUPERVISOR_SOURCE_EXCLUDES,
-    'assets/marketing/',
-    'listing/',
-];
 function appTaskSatisfiesPlaydropAssetRequirement(task, requirement) {
     if (!requirement) {
         return true;
@@ -1706,58 +1695,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 assertGreyboxReport(task) {
-    const reportPath = (0, node_path_1.join)(task.projectDir, 'greybox-report.json');
-    if (!(0, node_fs_1.existsSync)(reportPath)) {
-        throw new Error('agent_task_greybox_report_missing: greybox-report.json must prove the prototype and final start, agency, and restart checks.');
-    }
-    let report;
-    try {
-        const parsed = JSON.parse((0, node_fs_1.readFileSync)(reportPath, 'utf8'));
-        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-            throw new Error('report must be a JSON object');
-        }
-        report = parsed;
-    }
-    catch (error) {
-        throw new Error(`agent_task_greybox_report_invalid: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    if (report.schemaVersion !== 1 || Object.keys(report).some((key) => !['schemaVersion', 'prototype', 'final'].includes(key))) {
-        throw new Error('agent_task_greybox_report_invalid: expected schemaVersion 1 with only prototype and final sections.');
-    }
-    for (const sectionName of ['prototype', 'final']) {
-        const rawSection = report[sectionName];
-        if (!rawSection || typeof rawSection !== 'object' || Array.isArray(rawSection)) {
-            throw new Error(`agent_task_greybox_report_invalid: ${sectionName} must contain start, agency, and restart.`);
-        }
-        const section = rawSection;
-        if (Object.keys(section).length !== 3
-            || Object.keys(section).some((key) => !['start', 'agency', 'restart'].includes(key))) {
-            throw new Error(`agent_task_greybox_report_invalid: ${sectionName} must contain exactly start, agency, and restart.`);
-        }
-        for (const checkName of ['start', 'agency', 'restart']) {
-            const rawCheck = section[checkName];
-            if (!rawCheck || typeof rawCheck !== 'object' || Array.isArray(rawCheck)) {
-                throw new Error(`agent_task_greybox_report_invalid: ${sectionName}.${checkName} must be an object.`);
-            }
-            const check = rawCheck;
-            const expectedKeys = checkName === 'agency'
-                ? ['passed', 'normalInput', 'controlCondition', 'observation']
-                : ['passed', 'observation'];
-            if (Object.keys(check).length !== expectedKeys.length
-                || Object.keys(check).some((key) => !expectedKeys.includes(key))
-                || check.passed !== true
-                || typeof check.observation !== 'string'
-                || !check.observation.trim()
-                || (checkName === 'agency' && (typeof check.normalInput !== 'string'
-                    || !check.normalInput.trim()
-                    || typeof check.controlCondition !== 'string'
-                    || !check.controlCondition.trim()))) {
-                throw new Error(`agent_task_greybox_report_invalid: ${sectionName}.${checkName} must be complete and passing.`);
-            }
-        }
-    }
-}
 async function collectUploadPreflightErrors(checks) {
     const errors = [];
     for (const check of checks) {
@@ -1770,14 +1707,27 @@ async function collectUploadPreflightErrors(checks) {
     }
     return errors;
 }
-async function assertWorkerAppLocalUploadPreflight(input) {
-    if (input.kind === 'GAME_UPDATE') {
-        return;
+function assertAgentTaskReleaseNotes(task) {
+    const releaseNotes = task.releaseNotes?.trim() ?? '';
+    if (!releaseNotes) {
+        throw new Error('agent_task_release_notes_missing');
+    }
+    if (/[\r\n]/.test(releaseNotes)) {
+        throw new Error('agent_task_release_notes_multiline');
     }
+    if (releaseNotes.length > 240) {
+        throw new Error('agent_task_release_notes_too_long');
+    }
+}
+async function assertWorkerAppLocalUploadPreflight(input) {
+    const complete = input.stage !== 'PRE_CAPTURE';
+    const existingCaptureReport = input.task.listing?.captureReportPath;
+    const shouldCheckExistingCapture = !complete
+        && Boolean(existingCaptureReport)
+        && (0, node_fs_1.existsSync)(existingCaptureReport);
     const errors = await collectUploadPreflightErrors([
-        () => assertGreyboxReport(input.task),
-        () => (0, listingPreflight_1.assertAgentGameHeroListingPreflight)(input.task),
-        ...(input.kind === 'NEW_GAME' ? [() => (0, listingPreflight_1.assertAgentNewGameArtDirectionPreflight)(input.task)] : []),
+        () => assertAgentTaskReleaseNotes(input.task),
+        ...(complete ? [() => (0, listingPreflight_1.assertAgentGameHeroListingPreflight)(input.task)] : []),
         ...(input.kind === 'NEW_GAME' ? [() => assertAgentNewGamePlaytestContract(input.task)] : []),
         () => {
             if (!appTaskSatisfiesPlaydropAssetRequirement(input.task, input.playdropAssetRequirement)) {
@@ -1794,10 +1744,23 @@ async function assertWorkerAppLocalUploadPreflight(input) {
             creatorUsername: input.creatorUsername?.trim() ?? '',
             task: input.task,
         }),
-        () => (0, listingPreflight_1.assertAgentGameScreenshotListingPreflight)(input.task),
-        () => (0, listingPreflight_1.assertAgentGameCaptureReportPreflight)(input.task, {
-            requireCaptureReport: input.executionTarget === 'FIRST_PARTY',
-        }),
+        ...(complete
+            ? [
+                () => (0, listingPreflight_1.assertAgentGameScreenshotListingPreflight)(input.task),
+                () => (0, listingPreflight_1.assertAgentGameCaptureReportPreflight)(input.task, {
+                    requireCaptureReport: input.executionTarget === 'FIRST_PARTY',
+                    expectedRuntimeBundleHash: input.expectedRuntimeBundleHash,
+                }),
+            ]
+            : []),
+        ...(shouldCheckExistingCapture
+            ? [
+                () => (0, listingPreflight_1.assertAgentGameCaptureReportPreflight)(input.task, {
+                    requireCaptureReport: false,
+                    expectedRuntimeBundleHash: input.expectedRuntimeBundleHash,
+                }),
+            ]
+            : []),
     ]);
     if (errors.length === 1) {
         throw new Error(errors[0]);
@@ -1806,10 +1769,7 @@ async function assertWorkerAppLocalUploadPreflight(input) {
         throw new Error(`agent_task_upload_preflight_failed:\n${errors.map((error, index) => `${index + 1}. ${error}`).join('\n')}`);
     }
 }
-// Task upload path used by "playdrop task upload": same internal pipeline as
-// "playdrop project publish", but always as one PRIVATE draft version for the
-// task's creator, with browser launch checks on before the version is created.
-async function publishWorkerAppProject(input) {
+async function prepareWorkerAppProject(input, stage) {
     const creatorUsername = input.creatorUsername.trim();
     if (!creatorUsername) {
         throw new Error('agent_task_creator_username_missing');
@@ -1830,15 +1790,21 @@ async function publishWorkerAppProject(input) {
     if (expectedAppName && appTask.name !== expectedAppName) {
         throw new Error(`agent_task_output_app_name_mismatch: expected catalogue app "${expectedAppName}", found "${appTask.name}".`);
     }
+    const expectedDisplayName = input.expectedDisplayName?.trim() ?? '';
+    if (expectedDisplayName && appTask.displayName !== expectedDisplayName) {
+        throw new Error(`agent_task_output_display_name_mismatch: expected "${expectedDisplayName}", found "${appTask.displayName ?? ''}".`);
+    }
+    const expectedSubtitle = input.expectedSubtitle?.trim() ?? '';
+    if (expectedSubtitle && appTask.subtitle !== expectedSubtitle) {
+        throw new Error(`agent_task_output_subtitle_mismatch: expected "${expectedSubtitle}", found "${appTask.subtitle ?? ''}".`);
+    }
+    if (input.expectedPrimarySurface && appTask.primarySurface !== input.expectedPrimarySurface) {
+        throw new Error(`agent_task_output_primary_surface_mismatch: expected "${input.expectedPrimarySurface}", found "${appTask.primarySurface ?? ''}".`);
+    }
     if ((input.kind === 'NEW_GAME' || input.kind === 'REMIX_GAME') && (appTask.type ?? 'GAME') !== 'GAME') {
         throw new Error(`agent_task_game_type_invalid:${appTask.type ?? 'missing'}`);
     }
-    const task = {
-        ...appTask,
-        versionVisibility: 'PRIVATE',
-        sourceArchiveExcludeRelativeFiles: WORKER_SUPERVISOR_SOURCE_EXCLUDES,
-        bundleArchiveExcludeRelativeFiles: WORKER_SUPERVISOR_BUNDLE_EXCLUDES,
-    };
+    const task = (0, workerAppProject_1.prepareWorkerAppTask)(appTask);
     if (input.kind === 'REMIX_GAME') {
         const expectedRemixRef = input.remixSourceRef?.trim() ?? '';
         if (!expectedRemixRef) {
@@ -1852,6 +1818,9 @@ async function publishWorkerAppProject(input) {
             throw new Error(`agent_task_remix_ref_mismatch:${catalogueRemixRef}:${expectedRemixRef}`);
         }
     }
+    await (0, apps_1.validateAppTask)(task);
+    const isExternal = task.hostingMode === 'EXTERNAL' || Boolean(task.externalUrl);
+    const artifacts = isExternal ? null : await (0, apps_1.buildApp)(task);
     await assertWorkerAppLocalUploadPreflight({
         task,
         kind: input.kind,
@@ -1859,12 +1828,38 @@ async function publishWorkerAppProject(input) {
         creatorUsername,
         playdropAssetRequirement: input.playdropAssetRequirement,
         creatorRequest: input.creatorRequest,
+        stage,
+        expectedRuntimeBundleHash: artifacts?.bundleHash,
     });
     await assertDeclared3dPlaydropPacksContainRuntimeModels({
         client: input.client,
         task,
         creatorRequest: input.creatorRequest,
     });
+    return {
+        task,
+        artifacts,
+        warnings: [...selection.warnings],
+        creatorUsername,
+    };
+}
+// Runs every worker upload check that can be proven before final recorder
+// output exists. It intentionally performs no app registration, metadata
+// update, upload-session creation, file upload, or version creation.
+async function preflightWorkerAppProject(input) {
+    const prepared = await prepareWorkerAppProject(input, 'PRE_CAPTURE');
+    return {
+        appName: prepared.task.name,
+        creatorUsername: prepared.creatorUsername,
+        warnings: prepared.warnings,
+    };
+}
+// Task upload path used by "playdrop task upload": same internal pipeline as
+// "playdrop project publish", but always as one PRIVATE draft version for the
+// task's creator, with browser launch checks on before the version is created.
+async function publishWorkerAppProject(input) {
+    const prepared = await prepareWorkerAppProject(input, 'COMPLETE');
+    const { task, artifacts, creatorUsername } = prepared;
     const { app } = await (0, registration_1.ensureRegisteredHostedAppShell)({
         client: input.client,
         creatorUsername,
@@ -1896,6 +1891,7 @@ async function publishWorkerAppProject(input) {
         mediaCaptureRequired: input.executionTarget === 'FIRST_PARTY',
         playtestSmokeCheckRequired: input.kind === 'NEW_GAME',
         captureSession,
+        ...(artifacts ? { artifacts } : {}),
     });
     if (!uploadResult.versionCreated || !uploadResult.version) {
         throw new Error(`App "${task.name}" upload did not return a created version.`);
@@ -1913,7 +1909,7 @@ async function publishWorkerAppProject(input) {
         version: uploadResult.version,
         appName: task.name,
         creatorUsername,
-        warnings: [...selection.warnings, ...warnings],
+        warnings: [...prepared.warnings, ...warnings],
     };
 }
 async function publishStaticHtmlProject(input) {
@@ -1933,6 +1929,14 @@ async function publishStaticHtmlProject(input) {
     });
     try {
         if (input.taskId !== undefined && !input.claimedAppName?.trim()) {
+            const subtitle = prepared.metadata.description?.trim() ?? '';
+            if (!subtitle) {
+                throw new Error('static_game_subtitle_required');
+            }
+            const primarySurface = prepared.runtimeTask.primarySurface;
+            if (!primarySurface) {
+                throw new Error('static_game_primary_surface_required');
+            }
             const taskToken = input.taskToken?.trim() ?? '';
             if (!taskToken) {
                 throw new Error('static_game_publish_task_token_missing');
@@ -1940,9 +1944,14 @@ async function publishStaticHtmlProject(input) {
             const claimed = await input.client.workerClaimAgentTaskSlug(input.taskId, {
                 appName: prepared.runtimeTask.name,
                 displayName: prepared.metadata.title,
+                subtitle,
+                primarySurface,
             });
-            if (claimed.appName !== prepared.runtimeTask.name) {
-                throw new Error(`static_game_publish_slug_claim_mismatch:${claimed.appName}:${prepared.runtimeTask.name}`);
+            if (claimed.appName !== prepared.runtimeTask.name
+                || claimed.displayName !== prepared.metadata.title
+                || claimed.subtitle !== subtitle
+                || claimed.primarySurface !== primarySurface) {
+                throw new Error(`static_game_publish_identity_claim_mismatch:${claimed.appName}:${prepared.runtimeTask.name}`);
             }
         }
         const { app } = await (0, registration_1.ensureRegisteredHostedAppShell)({

package/dist/commands/whoami.js

@@ -67,7 +67,16 @@ async function whoami(options = {}) {
         });
     }
     if (resolvedCtx.workspaceAuth) {
-        console.log(`Workspace account: ${username} (${resolvedCtx.env})`);
+        const workspaceOwner = resolvedCtx.workspaceAuth.config.ownerUsername;
+        if (username === workspaceOwner) {
+            console.log(`Workspace account: ${username} (${resolvedCtx.env})`);
+        }
+        else {
+            const role = data.user?.role?.trim();
+            console.log(`Authenticated actor: ${username} (${resolvedCtx.env}${role ? `, ${role}` : ''})`);
+            console.log(`Workspace owner: ${workspaceOwner}`);
+            console.log('Authorization: delegated account access is enforced by the PlayDrop API');
+        }
         const resolutionSources = ['.playdrop.json'];
         if (options.env) {
             resolutionSources.push(`--env ${options.env}`);

package/dist/commands/worker/runtime.js

@@ -804,10 +804,12 @@ function buildClaudeAllowedPermissionRules(workspaceDir, playdropCliEnabled = tr
         throw new Error('worker_claude_workspace_missing');
     }
     const absoluteWorkspacePattern = `//${workspaceRoot.replace(/^\/+/, '')}/**`;
+    const managedImagePython = node_path_1.default.join(node_os_1.default.homedir(), '.cache', 'playdrop', 'make-2d-asset-pack', 'venv-v1', 'bin', 'python');
     return [
         `Read(${absoluteWorkspacePattern})`,
         `Edit(${absoluteWorkspacePattern})`,
         `Write(${absoluteWorkspacePattern})`,
+        `Bash(${managedImagePython} *)`,
         ...(playdropCliEnabled ? [`Bash(${workspaceRoot}/bin/playdrop *)`] : []),
         ...CLAUDE_BUILD_PERMISSION_RULES.filter((rule) => (playdropCliEnabled || !rule.toLowerCase().includes('playdrop'))),
     ];

package/dist/commands/worker.d.ts

@@ -1,5 +1,5 @@
 import type { ApiClient } from '@playdrop/api-client';
-import { type AgentExecutionTarget, type AgentRuntime, type AgentTaskKind, type AgentTaskNextStepSuggestion, type AgentTaskResponse, type AgentWorkerCapabilities, type AgentWorkerResponse, type AgentWorkerUpdatePolicyResponse, type JsonValue, type WorkerTaskAssignmentV2, type WorkerTaskPluginV2, type WorkerClaimAgentTaskResponse } from '@playdrop/types';
+import { type AgentAvailabilityFailureReason, type AgentExecutionTarget, type AgentRuntime, type AgentTaskKind, type AgentTaskNextStepSuggestion, type AgentTaskResponse, type AppSurface, type AgentWorkerCapabilities, type AgentWorkerResponse, type AgentWorkerUpdatePolicyResponse, type JsonValue, type WorkerTaskAssignmentV2, type WorkerTaskPluginV2, type WorkerClaimAgentTaskResponse } from '@playdrop/types';
 import { loadConfig } from '../config';
 import { runShell } from '../shellProbe';
 import { type WorkerPlaydropAssetRequirement } from './upload';
@@ -79,6 +79,14 @@ type TaskCatalogueReportOptions = {
     file?: string;
     message?: string;
 };
+type TaskMaterialOptions = {
+    env?: string;
+    file?: string;
+    title?: string;
+    phase?: string;
+    poster?: string;
+    asset?: boolean;
+};
 type TaskCompleteOptions = {
     env?: string;
     nextSteps?: string;
@@ -88,10 +96,13 @@ type TaskCompleteOptions = {
 type TaskClaimSlugOptions = {
     appName?: string;
     displayName?: string;
+    subtitle?: string;
+    primarySurface?: string;
     env?: string;
 };
 type TaskUploadOptions = {
     env?: string;
+    preflightOnly?: boolean;
 };
 type TaskFailOptions = {
     env?: string;
@@ -147,6 +158,9 @@ type WorkerTaskContextFile = {
     creatorRequest: string;
     target: AgentExecutionTarget;
     outputAppName: string | null;
+    outputDisplayName: string | null;
+    outputSubtitle: string | null;
+    outputPrimarySurface: AppSurface | null;
     outputVersion: string;
     remixSourceRef?: string | null;
     allowedTemplateKeys?: string[];
@@ -154,6 +168,16 @@ type WorkerTaskContextFile = {
     devPort: number;
     env: string;
 };
+type WorkerQueuedEvent = {
+    kind: 'progress' | 'catalogue_preview';
+    phase: string | null;
+    message?: string | null;
+    done?: string | null;
+    current?: string | null;
+    pct?: number | null;
+    payload?: Record<string, unknown>;
+};
+export declare function resolveInitialCreatorProgress(kind: AgentTaskKind, creationRecovery?: boolean): WorkerQueuedEvent | null;
 type WorkerCodexModel = {
     model: string;
     reasoningEffort: string;
@@ -293,6 +317,7 @@ export declare function buildAgentFailureCode(agent: AgentRuntime, result: Logge
     model: string;
     reasoningEffort?: string | null;
 }): string;
+export declare function classifyAgentAvailabilityFailureReason(errorCode: string): AgentAvailabilityFailureReason | null;
 export declare function describeAgentFailureForEvent(errorCode: string): string;
 export declare function createLocalPlaydropShim(input: {
     workspaceDir: string;
@@ -385,6 +410,8 @@ export declare function assignmentRequiresRegisteredBundle(assignment: WorkerTas
 export declare function startWorker(options?: WorkerStartOptions): Promise<void>;
 export declare function reportTask(options: TaskReportOptions): Promise<void>;
 export declare function showTaskContext(): void;
+export declare function assertTaskAssetMaterialIsTransparentPng(filePath: string): Promise<void>;
+export declare function materialTask(options: TaskMaterialOptions): Promise<void>;
 export declare function reportCatalogueTask(options: TaskCatalogueReportOptions): Promise<void>;
 export declare function uploadTask(options?: TaskUploadOptions): Promise<void>;
 export declare function claimSlugTask(options: TaskClaimSlugOptions): Promise<void>;