@playdrop/playdrop-cli 0.6.4 → 0.6.6

package/config/client-meta.json

@@ -1,6 +1,6 @@
 {
-  "version": "0.6.4",
-  "build": 1,
+  "version": "0.6.6",
+  "build": 3,
   "platforms": {
     "ios": {
       "minimumVersion": "16.0"
@@ -26,12 +26,12 @@
   },
   "clients": {
     "web": {
-      "minimumVersion": "0.6.4",
-      "minimumBuild": 1
+      "minimumVersion": "0.6.6",
+      "minimumBuild": 3
     },
     "admin": {
-      "minimumVersion": "0.6.4",
-      "minimumBuild": 1
+      "minimumVersion": "0.6.6",
+      "minimumBuild": 3
     },
     "apple": {
       "minimumVersion": "0.3.10",
@@ -46,7 +46,7 @@
       "minimumBuild": 1
     },
     "cli": {
-      "minimumVersion": "0.6.4"
+      "minimumVersion": "0.6.6"
     }
   }
 }

package/dist/appUrls.d.ts

@@ -7,3 +7,11 @@ export type AppUrlInput = {
 export declare function normalizePlaydropWebBase(webBase?: string | null): string;
 export declare function getAppTypeSlug(type: AppType | string | null | undefined): string;
 export declare function buildPlatformPlayUrl(webBase: string | null | undefined, input: AppUrlInput): string;
+export declare function buildPlatformDevUrl(webBase: string | null | undefined, input: AppUrlInput & {
+    devAuth?: 'prompt' | 'anonymous' | 'viewer' | 'player';
+    player?: string | null;
+    launchCheck?: boolean;
+}): string;
+export declare function buildUploadLaunchCheckUrl(webBase: string | null | undefined, input: AppUrlInput & {
+    sessionId: string;
+}): string;

package/dist/appUrls.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizePlaydropWebBase = normalizePlaydropWebBase;
 exports.getAppTypeSlug = getAppTypeSlug;
 exports.buildPlatformPlayUrl = buildPlatformPlayUrl;
+exports.buildPlatformDevUrl = buildPlatformDevUrl;
+exports.buildUploadLaunchCheckUrl = buildUploadLaunchCheckUrl;
 const DEFAULT_WEB_BASE = 'https://www.playdrop.ai';
 function normalizePlaydropWebBase(webBase) {
     const base = typeof webBase === 'string' && webBase.trim().length > 0 ? webBase.trim() : DEFAULT_WEB_BASE;
@@ -31,3 +33,28 @@ function buildPlatformPlayUrl(webBase, input) {
     const appName = encodeURIComponent(input.appName);
     return `${base}/creators/${creator}/apps/${typeSlug}/${appName}/play`;
 }
+function buildPlatformDevUrl(webBase, input) {
+    const base = normalizePlaydropWebBase(webBase);
+    const creator = encodeURIComponent(input.creatorUsername);
+    const typeSlug = getAppTypeSlug(input.appType);
+    const appName = encodeURIComponent(input.appName);
+    const url = new URL(`${base}/creators/${creator}/apps/${typeSlug}/${appName}/dev`);
+    if (typeof input.devAuth === 'string' && input.devAuth.trim().length > 0) {
+        url.searchParams.set('devAuth', input.devAuth.trim());
+    }
+    if (typeof input.player === 'string' && input.player.trim().length > 0) {
+        url.searchParams.set('player', input.player.trim());
+    }
+    if (input.launchCheck) {
+        url.searchParams.set('launchCheck', '1');
+    }
+    return url.toString();
+}
+function buildUploadLaunchCheckUrl(webBase, input) {
+    const base = normalizePlaydropWebBase(webBase);
+    const creator = encodeURIComponent(input.creatorUsername);
+    const typeSlug = getAppTypeSlug(input.appType);
+    const appName = encodeURIComponent(input.appName);
+    const sessionId = encodeURIComponent(input.sessionId);
+    return `${base}/creators/${creator}/apps/${typeSlug}/${appName}/upload-check/${sessionId}`;
+}

package/dist/apps/index.d.ts

@@ -1,8 +1,10 @@
 import type { ApiClient } from '@playdrop/api-client';
+import type { UserResponse } from '@playdrop/types';
 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;
@@ -13,6 +15,15 @@ export type AppPipelineOptions = {
     skipReview?: boolean;
     clearTags?: boolean;
     creatorUsername?: string;
+    apiBase?: string;
+    webBase?: string | null;
+    token?: string | null;
+    user?: UserResponse | null;
+    runLocalLaunchCheck?: boolean;
+    runStagedUploadLaunchCheck?: boolean;
+    launchCheckTimeoutMs?: number;
+    ensureRegisteredAppShell?: 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.runFormatScript = exports.uploadApp = exports.buildApp = exports.validateAppTask = exports.collectAppValidationWarnings = void 0;
+exports.runUploadedHostedLaunchCheck = exports.runLocalHostedLaunchCheck = exports.formatHostedLaunchCheckFailure = 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,10 +10,50 @@ 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");
 async function runAppPipeline(client, task, options) {
     await (0, validate_1.validateAppTask)(task);
     // External apps don't need to be built - they're hosted elsewhere
     const isExternal = task.hostingMode === 'EXTERNAL' || !!task.externalUrl;
+    const requiresRegisteredShell = !isExternal && task.authMode === 'REQUIRED';
+    if (requiresRegisteredShell && options?.ensureRegisteredAppShell) {
+        const creatorUsername = typeof options.creatorUsername === 'string' ? options.creatorUsername.trim() : '';
+        if (!creatorUsername) {
+            throw new Error(`Missing creator username for required hosted app registration of "${task.name}".`);
+        }
+        await (0, registration_1.ensureRegisteredHostedAppShell)({
+            client,
+            creatorUsername,
+            task,
+        });
+    }
+    if (!isExternal && options?.runLocalLaunchCheck) {
+        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}".`);
+        }
+        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}".`);
+        }
+        const launchCheck = await (0, launchCheck_1.runLocalHostedLaunchCheck)({
+            client,
+            apiBase,
+            webBase: options.webBase,
+            creatorUsername,
+            task,
+            timeoutMs: options.launchCheckTimeoutMs,
+            token: options.token ?? null,
+            currentUser: options.user ?? null,
+        });
+        if (launchCheck.status !== 'PASSED') {
+            throw new Error((0, launchCheck_1.formatHostedLaunchCheckFailure)(task.name, launchCheck, 'local'));
+        }
+    }
     const artifacts = isExternal ? null : await (0, build_1.buildApp)(task);
     const warnings = (0, validate_1.collectAppValidationWarnings)(task, isExternal ? 'source' : 'bundle');
     const uploadOptions = {
@@ -21,6 +61,10 @@ async function runAppPipeline(client, task, options) {
         skipReview: options?.skipReview,
         clearTags: options?.clearTags,
         creatorUsername: options?.creatorUsername,
+        token: options?.token,
+        user: options?.user ?? null,
+        runStagedUploadLaunchCheck: options?.runStagedUploadLaunchCheck,
+        launchCheckTimeoutMs: options?.launchCheckTimeoutMs,
     };
     const upload = await (0, upload_1.uploadApp)(client, task, artifacts, uploadOptions);
     return { artifacts, upload, warnings };

package/dist/apps/launchCheck.d.ts

@@ -0,0 +1,30 @@
+import type { ApiClient } from '@playdrop/api-client';
+import type { UserResponse } from '@playdrop/types';
+import type { AppTask } from '../catalogue';
+export type HostedLaunchCheckResult = {
+    status: 'PASSED' | 'FAILED';
+    errorCode: string | null;
+    message: string | null;
+    checkedAt: string;
+    artifactFingerprint: string | null;
+};
+export declare function formatHostedLaunchCheckFailure(taskName: string, result: HostedLaunchCheckResult, scope?: 'local' | 'staged'): string;
+export declare function runLocalHostedLaunchCheck(input: {
+    client: ApiClient;
+    apiBase: string;
+    webBase: string | null | undefined;
+    creatorUsername: string;
+    task: AppTask;
+    timeoutMs?: number;
+    token?: string | null;
+    currentUser?: UserResponse | null;
+}): Promise<HostedLaunchCheckResult>;
+export declare function runUploadedHostedLaunchCheck(input: {
+    client: ApiClient;
+    creatorUsername: string;
+    task: AppTask;
+    sessionId: string;
+    timeoutMs?: number;
+    token?: string | null;
+    currentUser?: UserResponse | null;
+}): Promise<HostedLaunchCheckResult>;

package/dist/apps/launchCheck.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatHostedLaunchCheckFailure = formatHostedLaunchCheckFailure;
+exports.runLocalHostedLaunchCheck = runLocalHostedLaunchCheck;
+exports.runUploadedHostedLaunchCheck = runUploadedHostedLaunchCheck;
+const appUrls_1 = require("../appUrls");
+const captureRuntime_1 = require("../captureRuntime");
+const devShared_1 = require("../commands/devShared");
+const dev_1 = require("../commands/dev");
+const devAuth_1 = require("../devAuth");
+const devServer_1 = require("../commands/devServer");
+const devRuntimeAssets_1 = require("../commands/devRuntimeAssets");
+const registration_1 = require("./registration");
+const DEFAULT_HOSTED_LAUNCH_TIMEOUT_MS = 15000;
+const POST_READY_SETTLE_MS = 750;
+function normalizeLaunchCheckMessage(message) {
+    const normalized = typeof message === 'string' ? message.trim() : '';
+    return normalized || 'Hosted app failed to launch.';
+}
+function buildPassedLaunchCheckResult(artifactFingerprint) {
+    return {
+        status: 'PASSED',
+        errorCode: null,
+        message: null,
+        checkedAt: new Date().toISOString(),
+        artifactFingerprint,
+    };
+}
+function buildFailedLaunchCheckResult(errorCode, message, artifactFingerprint) {
+    return {
+        status: 'FAILED',
+        errorCode,
+        message,
+        checkedAt: new Date().toISOString(),
+        artifactFingerprint,
+    };
+}
+function formatHostedLaunchCheckFailure(taskName, result, scope = 'local') {
+    const scopeLabel = scope === 'staged' ? 'staged upload preview' : 'local hosted preview';
+    const errorCode = result.errorCode?.trim() || 'startup_failure';
+    const message = normalizeLaunchCheckMessage(result.message);
+    return `hosted_launch_check_failed: ${taskName} failed the ${scopeLabel} launch-check (${errorCode}). ${message}`;
+}
+function normalizeLaunchCheckFailure(error, artifactFingerprint) {
+    const rawMessage = error instanceof Error ? error.message : String(error);
+    const message = normalizeLaunchCheckMessage(rawMessage);
+    if (/errorCode=missing_init\b/i.test(message) || /hosted_app_missing_client_init:/i.test(message)) {
+        return buildFailedLaunchCheckResult('missing_init', message, artifactFingerprint);
+    }
+    if (/errorCode=missing_ready\b/i.test(message) || /hosted_app_missing_ready:/i.test(message)) {
+        return buildFailedLaunchCheckResult('missing_ready', message, artifactFingerprint);
+    }
+    if (/errorCode=sdk_mismatch\b/i.test(message) || /hosted_app_sdk_version_mismatch:/i.test(message)) {
+        return buildFailedLaunchCheckResult('sdk_mismatch', message, artifactFingerprint);
+    }
+    return buildFailedLaunchCheckResult('startup_failure', message, artifactFingerprint);
+}
+function shouldRethrowHostedLaunchCheckError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /Failed to launch Playwright Chromium/i.test(message) || /Required setup:/i.test(message);
+}
+function buildRegistrationRequiredLaunchCheckFailure(taskName) {
+    return buildFailedLaunchCheckResult('app_registration_required_for_auth_validation', `Auth-required hosted app "${taskName}" must be registered on PlayDrop before viewer launch validation can run. Run "playdrop project create app ${taskName}" and try again.`, null);
+}
+function appendLaunchCheckParams(targetUrl, devAuth) {
+    const withAuth = (0, devAuth_1.applyHostedDevAuthSelectionToUrl)(targetUrl, {
+        devAuth,
+        player: null,
+    });
+    const nextUrl = new URL(withAuth);
+    nextUrl.searchParams.set('launchCheck', '1');
+    return nextUrl.toString();
+}
+async function runHostedLaunchCheckWithCapture(options) {
+    const expectedHostedLaunchState = options.expectedHostedLaunchState ?? 'ready';
+    try {
+        const result = await (0, captureRuntime_1.runCapture)({
+            targetUrl: options.targetUrl,
+            expectedUrl: options.targetUrl,
+            timeoutMs: options.timeoutMs ?? DEFAULT_HOSTED_LAUNCH_TIMEOUT_MS,
+            settleAfterReadyMs: POST_READY_SETTLE_MS,
+            minimumLogLevel: 'warn',
+            enableCaptureBridge: true,
+            requireHostedLaunchReady: true,
+            expectedHostedLaunchState,
+            token: options.token ?? null,
+            user: options.user ?? null,
+            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);
+        }
+        if (result.hostedLaunchState?.state !== expectedHostedLaunchState) {
+            return buildFailedLaunchCheckResult('startup_failure', expectedHostedLaunchState === 'login_required'
+                ? 'Hosted app did not stop at the PlayDrop sign-in gate.'
+                : 'Hosted app never reported the ready state.', options.artifactFingerprint ?? null);
+        }
+        return buildPassedLaunchCheckResult(options.artifactFingerprint ?? null);
+    }
+    catch (error) {
+        if (shouldRethrowHostedLaunchCheckError(error)) {
+            throw error;
+        }
+        return normalizeLaunchCheckFailure(error, options.artifactFingerprint ?? null);
+    }
+}
+async function startOrReuseMountedDevRuntime(input) {
+    const appTypeSlug = (0, appUrls_1.getAppTypeSlug)(input.task.type ?? 'GAME');
+    const runtimeAssetManifest = input.task.hostingMode === 'EXTERNAL' || input.task.externalUrl
+        ? (0, devRuntimeAssets_1.createEmptyDevRuntimeAssetManifest)()
+        : await (0, devRuntimeAssets_1.buildDevRuntimeAssetManifest)({
+            client: input.client,
+            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)}/`,
+        });
+    const serverAlreadyRunning = await (0, devServer_1.isDevServerAvailable)({
+        creatorUsername: input.creatorUsername,
+        appType: appTypeSlug,
+        appName: input.task.name,
+        port: devServer_1.DEV_ROUTER_PORT,
+    }, 750);
+    if (serverAlreadyRunning) {
+        await (0, devServer_1.updateMountedDevRuntimeAssetManifest)({
+            creatorUsername: input.creatorUsername,
+            appName: input.task.name,
+            runtimeAssetManifest,
+            port: devServer_1.DEV_ROUTER_PORT,
+        });
+        return { handle: null, runtimeAssetManifest };
+    }
+    try {
+        const handle = await (0, devServer_1.startDevServer)({
+            appName: input.task.name,
+            appType: appTypeSlug,
+            creatorUsername: input.creatorUsername,
+            htmlPath: input.task.filePath,
+            port: devServer_1.DEV_ROUTER_PORT,
+            projectInfo: (0, devShared_1.findProjectInfo)(input.task.filePath),
+            runtimeAssetManifest,
+        });
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        return { handle, runtimeAssetManifest };
+    }
+    catch (error) {
+        const formatted = (0, dev_1.formatDevRuntimeAssetManifestFailure)(error);
+        const mountConflict = (0, devServer_1.parseMountConflictError)(error instanceof Error ? error.message : '');
+        if (mountConflict) {
+            throw new Error(`A different dev session already owns ${mountConflict.ref}. Active owner pid: ${mountConflict.ownerPid}.`);
+        }
+        throw new Error(formatted.message);
+    }
+}
+async function runLocalHostedLaunchCheck(input) {
+    let mountedRuntime = null;
+    try {
+        mountedRuntime = await startOrReuseMountedDevRuntime({
+            client: input.client,
+            apiBase: input.apiBase,
+            creatorUsername: input.creatorUsername,
+            task: input.task,
+        });
+        const authMode = mountedRuntime.runtimeAssetManifest.response.localAppMetadata.authMode;
+        if (authMode === 'REQUIRED') {
+            const registeredApp = await (0, registration_1.fetchRegisteredAppShell)(input.client, input.creatorUsername, input.task.name);
+            if (!registeredApp?.id) {
+                return buildRegistrationRequiredLaunchCheckFailure(input.task.name);
+            }
+            const anonymousGateResult = await runHostedLaunchCheckWithCapture({
+                targetUrl: (0, appUrls_1.buildPlatformDevUrl)(input.webBase, {
+                    creatorUsername: input.creatorUsername,
+                    appName: input.task.name,
+                    appType: input.task.type ?? 'GAME',
+                    devAuth: 'anonymous',
+                    launchCheck: true,
+                }),
+                timeoutMs: input.timeoutMs,
+                expectedHostedLaunchState: 'login_required',
+            });
+            if (anonymousGateResult.status !== 'PASSED') {
+                return anonymousGateResult;
+            }
+            return await runHostedLaunchCheckWithCapture({
+                targetUrl: (0, appUrls_1.buildPlatformDevUrl)(input.webBase, {
+                    creatorUsername: input.creatorUsername,
+                    appName: input.task.name,
+                    appType: input.task.type ?? 'GAME',
+                    devAuth: 'viewer',
+                    launchCheck: true,
+                }),
+                timeoutMs: input.timeoutMs,
+                expectedHostedLaunchState: 'ready',
+                token: input.token ?? null,
+                user: input.currentUser ?? null,
+                savedSessionBootstrap: true,
+            });
+        }
+        return await runHostedLaunchCheckWithCapture({
+            targetUrl: (0, appUrls_1.buildPlatformDevUrl)(input.webBase, {
+                creatorUsername: input.creatorUsername,
+                appName: input.task.name,
+                appType: input.task.type ?? 'GAME',
+                devAuth: 'anonymous',
+                launchCheck: true,
+            }),
+            timeoutMs: input.timeoutMs,
+        });
+    }
+    finally {
+        if (mountedRuntime?.handle) {
+            await mountedRuntime.handle.close().catch(() => { });
+        }
+    }
+}
+async function runUploadedHostedLaunchCheck(input) {
+    const preview = await input.client.fetchAppUploadLaunchCheckPreview(input.creatorUsername, input.task.name, input.sessionId);
+    const authMode = preview.localAppMetadata.authMode;
+    let result;
+    if (authMode === 'REQUIRED') {
+        if (!preview.app?.id) {
+            result = buildRegistrationRequiredLaunchCheckFailure(input.task.name);
+        }
+        else {
+            const anonymousGateResult = await runHostedLaunchCheckWithCapture({
+                targetUrl: appendLaunchCheckParams(preview.launchUrl, 'anonymous'),
+                artifactFingerprint: preview.session.manifestHash,
+                timeoutMs: input.timeoutMs,
+                expectedHostedLaunchState: 'login_required',
+            });
+            if (anonymousGateResult.status !== 'PASSED') {
+                result = anonymousGateResult;
+            }
+            else {
+                result = await runHostedLaunchCheckWithCapture({
+                    targetUrl: appendLaunchCheckParams(preview.launchUrl, 'viewer'),
+                    artifactFingerprint: preview.session.manifestHash,
+                    timeoutMs: input.timeoutMs,
+                    expectedHostedLaunchState: 'ready',
+                    token: input.token ?? null,
+                    user: input.currentUser ?? null,
+                    savedSessionBootstrap: true,
+                });
+            }
+        }
+    }
+    else {
+        result = await runHostedLaunchCheckWithCapture({
+            targetUrl: appendLaunchCheckParams(preview.launchUrl, 'anonymous'),
+            artifactFingerprint: preview.session.manifestHash,
+            timeoutMs: input.timeoutMs,
+            expectedHostedLaunchState: 'ready',
+        });
+    }
+    const recorded = await input.client.recordAppUploadLaunchCheck(input.creatorUsername, input.task.name, input.sessionId, {
+        status: result.status,
+        artifactFingerprint: preview.session.manifestHash,
+        errorCode: result.errorCode,
+        message: result.message,
+    });
+    const recordedLaunchCheck = recorded.session.launchCheck;
+    if (recordedLaunchCheck.status !== 'PASSED' && recordedLaunchCheck.status !== 'FAILED') {
+        return buildFailedLaunchCheckResult('startup_failure', 'Upload launch-check was not recorded on the staged session.', preview.session.manifestHash);
+    }
+    return {
+        status: recordedLaunchCheck.status,
+        errorCode: recordedLaunchCheck.errorCode,
+        message: recordedLaunchCheck.message,
+        checkedAt: recordedLaunchCheck.checkedAt ?? new Date().toISOString(),
+        artifactFingerprint: recordedLaunchCheck.artifactFingerprint,
+    };
+}

package/dist/apps/registration.d.ts

@@ -0,0 +1,12 @@
+import type { ApiClient } from '@playdrop/api-client';
+import { type AppResponse } from '@playdrop/types';
+import type { AppTask } from '../catalogue';
+export declare function fetchRegisteredAppShell(client: ApiClient, creatorUsername: string, appName: string): Promise<AppResponse | null>;
+export declare function ensureRegisteredHostedAppShell(input: {
+    client: ApiClient;
+    creatorUsername: string;
+    task: AppTask;
+}): Promise<{
+    app: AppResponse;
+    created: boolean;
+}>;

package/dist/apps/registration.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchRegisteredAppShell = fetchRegisteredAppShell;
+exports.ensureRegisteredHostedAppShell = ensureRegisteredHostedAppShell;
+const types_1 = require("@playdrop/types");
+function resolveRegistrationDisplayName(task) {
+    const displayName = typeof task.displayName === 'string' ? task.displayName.trim() : '';
+    return displayName || task.name;
+}
+async function fetchRegisteredAppShell(client, creatorUsername, appName) {
+    try {
+        const response = await client.fetchAppBySlug(creatorUsername, appName);
+        return response?.app ?? null;
+    }
+    catch (error) {
+        if (error instanceof types_1.ApiError && error.status === 404) {
+            return null;
+        }
+        throw error;
+    }
+}
+async function ensureRegisteredHostedAppShell(input) {
+    let app = await fetchRegisteredAppShell(input.client, input.creatorUsername, input.task.name);
+    let created = false;
+    const displayName = resolveRegistrationDisplayName(input.task);
+    if (!app) {
+        const createdResponse = await input.client.createApp(input.creatorUsername, {
+            name: input.task.name,
+            displayName,
+        });
+        app = createdResponse.app;
+        created = true;
+    }
+    if (!app) {
+        throw new Error(`App ${input.creatorUsername}/${input.task.name} could not be registered on PlayDrop.`);
+    }
+    const updateRequest = {};
+    if (app.displayName !== displayName) {
+        updateRequest.displayName = displayName;
+    }
+    if (input.task.type && app.type !== input.task.type) {
+        updateRequest.type = input.task.type;
+    }
+    if (Object.keys(updateRequest).length > 0) {
+        const updated = await input.client.updateApp(input.creatorUsername, input.task.name, updateRequest);
+        app = updated.app;
+    }
+    return { app, created };
+}

package/dist/apps/upload.d.ts

@@ -1,4 +1,5 @@
 import type { ApiClient } from '@playdrop/api-client';
+import type { UserResponse } from '@playdrop/types';
 import type { AppTask } from '../catalogue';
 import type { AppBuildArtifacts } from './build';
 export type AppUploadResult = {
@@ -17,5 +18,9 @@ export type AppUploadOptions = {
     skipReview?: boolean;
     clearTags?: boolean;
     creatorUsername?: string;
+    token?: string | null;
+    user?: UserResponse | null;
+    runStagedUploadLaunchCheck?: boolean;
+    launchCheckTimeoutMs?: number;
 };
 export declare function uploadApp(client: ApiClient, task: AppTask, artifacts: AppBuildArtifacts | null, options?: AppUploadOptions): Promise<AppUploadResult>;

package/dist/apps/upload.js

@@ -7,6 +7,7 @@ const config_1 = require("@playdrop/config");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const http_1 = require("../http");
+const launchCheck_1 = require("./launchCheck");
 const EXTENSION_TO_MIME = {
     '.png': 'image/png',
     '.jpg': 'image/jpeg',
@@ -355,6 +356,22 @@ async function uploadAppVersion(client, task, artifacts, options) {
                     })),
                 });
             }
+            if (task.hostingMode !== 'EXTERNAL'
+                && !task.externalUrl
+                && options?.runStagedUploadLaunchCheck) {
+                const launchCheck = await (0, launchCheck_1.runUploadedHostedLaunchCheck)({
+                    client,
+                    creatorUsername,
+                    task,
+                    sessionId,
+                    timeoutMs: options.launchCheckTimeoutMs,
+                    token: options?.token ?? null,
+                    currentUser: options?.user ?? null,
+                });
+                if (launchCheck.status !== 'PASSED') {
+                    throw new Error((0, launchCheck_1.formatHostedLaunchCheckFailure)(task.name, launchCheck, 'staged'));
+                }
+            }
         }
         const finalized = initialized.status === 'finalized'
             ? initialized.finalized