@playdrop/playdrop-cli 0.11.9 → 0.12.1

package/config/client-meta.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.11.9",
+  "version": "0.12.1",
   "build": 1,
   "runtimeSdkVersion": "0.10.0",
   "clients": {

package/dist/apps/build.js

@@ -222,7 +222,6 @@ function appendIncludedProjectFile(rootDir, includePath, excludedRelativeFiles,
     const record = {
         absolutePath,
         relativePath: normalizedIncludePath,
-        mtime: stats.mtime,
     };
     results.push(record);
     fileByRelativePath.set(record.relativePath, record);
@@ -278,7 +277,6 @@ function collectProjectFiles(rootDir, rules, options) {
             const record = {
                 absolutePath,
                 relativePath: relativePath.split('/').join('/'),
-                mtime: stats.mtime,
             };
             results.push(record);
             fileByRelativePath.set(record.relativePath, record);
@@ -378,6 +376,7 @@ const CRC32_TABLE = (() => {
     return table;
 })();
 const ZIP_REGULAR_FILE_MODE = 0o100644;
+const ZIP_STABLE_TIMESTAMP = new Date(Date.UTC(1980, 0, 1, 0, 0, 0));
 function crc32(buffer) {
     let crc = 0 ^ -1;
     for (let i = 0; i < buffer.length; i += 1) {
@@ -404,7 +403,7 @@ function createZipArchive(entries) {
         const data = (0, node_fs_1.readFileSync)(entry.absolutePath);
         const compressed = (0, node_zlib_1.deflateRawSync)(data);
         const crc = crc32(data);
-        const { dosDate, dosTime } = toDosDateTime(entry.mtime);
+        const { dosDate, dosTime } = toDosDateTime(ZIP_STABLE_TIMESTAMP);
         const fileNameBuffer = Buffer.from(entry.relativePath, 'utf8');
         const localHeader = Buffer.alloc(30);
         let cursor = 0;

package/dist/apps/index.d.ts

@@ -4,7 +4,6 @@ import type { AppTask } from '../catalogue';
 import { collectAppValidationWarnings, validateAppTask, runFormatScript } from './validate';
 import { buildApp, type AppBuildArtifacts } from './build';
 import { uploadApp, type AppUploadResult } from './upload';
-import { formatHostedLaunchCheckFailure, runLocalHostedLaunchCheck, runUploadedHostedLaunchCheck, type HostedLaunchCheckResult } from './launchCheck';
 export type AppPipelineResult = {
     artifacts: AppBuildArtifacts | null;
     upload: AppUploadResult;
@@ -18,12 +17,12 @@ export type AppPipelineOptions = {
     webBase?: string | null;
     token?: string | null;
     user?: UserResponse | null;
-    runLocalLaunchCheck?: boolean;
-    runStagedUploadLaunchCheck?: boolean;
-    launchCheckTimeoutMs?: number;
+    runLocalLoadCheck?: boolean;
+    runStagedUploadLoadCheck?: boolean;
+    loadCheckTimeoutMs?: number;
     ensureRegisteredAppShell?: boolean;
     agentTaskId?: number;
+    mediaCaptureRequired?: boolean;
 };
 export declare function runAppPipeline(client: ApiClient, task: AppTask, options?: AppPipelineOptions): Promise<AppPipelineResult>;
 export { collectAppValidationWarnings, validateAppTask, buildApp, uploadApp, runFormatScript };
-export { formatHostedLaunchCheckFailure, runLocalHostedLaunchCheck, runUploadedHostedLaunchCheck, type HostedLaunchCheckResult, };

package/dist/apps/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runUploadedHostedLaunchCheck = exports.runLocalHostedLaunchCheck = exports.formatHostedLaunchCheckFailure = exports.runFormatScript = exports.uploadApp = exports.buildApp = exports.validateAppTask = exports.collectAppValidationWarnings = void 0;
+exports.runFormatScript = exports.uploadApp = exports.buildApp = exports.validateAppTask = exports.collectAppValidationWarnings = void 0;
 exports.runAppPipeline = runAppPipeline;
 const validate_1 = require("./validate");
 Object.defineProperty(exports, "collectAppValidationWarnings", { enumerable: true, get: function () { return validate_1.collectAppValidationWarnings; } });
@@ -10,11 +10,8 @@ const build_1 = require("./build");
 Object.defineProperty(exports, "buildApp", { enumerable: true, get: function () { return build_1.buildApp; } });
 const upload_1 = require("./upload");
 Object.defineProperty(exports, "uploadApp", { enumerable: true, get: function () { return upload_1.uploadApp; } });
-const launchCheck_1 = require("./launchCheck");
-Object.defineProperty(exports, "formatHostedLaunchCheckFailure", { enumerable: true, get: function () { return launchCheck_1.formatHostedLaunchCheckFailure; } });
-Object.defineProperty(exports, "runLocalHostedLaunchCheck", { enumerable: true, get: function () { return launchCheck_1.runLocalHostedLaunchCheck; } });
-Object.defineProperty(exports, "runUploadedHostedLaunchCheck", { enumerable: true, get: function () { return launchCheck_1.runUploadedHostedLaunchCheck; } });
 const registration_1 = require("./registration");
+const loadCheck_1 = require("./loadCheck");
 async function runAppPipeline(client, task, options) {
     await (0, validate_1.validateAppTask)(task);
     // External apps don't need to be built - they're hosted elsewhere
@@ -32,40 +29,41 @@ async function runAppPipeline(client, task, options) {
             agentTaskId: options.agentTaskId,
         });
     }
-    if (!isExternal && options?.runLocalLaunchCheck) {
+    const artifacts = isExternal ? null : await (0, build_1.buildApp)(task);
+    const warnings = (0, validate_1.collectAppValidationWarnings)(task, isExternal ? 'source' : 'bundle');
+    if (!isExternal && options?.runLocalLoadCheck) {
         const creatorUsername = typeof options.creatorUsername === 'string' ? options.creatorUsername.trim() : '';
         if (!creatorUsername) {
-            throw new Error(`Missing creator username for local hosted launch-check of "${task.name}".`);
+            throw new Error(`Missing creator username for local hosted load-check of "${task.name}".`);
         }
         const apiBase = typeof options.apiBase === 'string' ? options.apiBase.trim() : '';
         if (!apiBase) {
-            throw new Error(`Missing API base URL for local hosted launch-check of "${task.name}".`);
+            throw new Error(`Missing API base URL for local hosted load-check of "${task.name}".`);
         }
-        const launchCheck = await (0, launchCheck_1.runLocalHostedLaunchCheck)({
+        const loadCheck = await (0, loadCheck_1.runLocalHostedLoadCheck)({
             client,
             apiBase,
             webBase: options.webBase,
             creatorUsername,
             task,
-            timeoutMs: options.launchCheckTimeoutMs,
+            timeoutMs: options.loadCheckTimeoutMs,
             token: options.token ?? null,
             currentUser: options.user ?? null,
         });
-        if (launchCheck.status !== 'PASSED') {
-            throw new Error((0, launchCheck_1.formatHostedLaunchCheckFailure)(task.name, launchCheck, 'local'));
+        if (loadCheck.status !== 'PASSED') {
+            throw new Error((0, loadCheck_1.formatHostedLoadCheckFailure)(task.name, loadCheck, 'local'));
         }
     }
-    const artifacts = isExternal ? null : await (0, build_1.buildApp)(task);
-    const warnings = (0, validate_1.collectAppValidationWarnings)(task, isExternal ? 'source' : 'bundle');
     const uploadOptions = {
         skipReview: options?.skipReview,
         clearTags: options?.clearTags,
         creatorUsername: options?.creatorUsername,
         token: options?.token,
         user: options?.user ?? null,
-        runStagedUploadLaunchCheck: options?.runStagedUploadLaunchCheck,
-        launchCheckTimeoutMs: options?.launchCheckTimeoutMs,
+        runStagedUploadLoadCheck: options?.runStagedUploadLoadCheck,
+        loadCheckTimeoutMs: options?.loadCheckTimeoutMs,
         agentTaskId: options?.agentTaskId,
+        mediaCaptureRequired: options?.mediaCaptureRequired,
     };
     const upload = await (0, upload_1.uploadApp)(client, task, artifacts, uploadOptions);
     return { artifacts, upload, warnings };

package/dist/apps/loadCheck.d.ts

@@ -0,0 +1,76 @@
+import type { ApiClient } from '@playdrop/api-client';
+import type { UserResponse } from '@playdrop/types';
+import type { Frame, Page } from 'playwright-core';
+import type { AppTask } from '../catalogue';
+export type HostedLoadCheckResult = {
+    status: 'PASSED' | 'FAILED';
+    errorCode: string | null;
+    message: string | null;
+    checkedAt: string;
+    artifactFingerprint: string | null;
+    screenshotPath?: string | null;
+    webglRenderer?: string | null;
+    targetUrl?: string | null;
+    errors?: string[];
+    warnings?: string[];
+};
+export type HostedLaunchExpectedState = 'ready' | 'login_required' | 'controller_required' | 'surface_unsupported';
+export type HostedLaunchState = {
+    state: 'ready';
+} | {
+    state: 'login_required';
+} | {
+    state: 'controller_required';
+} | {
+    state: 'surface_unsupported';
+} | {
+    state: 'error';
+    errorCode: string | null;
+    message: string | null;
+};
+export type ProjectCheckAction = {
+    type: 'click';
+    x: number;
+    y: number;
+    button?: 'left' | 'right' | 'middle';
+} | {
+    type: 'press';
+    key: string;
+} | {
+    type: 'wait';
+    ms: number;
+};
+export declare function isSoftwareWebGlRenderer(renderer: string | null | undefined): boolean;
+export declare function normalizeProjectCheckActions(value: unknown): ProjectCheckAction[];
+export declare function focusProjectCheckGameFrame(page: Pick<Page, 'mouse'>, frame: Frame): Promise<{
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}>;
+export declare function dispatchProjectCheckActionsToFrame(page: Page, frame: Frame, actions: readonly ProjectCheckAction[]): Promise<void>;
+export declare function formatHostedLoadCheckFailure(taskName: string, result: HostedLoadCheckResult, scope?: 'local' | 'staged' | 'final'): string;
+export declare function runLocalHostedLoadCheck(input: {
+    client: ApiClient;
+    apiBase: string;
+    webBase: string | null | undefined;
+    creatorUsername: string;
+    task: AppTask;
+    devRouterPort?: number;
+    timeoutMs?: number;
+    token?: string | null;
+    currentUser?: UserResponse | null;
+    allowUnregisteredViewerLaunch?: boolean;
+    screenshotPath?: string | null;
+    actions?: ProjectCheckAction[];
+}): Promise<HostedLoadCheckResult>;
+export declare function runUploadedHostedLoadCheck(input: {
+    client: ApiClient;
+    creatorUsername: string;
+    task: AppTask;
+    sessionId: string;
+    timeoutMs?: number;
+    token?: string | null;
+    currentUser?: UserResponse | null;
+    screenshotPath?: string | null;
+}): Promise<HostedLoadCheckResult>;