@playdrop/playdrop-cli 0.9.6 → 0.10.1

package/config/client-meta.json

@@ -1,7 +1,7 @@
 {
-  "version": "0.9.6",
-  "runtimeSdkVersion": "0.7.21",
+  "version": "0.10.1",
   "build": 1,
+  "runtimeSdkVersion": "0.10.0",
   "clients": {
     "all": {
       "minimumVersion": "0.7.4"

package/dist/apiClient.d.ts

@@ -3,7 +3,17 @@ import { type AiClient } from '@playdrop/ai-client';
 type ClientOptions = {
     baseUrl: string;
     token?: string | null;
+    onBehalfCreatorUsername?: string | null;
+    agentTaskToken?: string | null;
+    agentTaskId?: number | null;
+    agentTaskAttempt?: number | null;
 };
+export declare function createCliClientHeaders(input: {
+    onBehalfCreatorUsername?: string | null;
+    agentTaskToken?: string | null;
+    agentTaskId?: number | null;
+    agentTaskAttempt?: number | null;
+}): Record<string, string>;
 export declare function createCliApiClient(options: ClientOptions): ApiClient;
 export declare function createCliAiClient(options: ClientOptions): AiClient;
 export {};

package/dist/apiClient.js

@@ -1,21 +1,74 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCliClientHeaders = createCliClientHeaders;
 exports.createCliApiClient = createCliApiClient;
 exports.createCliAiClient = createCliAiClient;
 const api_client_1 = require("@playdrop/api-client");
 const ai_client_1 = require("@playdrop/ai-client");
 const clientInfo_1 = require("./clientInfo");
+function readPositiveIntEnv(name) {
+    const raw = process.env[name]?.trim();
+    if (!raw) {
+        return null;
+    }
+    const parsed = Number(raw);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+}
+function createCliClientHeaders(input) {
+    const onBehalfCreatorUsername = input.onBehalfCreatorUsername;
+    const creatorUsername = typeof onBehalfCreatorUsername === 'string'
+        ? onBehalfCreatorUsername.trim()
+        : '';
+    const agentTaskToken = typeof input.agentTaskToken === 'string'
+        ? input.agentTaskToken.trim()
+        : '';
+    const agentTaskId = Number.isInteger(input.agentTaskId) && Number(input.agentTaskId) > 0
+        ? Number(input.agentTaskId)
+        : readPositiveIntEnv('PLAYDROP_WORKER_TASK_ID');
+    const agentTaskAttempt = Number.isInteger(input.agentTaskAttempt) && Number(input.agentTaskAttempt) > 0
+        ? Number(input.agentTaskAttempt)
+        : readPositiveIntEnv('PLAYDROP_WORKER_TASK_ATTEMPT');
+    if (agentTaskToken && process.env.PLAYDROP_WORKER_CONTEXT === '1' && (!agentTaskId || !agentTaskAttempt)) {
+        throw new Error('worker_ai_generation_task_context_missing');
+    }
+    return {
+        ...(0, clientInfo_1.createClientHeaders)(),
+        ...(creatorUsername
+            ? {
+                'x-playdrop-creator-username': creatorUsername,
+                'x-playdrop-ai-paid-by': 'creator',
+            }
+            : {}),
+        ...(agentTaskToken
+            ? {
+                'x-playdrop-agent-task-token': agentTaskToken,
+                ...(agentTaskId ? { 'x-playdrop-agent-task-id': String(agentTaskId) } : {}),
+                ...(agentTaskAttempt ? { 'x-playdrop-agent-task-attempt': String(agentTaskAttempt) } : {}),
+            }
+            : {}),
+    };
+}
 function createCliApiClient(options) {
     return (0, api_client_1.createApiClient)({
         baseUrl: options.baseUrl,
-        clientHeaders: () => (0, clientInfo_1.createClientHeaders)(),
+        clientHeaders: () => createCliClientHeaders({
+            onBehalfCreatorUsername: options.onBehalfCreatorUsername,
+            agentTaskToken: options.agentTaskToken,
+            agentTaskId: options.agentTaskId,
+            agentTaskAttempt: options.agentTaskAttempt,
+        }),
         tokenProvider: () => options.token ?? null,
     });
 }
 function createCliAiClient(options) {
     return (0, ai_client_1.createAiClient)({
         baseUrl: options.baseUrl,
-        clientHeaders: () => (0, clientInfo_1.createClientHeaders)(),
+        clientHeaders: () => createCliClientHeaders({
+            onBehalfCreatorUsername: options.onBehalfCreatorUsername,
+            agentTaskToken: options.agentTaskToken,
+            agentTaskId: options.agentTaskId,
+            agentTaskAttempt: options.agentTaskAttempt,
+        }),
         tokenProvider: () => options.token ?? null,
     });
 }

package/dist/appUrls.d.ts

@@ -11,6 +11,7 @@ export declare function buildPlatformDevUrl(webBase: string | null | undefined,
     devAuth?: 'prompt' | 'anonymous' | 'viewer' | 'player';
     player?: string | null;
     launchCheck?: boolean;
+    localDevPort?: number | string | null;
 }): string;
 export declare function buildUploadLaunchCheckUrl(webBase: string | null | undefined, input: AppUrlInput & {
     sessionId: string;

package/dist/appUrls.js

@@ -48,6 +48,15 @@ function buildPlatformDevUrl(webBase, input) {
     if (input.launchCheck) {
         url.searchParams.set('launchCheck', '1');
     }
+    if (input.localDevPort !== null && input.localDevPort !== undefined) {
+        const port = typeof input.localDevPort === 'number'
+            ? input.localDevPort
+            : Number.parseInt(String(input.localDevPort), 10);
+        if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+            throw new Error('invalid_local_dev_port');
+        }
+        url.searchParams.set('localDevPort', String(port));
+    }
     return url.toString();
 }
 function buildUploadLaunchCheckUrl(webBase, input) {

package/dist/apps/build.js

@@ -249,6 +249,9 @@ function collectProjectFiles(rootDir, rules, options) {
             if (!relativePath)
                 continue;
             const isDir = entry.isDirectory();
+            const exclusionTarget = isDir ? `${relativePath}/` : relativePath;
+            if (isExcludedRelativePath(exclusionTarget, excludeRelativeFiles))
+                continue;
             if (!isDir && enforceReservedBundleNames && isReservedBundlePath(relativePath)) {
                 throw new Error(`[apps][build] Reserved bundle filename "${relativePath}" is not allowed. Use dedicated source/ecs/server upload fields.`);
             }
@@ -270,7 +273,7 @@ function collectProjectFiles(rootDir, rules, options) {
             }
             if (!stats.isFile())
                 continue;
-            if (excludeRelativeFiles.has(relativePath))
+            if (isExcludedRelativePath(relativePath, excludeRelativeFiles))
                 continue;
             const record = {
                 absolutePath,
@@ -287,6 +290,17 @@ function collectProjectFiles(rootDir, rules, options) {
     results.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
     return results;
 }
+function isExcludedRelativePath(relativePath, excludedRelativeFiles) {
+    if (excludedRelativeFiles.has(relativePath)) {
+        return true;
+    }
+    for (const excludedPath of excludedRelativeFiles) {
+        if (excludedPath.endsWith('/') && relativePath.startsWith(excludedPath)) {
+            return true;
+        }
+    }
+    return false;
+}
 // Files that are uploaded separately and should not be included in the bundle zip.
 const RESERVED_BUNDLE_FILES = new Set(['source.zip', 'ecs.json', 'server.js']);
 function isReservedBundlePath(relativePath) {
@@ -297,32 +311,6 @@ function isReservedBundlePath(relativePath) {
 function resolveRuntimeRoot(task) {
     return (0, node_path_1.resolve)((0, node_path_1.dirname)(task.filePath));
 }
-function collectSeparatelyUploadedSourceFiles(task) {
-    const excludedFiles = new Set();
-    const addFile = (filePath) => {
-        if (!filePath) {
-            return;
-        }
-        const absolutePath = (0, node_path_1.resolve)(filePath);
-        if (!isPathWithinRoot(task.projectDir, absolutePath)) {
-            return;
-        }
-        const relativePath = normalizeRelativePath(task.projectDir, absolutePath);
-        if (!relativePath || relativePath.startsWith('..')) {
-            return;
-        }
-        excludedFiles.add(relativePath);
-    };
-    addFile(task.listing?.iconPath);
-    addFile(task.listing?.heroPortraitPath);
-    addFile(task.listing?.heroLandscapePath);
-    task.listing?.screenshotPortraitPaths?.forEach(addFile);
-    task.listing?.screenshotLandscapePaths?.forEach(addFile);
-    task.listing?.videoPortraitPaths?.forEach(addFile);
-    task.listing?.videoLandscapePaths?.forEach(addFile);
-    task.achievements?.forEach((definition) => addFile(definition.iconPath));
-    return Array.from(excludedFiles).sort((left, right) => left.localeCompare(right));
-}
 function resolveBundleEntryPoint(task, runtimeRoot) {
     const entryPoint = normalizeRelativePath(runtimeRoot, task.filePath);
     if (!entryPoint || entryPoint.startsWith('..')) {
@@ -330,6 +318,28 @@ function resolveBundleEntryPoint(task, runtimeRoot) {
     }
     return entryPoint;
 }
+function normalizeBundleArchiveExclusions(task, runtimeRoot) {
+    const exclusions = task.bundleArchiveExcludeRelativeFiles ?? [];
+    const runtimeRootAbsolute = (0, node_path_1.resolve)(runtimeRoot);
+    const normalized = [];
+    for (const exclusion of exclusions) {
+        const trimmed = exclusion.trim();
+        if (!trimmed) {
+            continue;
+        }
+        const isDirectory = trimmed.replace(/\\/g, '/').endsWith('/');
+        const absolutePath = (0, node_path_1.resolve)(task.projectDir, trimmed);
+        if (!isPathWithinRoot(runtimeRootAbsolute, absolutePath)) {
+            continue;
+        }
+        const runtimeRelativePath = normalizeRelativePath(runtimeRootAbsolute, absolutePath);
+        if (!runtimeRelativePath || runtimeRelativePath.startsWith('..')) {
+            continue;
+        }
+        normalized.push(isDirectory ? `${runtimeRelativePath}/` : runtimeRelativePath);
+    }
+    return normalized;
+}
 /**
  * Collect files for the bundle zip.
  * Collect files for the bundle zip from the runtime root (dirname(entry file)).
@@ -340,6 +350,7 @@ function collectBundleFiles(task) {
     const rules = buildIgnoreRules(task.projectDir);
     const entries = collectProjectFiles(runtimeRoot, rules, {
         includeRelativeFiles: [entryPoint],
+        excludeRelativeFiles: normalizeBundleArchiveExclusions(task, runtimeRoot),
         enforceReservedBundleNames: true,
     });
     return { entries, entryPoint };
@@ -486,7 +497,7 @@ function createZipArchive(entries) {
 function createSourceArchive(task) {
     const rules = buildIgnoreRules(task.projectDir);
     const includeFiles = ['README.md', 'AGENTS.md'];
-    const excludedFiles = collectSeparatelyUploadedSourceFiles(task);
+    const excludedFiles = task.sourceArchiveExcludeRelativeFiles ?? [];
     if (task.catalogueAbsolutePath && (0, node_fs_1.existsSync)(task.catalogueAbsolutePath)) {
         const relativeCataloguePath = normalizeRelativePath(task.projectDir, task.catalogueAbsolutePath) || 'catalogue.json';
         includeFiles.push(relativeCataloguePath);

package/dist/apps/index.d.ts

@@ -23,6 +23,7 @@ export type AppPipelineOptions = {
     runStagedUploadLaunchCheck?: boolean;
     launchCheckTimeoutMs?: number;
     ensureRegisteredAppShell?: boolean;
+    agentTaskId?: number;
 };
 export declare function runAppPipeline(client: ApiClient, task: AppTask, options?: AppPipelineOptions): Promise<AppPipelineResult>;
 export { collectAppValidationWarnings, validateAppTask, buildApp, uploadApp, runFormatScript };

package/dist/apps/index.js

@@ -29,6 +29,7 @@ async function runAppPipeline(client, task, options) {
             client,
             creatorUsername,
             task,
+            agentTaskId: options.agentTaskId,
         });
     }
     if (!isExternal && options?.runLocalLaunchCheck) {
@@ -65,6 +66,7 @@ async function runAppPipeline(client, task, options) {
         user: options?.user ?? null,
         runStagedUploadLaunchCheck: options?.runStagedUploadLaunchCheck,
         launchCheckTimeoutMs: options?.launchCheckTimeoutMs,
+        agentTaskId: options?.agentTaskId,
     };
     const upload = await (0, upload_1.uploadApp)(client, task, artifacts, uploadOptions);
     return { artifacts, upload, warnings };

package/dist/apps/launchCheck.d.ts

@@ -15,9 +15,11 @@ export declare function runLocalHostedLaunchCheck(input: {
     webBase: string | null | undefined;
     creatorUsername: string;
     task: AppTask;
+    devRouterPort?: number;
     timeoutMs?: number;
     token?: string | null;
     currentUser?: UserResponse | null;
+    allowUnregisteredViewerLaunch?: boolean;
 }): Promise<HostedLaunchCheckResult>;
 export declare function runUploadedHostedLaunchCheck(input: {
     client: ApiClient;

package/dist/apps/launchCheck.js

@@ -49,6 +49,20 @@ function buildFailedLaunchCheckResult(errorCode, message, artifactFingerprint) {
         artifactFingerprint,
     };
 }
+function formatCaptureErrors(errors) {
+    if (!Array.isArray(errors) || errors.length === 0) {
+        return '';
+    }
+    const normalized = errors
+        .map((entry) => entry.replace(/\s+/g, ' ').trim())
+        .filter(Boolean)
+        .slice(0, 3)
+        .map((entry) => entry.length > 240 ? `${entry.slice(0, 237)}...` : entry);
+    if (normalized.length === 0) {
+        return '';
+    }
+    return ` First error${normalized.length === 1 ? '' : 's'}: ${normalized.join(' | ')}`;
+}
 function formatHostedLaunchCheckFailure(taskName, result, scope = 'local') {
     const scopeLabel = scope === 'staged' ? 'staged upload preview' : 'local hosted preview';
     const errorCode = result.errorCode?.trim() || 'startup_failure';
@@ -113,7 +127,7 @@ async function runHostedLaunchCheckWithCapture(options) {
             savedSessionBootstrap: options.savedSessionBootstrap ?? false,
         });
         if (result.errorCount > 0) {
-            return buildFailedLaunchCheckResult('startup_failure', `Hosted app emitted ${result.errorCount} console, page, or network error(s) during startup.`, options.artifactFingerprint ?? null);
+            return buildFailedLaunchCheckResult('startup_failure', `Hosted app emitted ${result.errorCount} console, page, or network error(s) during startup.${formatCaptureErrors(result.errors)}`, options.artifactFingerprint ?? null);
         }
         if (result.hostedLaunchState?.state !== expectedHostedLaunchState) {
             return buildFailedLaunchCheckResult('startup_failure', expectedHostedLaunchState === 'login_required'
@@ -135,6 +149,7 @@ async function runHostedLaunchCheckWithCapture(options) {
 }
 async function startOrReuseMountedDevRuntime(input) {
     const appTypeSlug = (0, appUrls_1.getAppTypeSlug)(input.task.type ?? 'GAME');
+    const devRouterPort = input.devRouterPort ?? devServer_1.DEV_ROUTER_PORT;
     const runtimeAssetManifest = input.task.hostingMode === 'EXTERNAL' || input.task.externalUrl
         ? (0, devRuntimeAssets_1.createEmptyDevRuntimeAssetManifest)()
         : await (0, devRuntimeAssets_1.buildDevRuntimeAssetManifest)({
@@ -142,20 +157,20 @@ async function startOrReuseMountedDevRuntime(input) {
             apiBase: input.apiBase,
             task: input.task,
             creatorUsername: input.creatorUsername,
-            appBaseUrl: `http://127.0.0.1:${devServer_1.DEV_ROUTER_PORT}/apps/dev/${encodeURIComponent(input.creatorUsername)}/${encodeURIComponent(appTypeSlug)}/${encodeURIComponent(input.task.name)}/`,
+            appBaseUrl: `http://127.0.0.1:${devRouterPort}/apps/dev/${encodeURIComponent(input.creatorUsername)}/${encodeURIComponent(appTypeSlug)}/${encodeURIComponent(input.task.name)}/`,
         });
     const serverAlreadyRunning = await (0, devServer_1.isDevServerAvailable)({
         creatorUsername: input.creatorUsername,
         appType: appTypeSlug,
         appName: input.task.name,
-        port: devServer_1.DEV_ROUTER_PORT,
+        port: devRouterPort,
     }, 750);
     if (serverAlreadyRunning) {
         await (0, devServer_1.updateMountedDevRuntimeAssetManifest)({
             creatorUsername: input.creatorUsername,
             appName: input.task.name,
             runtimeAssetManifest,
-            port: devServer_1.DEV_ROUTER_PORT,
+            port: devRouterPort,
         });
         return { handle: null, runtimeAssetManifest };
     }
@@ -165,7 +180,7 @@ async function startOrReuseMountedDevRuntime(input) {
             appType: appTypeSlug,
             creatorUsername: input.creatorUsername,
             htmlPath: input.task.filePath,
-            port: devServer_1.DEV_ROUTER_PORT,
+            port: devRouterPort,
             projectInfo: (0, devShared_1.findProjectInfo)(input.task.filePath),
             runtimeAssetManifest,
         });
@@ -189,12 +204,19 @@ async function runLocalHostedLaunchCheck(input) {
             apiBase: input.apiBase,
             creatorUsername: input.creatorUsername,
             task: input.task,
+            devRouterPort: input.devRouterPort,
         });
+        const localDevPort = input.devRouterPort === undefined || input.devRouterPort === devServer_1.DEV_ROUTER_PORT
+            ? null
+            : input.devRouterPort;
         const localAppMetadata = mountedRuntime.runtimeAssetManifest.response.localAppMetadata;
         const anonymousExpectedState = resolveAnonymousHostedLaunchState(localAppMetadata);
         if (anonymousExpectedState === 'login_required') {
             const registeredApp = await (0, registration_1.fetchRegisteredAppShell)(input.client, input.creatorUsername, input.task.name);
-            if (!registeredApp?.id) {
+            const canLaunchUnregisteredViewer = input.allowUnregisteredViewerLaunch === true
+                && Boolean(input.token)
+                && Boolean(input.currentUser);
+            if (!registeredApp?.id && !canLaunchUnregisteredViewer) {
                 return buildRegistrationRequiredLaunchCheckFailure(input.task.name);
             }
             const anonymousGateResult = await runHostedLaunchCheckWithCapture({
@@ -204,6 +226,7 @@ async function runLocalHostedLaunchCheck(input) {
                     appType: input.task.type ?? 'GAME',
                     devAuth: 'anonymous',
                     launchCheck: true,
+                    localDevPort,
                 }),
                 timeoutMs: input.timeoutMs,
                 expectedHostedLaunchState: anonymousExpectedState,
@@ -218,6 +241,7 @@ async function runLocalHostedLaunchCheck(input) {
                     appType: input.task.type ?? 'GAME',
                     devAuth: 'viewer',
                     launchCheck: true,
+                    localDevPort,
                 }),
                 timeoutMs: input.timeoutMs,
                 expectedHostedLaunchState: resolvePostAuthHostedLaunchState(localAppMetadata.controllerMode),
@@ -233,6 +257,7 @@ async function runLocalHostedLaunchCheck(input) {
                 appType: input.task.type ?? 'GAME',
                 devAuth: 'anonymous',
                 launchCheck: true,
+                localDevPort,
             }),
             timeoutMs: input.timeoutMs,
             expectedHostedLaunchState: anonymousExpectedState,

package/dist/apps/registration.d.ts

@@ -6,6 +6,7 @@ export declare function ensureRegisteredHostedAppShell(input: {
     client: ApiClient;
     creatorUsername: string;
     task: AppTask;
+    agentTaskId?: number;
 }): Promise<{
     app: AppResponse;
     created: boolean;

package/dist/apps/registration.js

@@ -27,6 +27,7 @@ async function ensureRegisteredHostedAppShell(input) {
         const createdResponse = await input.client.createApp(input.creatorUsername, {
             name: input.task.name,
             displayName,
+            ...(input.agentTaskId !== undefined ? { agentTaskId: input.agentTaskId } : {}),
         });
         app = createdResponse.app;
         created = true;

package/dist/apps/upload.d.ts

@@ -22,5 +22,6 @@ export type AppUploadOptions = {
     user?: UserResponse | null;
     runStagedUploadLaunchCheck?: boolean;
     launchCheckTimeoutMs?: number;
+    agentTaskId?: number;
 };
 export declare function uploadApp(client: ApiClient, task: AppTask, artifacts: AppBuildArtifacts | null, options?: AppUploadOptions): Promise<AppUploadResult>;

package/dist/apps/upload.js

@@ -125,26 +125,11 @@ async function prepareOwnedAssetUpload(task) {
         files,
     };
 }
-// eslint-disable-next-line complexity -- Source archive failures need distinct guidance when publish-only media is already excluded.
-function ensurePreparedArtifactSize(file, maxBytes, code, label, task) {
+function ensurePreparedArtifactSize(file, maxBytes, code, label) {
     if (!file) {
         return 0;
     }
     if (file.size > maxBytes) {
-        if (code === 'source_too_large' && task) {
-            const hasSeparatePublishMedia = Boolean(task.listing?.iconPath
-                || task.listing?.heroPortraitPath
-                || task.listing?.heroLandscapePath
-                || task.listing?.screenshotPortraitPaths?.length
-                || task.listing?.screenshotLandscapePaths?.length
-                || task.listing?.videoPortraitPaths?.length
-                || task.listing?.videoLandscapePaths?.length
-                || task.achievements?.length);
-            const suffix = hasSeparatePublishMedia
-                ? ' Listing and achievement media are uploaded separately and excluded from source.zip. The remaining source archive is still too large.'
-                : '';
-            throw createUploadValidationError(code, `${label} must be under ${formatLimitBytes(maxBytes)}. Received ${file.size} bytes.${suffix}`);
-        }
         throw createUploadValidationError(code, `${label} must be under ${formatLimitBytes(maxBytes)}. Received ${file.size} bytes.`);
     }
     return file.size;
@@ -160,7 +145,7 @@ function pushPreparedFile(taskName, currentTotal, prepared) {
     return accumulateUploadBytes(taskName, currentTotal, prepared.size);
 }
 function pushPreparedArtifact(task, currentTotal, file, maxBytes, code, label) {
-    const bytes = ensurePreparedArtifactSize(file, maxBytes, code, label, task);
+    const bytes = ensurePreparedArtifactSize(file, maxBytes, code, label);
     return accumulateUploadBytes(task.name, currentTotal, bytes);
 }
 async function uploadApp(client, task, artifacts, options) {
@@ -256,8 +241,10 @@ async function uploadAppVersion(client, task, artifacts, options) {
     }
     const initializeRequest = {
         version: task.version,
+        agentTaskId: options?.agentTaskId,
         releaseNotes: task.releaseNotes,
         visibility: task.versionVisibility,
+        setAsCurrent: task.versionVisibility === 'PRIVATE' ? false : undefined,
         license: task.license,
         remixRef: task.remix,
         usesAssets: task.uses.assets.map((entry) => ({

package/dist/captureRuntime.d.ts

@@ -24,8 +24,21 @@ export type RunCaptureOptions = {
     enableCaptureBridge?: boolean;
     requireHostedLaunchReady?: boolean;
     expectedHostedLaunchState?: HostedLaunchExpectedState;
+    actions?: CaptureAction[];
 };
 export type HostedLaunchExpectedState = 'ready' | 'login_required' | 'controller_required' | 'surface_unsupported';
+export type CaptureAction = {
+    type: 'click';
+    x: number;
+    y: number;
+    button?: 'left' | 'right' | 'middle';
+} | {
+    type: 'press';
+    key: string;
+} | {
+    type: 'wait';
+    ms: number;
+};
 export type CaptureHostedLaunchState = {
     state: 'ready';
 } | {
@@ -41,6 +54,7 @@ export type CaptureHostedLaunchState = {
 };
 export type CaptureRunResult = {
     errorCount: number;
+    errors: string[];
     warningCount: number;
     warnings: string[];
     finalUrl: string;