@playdrop/playdrop-cli 0.6.5 → 0.6.7

package/dist/apps/validate.js

@@ -50,6 +50,9 @@ const SDK_INIT_PATTERNS = [
     /\bplaydrop\s*\.\s*init\s*\(/g,
     /\bsdk\s*\.\s*initialize\s*\(/g,
 ];
+const SDK_READY_PATTERNS = [
+    /\bsdk\s*\??\.\s*host\s*\??\.\s*ready\s*\(/g,
+];
 const LOCAL_HTML_SCRIPT_PATTERN = /<script\b[^>]*\bsrc\s*=\s*["']([^"']+)["'][^>]*>/gi;
 const LOCAL_IMPORT_PATTERNS = [
     /(?:import|export)\s+(?:[^'"`]*?\s+from\s+)?["']([^"']+)["']/g,
@@ -124,6 +127,33 @@ function scanForLegacySdkSymbols(task) {
 function stripSpecifierDecorators(specifier) {
     return specifier.split(/[?#]/, 1)[0]?.trim() ?? '';
 }
+function escapeRegexLiteral(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function detectSdkInitInSource(source) {
+    if (SDK_INIT_PATTERNS.some((pattern) => {
+        pattern.lastIndex = 0;
+        return pattern.test(source);
+    })) {
+        return true;
+    }
+    const playdropAliases = new Set();
+    const aliasAssignmentPattern = /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*[^;\n]*\bplaydrop\b[^;\n]*/g;
+    let aliasMatch;
+    while ((aliasMatch = aliasAssignmentPattern.exec(source)) !== null) {
+        const alias = aliasMatch[1]?.trim();
+        if (alias) {
+            playdropAliases.add(alias);
+        }
+    }
+    for (const alias of playdropAliases) {
+        const aliasInitPattern = new RegExp(`\\b${escapeRegexLiteral(alias)}\\s*(?:\\.\\s*|\\?\\.\\s*)init\\s*\\(`, 'g');
+        if (aliasInitPattern.test(source)) {
+            return true;
+        }
+    }
+    return false;
+}
 function safeReadFile(filePath) {
     try {
         return (0, node_fs_1.readFileSync)(filePath, 'utf8');
@@ -378,9 +408,10 @@ function collectSdkDetectionFiles(task, mode) {
 function detectSdkUsage(task, mode) {
     let hasSdkReference = false;
     let hasSdkInit = false;
+    let hasSdkReady = false;
     const files = collectSdkDetectionFiles(task, mode);
     for (const filePath of files) {
-        if (hasSdkReference && hasSdkInit) {
+        if (hasSdkReference && hasSdkInit && hasSdkReady) {
             break;
         }
         const source = safeReadFile(filePath);
@@ -394,13 +425,16 @@ function detectSdkUsage(task, mode) {
             });
         }
         if (!hasSdkInit) {
-            hasSdkInit = SDK_INIT_PATTERNS.some((pattern) => {
+            hasSdkInit = detectSdkInitInSource(source);
+        }
+        if (!hasSdkReady) {
+            hasSdkReady = SDK_READY_PATTERNS.some((pattern) => {
                 pattern.lastIndex = 0;
                 return pattern.test(source);
             });
         }
     }
-    return { hasSdkReference, hasSdkInit };
+    return { hasSdkReference, hasSdkInit, hasSdkReady };
 }
 function collectOutdatedSdkVersionWarnings(task) {
     if (!task.packageJsonPath) {
@@ -451,6 +485,7 @@ function collectAppValidationWarnings(task, mode = 'source') {
         : primaryDetection;
     const hasSdkReference = primaryDetection.hasSdkReference || sourceDetection.hasSdkReference;
     const hasSdkInit = primaryDetection.hasSdkInit || sourceDetection.hasSdkInit;
+    const hasSdkReady = primaryDetection.hasSdkReady || sourceDetection.hasSdkReady;
     const warnings = [];
     if (!hasSdkReference) {
         warnings.push(`[apps][validate] Could not detect the Playdrop SDK loader or @playdrop/sdk import for ${task.name}. We could not find https://assets.playdrop.ai/sdk/playdrop.js or @playdrop/sdk in the app files, so it might not work once uploaded.`);
@@ -458,6 +493,9 @@ function collectAppValidationWarnings(task, mode = 'source') {
     if (!hasSdkInit) {
         warnings.push(`[apps][validate] Could not detect Playdrop SDK initialization for ${task.name}. We could not find playdrop.init() in the app files, so it might not work once uploaded.`);
     }
+    if (!hasSdkReady) {
+        warnings.push(`[apps][validate] Could not detect Playdrop host readiness for ${task.name}. We could not find sdk.host.ready() in the app files, so the app will fail to start correctly inside Playdrop.`);
+    }
     return [...warnings, ...collectOutdatedSdkVersionWarnings(task)];
 }
 async function runFormatScript(task) {

package/dist/captureRuntime.d.ts

@@ -12,6 +12,7 @@ export type RunCaptureOptions = {
     targetUrl: string;
     expectedUrl?: string | null;
     timeoutMs: number;
+    settleAfterReadyMs?: number;
     minimumLogLevel: CaptureLogLevel;
     screenshotPath?: string | null;
     logPath?: string | null;
@@ -21,10 +22,27 @@ export type RunCaptureOptions = {
     login?: LoginOptions | null;
     savedSessionBootstrap?: boolean;
     enableCaptureBridge?: boolean;
+    requireHostedLaunchReady?: boolean;
+    expectedHostedLaunchState?: HostedLaunchExpectedState;
+};
+export type HostedLaunchExpectedState = 'ready' | 'login_required' | 'controller_required' | 'surface_unsupported';
+export type CaptureHostedLaunchState = {
+    state: 'ready';
+} | {
+    state: 'login_required';
+} | {
+    state: 'controller_required';
+} | {
+    state: 'surface_unsupported';
+} | {
+    state: 'error';
+    errorCode: string | null;
+    message: string | null;
 };
 export type CaptureRunResult = {
     errorCount: number;
     finalUrl: string;
+    hostedLaunchState: CaptureHostedLaunchState | null;
 };
 export declare function resolveCaptureLogLevel(value: string | undefined): CaptureLogLevel;
 export declare function validateCaptureTimeout(value: number | undefined): number;

package/dist/captureRuntime.js

@@ -9,7 +9,6 @@ const node_path_1 = require("node:path");
 const playwright_1 = require("./playwright");
 const sessionCookie_1 = require("./sessionCookie");
 const FRAME_SELECTOR = 'iframe[title="Game"]';
-const LOGIN_BUTTON_NAME = 'Sign in to play';
 exports.CAPTURE_LOG_LEVEL_VALUES = ['debug', 'info', 'warn', 'error'];
 exports.MAX_CAPTURE_TIMEOUT_SECONDS = 600;
 function formatConsoleValue(value) {
@@ -80,6 +79,68 @@ function normalizeComparableUrl(rawUrl) {
     const pathname = parsed.pathname.replace(/\/+$/, '') || '/';
     return `${parsed.origin}${pathname}`;
 }
+function normalizeHostedLaunchStatePayload(payload) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        return null;
+    }
+    const state = typeof payload.state === 'string'
+        ? payload.state.trim().toLowerCase()
+        : '';
+    if (state === 'ready') {
+        return { state: 'ready' };
+    }
+    if (state === 'login_required') {
+        return { state: 'login_required' };
+    }
+    if (state === 'controller_required') {
+        return { state: 'controller_required' };
+    }
+    if (state === 'surface_unsupported') {
+        return { state: 'surface_unsupported' };
+    }
+    if (state !== 'error') {
+        return null;
+    }
+    const errorCode = typeof payload.errorCode === 'string'
+        ? payload.errorCode.trim() || null
+        : null;
+    const message = typeof payload.message === 'string'
+        ? payload.message.trim() || null
+        : null;
+    return {
+        state: 'error',
+        errorCode,
+        message,
+    };
+}
+function formatHostedLaunchError(state) {
+    const parts = ['Hosted app failed to launch.'];
+    if (state.errorCode) {
+        parts.push(`errorCode=${state.errorCode}.`);
+    }
+    if (state.message) {
+        parts.push(state.message);
+    }
+    return parts.join(' ');
+}
+function formatHostedLaunchStateMismatch(actualState, expectedState) {
+    if (expectedState === "login_required") {
+        return `Hosted app reported ${actualState} instead of login_required.`;
+    }
+    if (expectedState === "controller_required") {
+        return `Hosted app reported ${actualState} instead of controller_required.`;
+    }
+    if (expectedState === "surface_unsupported") {
+        return `Hosted app reported ${actualState} instead of surface_unsupported.`;
+    }
+    return `Hosted app reported ${actualState} instead of ready.`;
+}
+function shouldSettleHostedLaunchWaiter(state, expectedState) {
+    if (state.state === "error" || !expectedState) {
+        return true;
+    }
+    return state.state === expectedState;
+}
 async function writeLogFile(logPath, lines) {
     if (!logPath || logPath.trim().length === 0) {
         return;
@@ -113,11 +174,15 @@ async function runCapture(options) {
     const errors = [];
     const outputLines = [];
     const expectedUrl = options.expectedUrl ? normalizeComparableUrl(options.expectedUrl) : null;
+    const expectedHostedLaunchState = options.requireHostedLaunchReady
+        ? options.expectedHostedLaunchState ?? 'ready'
+        : null;
     const hasExplicitLogin = Boolean(options.login?.username);
     const shouldBootstrapSavedSession = options.savedSessionBootstrap !== false && !hasExplicitLogin;
     const bootstrapToken = shouldBootstrapSavedSession ? options.token?.trim() || null : null;
     const bootstrapUser = shouldBootstrapSavedSession ? options.user ?? null : null;
     let finalUrl = options.targetUrl;
+    let hostedLaunchState = null;
     const record = (level, message) => {
         const line = `[capture][${level}] ${message}`;
         outputLines.push(line);
@@ -142,6 +207,24 @@ async function runCapture(options) {
     try {
         await (0, playwright_1.withChromiumPage)(async ({ context, page }) => {
             const targetOrigin = new URL(options.targetUrl).origin;
+            let hostedLaunchWaiterSettled = false;
+            let resolveHostedLaunchWaiter = null;
+            const hostedLaunchWaiter = options.requireHostedLaunchReady
+                ? new Promise((resolve) => {
+                    resolveHostedLaunchWaiter = resolve;
+                })
+                : null;
+            const settleHostedLaunchWaiter = (state) => {
+                hostedLaunchState = state;
+                if (!hostedLaunchWaiter || hostedLaunchWaiterSettled) {
+                    return;
+                }
+                if (!shouldSettleHostedLaunchWaiter(state, expectedHostedLaunchState)) {
+                    return;
+                }
+                hostedLaunchWaiterSettled = true;
+                resolveHostedLaunchWaiter?.(state);
+            };
             if (bootstrapToken) {
                 await context.addCookies((0, sessionCookie_1.buildCaptureAccessTokenCookies)(options.targetUrl, bootstrapToken));
             }
@@ -173,6 +256,12 @@ async function runCapture(options) {
             }
             if (options.enableCaptureBridge) {
                 await page.exposeBinding('__playdropCaptureLog', async (_source, type, payload) => {
+                    if (type === 'hosted-launch-state') {
+                        const normalizedHostedState = normalizeHostedLaunchStatePayload(payload);
+                        if (normalizedHostedState) {
+                            settleHostedLaunchWaiter(normalizedHostedState);
+                        }
+                    }
                     const normalized = typeof type === 'string' ? type.toLowerCase() : 'info';
                     const level = normalized === 'error' || normalized === 'fatal'
                         ? 'error'
@@ -216,7 +305,11 @@ async function runCapture(options) {
                     });
                     const bridgeWindow = window;
                     bridgeWindow.playdrop = bridgeWindow.playdrop || {};
+                    bridgeWindow.__playdropCaptureHostedLaunchState = null;
                     const bridge = (type, payload) => {
+                        if (type === 'hosted-launch-state') {
+                            bridgeWindow.__playdropCaptureHostedLaunchState = payload;
+                        }
                         try {
                             const binding = bridgeWindow.__playdropCaptureLog;
                             if (typeof binding === 'function') {
@@ -342,22 +435,20 @@ async function runCapture(options) {
                 recordError(`[navigation] ${response.status()} ${response.statusText()} ${options.targetUrl}`);
             }
             const readinessTimeoutMs = Math.min(Math.max(options.timeoutMs, 1000), 30000);
-            const readinessHandle = await page.waitForFunction(({ frameSelector, loginButtonName }) => {
+            const readinessHandle = await page.waitForFunction(({ frameSelector, waitForHostedLaunchState }) => {
                 const frame = document.querySelector(frameSelector);
                 if (frame) {
                     return 'frame';
                 }
-                const buttons = Array.from(document.querySelectorAll('button'));
-                const loginButton = buttons.find((button) => button.textContent?.trim() === loginButtonName);
-                if (loginButton) {
-                    return 'login';
+                if (waitForHostedLaunchState) {
+                    const state = window.__playdropCaptureHostedLaunchState;
+                    if (state && typeof state.state === 'string' && state.state.trim().length > 0) {
+                        return `hosted:${state.state.trim().toLowerCase()}`;
+                    }
                 }
                 return null;
-            }, { frameSelector: FRAME_SELECTOR, loginButtonName: LOGIN_BUTTON_NAME }, { timeout: readinessTimeoutMs });
-            const readiness = await readinessHandle.jsonValue();
-            if (readiness !== 'frame') {
-                throw new Error('The Playdrop app frame did not load. The page is still showing the login wall.');
-            }
+            }, { frameSelector: FRAME_SELECTOR, waitForHostedLaunchState: Boolean(expectedHostedLaunchState) }, { timeout: readinessTimeoutMs });
+            await readinessHandle.jsonValue();
             const assertPageState = async () => {
                 const currentUrl = page.url();
                 if (!currentUrl) {
@@ -371,22 +462,46 @@ async function runCapture(options) {
                 if (finalPathname.startsWith('/login')) {
                     throw new Error(`Capture landed on the login page (${currentUrl}).`);
                 }
-                const loginVisible = await page
-                    .getByRole('button', { name: LOGIN_BUTTON_NAME })
-                    .first()
-                    .isVisible()
-                    .catch(() => false);
-                if (loginVisible) {
-                    throw new Error('The Playdrop login wall is still visible.');
-                }
                 const frameCount = await page.locator(FRAME_SELECTOR).count();
-                if (frameCount === 0) {
+                if ((expectedHostedLaunchState ?? 'ready') === 'ready' && frameCount === 0) {
                     throw new Error('The Playdrop app frame never appeared.');
                 }
+                if (expectedHostedLaunchState === 'login_required' && frameCount > 0) {
+                    throw new Error('The Playdrop auth gate booted the app frame unexpectedly.');
+                }
+                if (expectedHostedLaunchState === 'controller_required' && frameCount > 0) {
+                    throw new Error('The Playdrop controller gate booted the app frame unexpectedly.');
+                }
+                if (expectedHostedLaunchState === 'surface_unsupported' && frameCount > 0) {
+                    throw new Error('The Playdrop surface gate booted the app frame unexpectedly.');
+                }
                 return currentUrl;
             };
+            if (hostedLaunchWaiter) {
+                const launchState = await Promise.race([
+                    hostedLaunchWaiter,
+                    page.waitForTimeout(options.timeoutMs).then(() => {
+                        if (hostedLaunchState && expectedHostedLaunchState && hostedLaunchState.state !== expectedHostedLaunchState) {
+                            throw new Error(formatHostedLaunchStateMismatch(hostedLaunchState.state, expectedHostedLaunchState));
+                        }
+                        throw new Error(expectedHostedLaunchState === 'login_required'
+                            ? 'Hosted app did not stop at the PlayDrop sign-in gate before the launch-check timeout.'
+                            : expectedHostedLaunchState === 'controller_required'
+                                ? 'Hosted app did not stop at the PlayDrop controller gate before the launch-check timeout.'
+                                : expectedHostedLaunchState === 'surface_unsupported'
+                                    ? 'Hosted app did not stop at the PlayDrop unsupported-surface gate before the launch-check timeout.'
+                                    : 'Hosted app did not reach the ready state before the launch-check timeout.');
+                    }),
+                ]);
+                if (launchState.state === 'error') {
+                    throw new Error(formatHostedLaunchError(launchState));
+                }
+                if (expectedHostedLaunchState && launchState.state !== expectedHostedLaunchState) {
+                    throw new Error(formatHostedLaunchStateMismatch(launchState.state, expectedHostedLaunchState));
+                }
+            }
             finalUrl = await assertPageState();
-            await page.waitForTimeout(options.timeoutMs);
+            await page.waitForTimeout(options.settleAfterReadyMs ?? options.timeoutMs);
             finalUrl = await assertPageState();
             if (options.screenshotPath) {
                 const targetDir = (0, node_path_1.dirname)(options.screenshotPath);
@@ -404,5 +519,6 @@ async function runCapture(options) {
     return {
         errorCount: errors.length,
         finalUrl,
+        hostedLaunchState,
     };
 }

package/dist/clientInfo.js

@@ -13,15 +13,44 @@ const path_1 = __importDefault(require("path"));
 const fs_1 = require("fs");
 const config_1 = require("@playdrop/config");
 let cachedCliPackageVersion = null;
+function assertValidCliVersion(version) {
+    if (!/^\d+\.\d+\.\d+$/.test(version)) {
+        throw new Error(`invalid_cli_package_version:${version}`);
+    }
+    return version;
+}
+function readVersionFromJson(pathname, field) {
+    try {
+        const parsed = JSON.parse((0, fs_1.readFileSync)(pathname, 'utf8'));
+        const value = typeof parsed[field] === 'string' ? parsed[field].trim() : '';
+        if (!value) {
+            return null;
+        }
+        return assertValidCliVersion(value);
+    }
+    catch {
+        return null;
+    }
+}
 function readCliPackageVersion() {
     if (cachedCliPackageVersion) {
         return cachedCliPackageVersion;
     }
+    const candidateMetaPaths = [
+        path_1.default.resolve(__dirname, '..', 'config', 'client-meta.json'),
+        path_1.default.resolve(__dirname, '..', '..', '..', 'config', 'client-meta.json'),
+    ];
+    for (const candidatePath of candidateMetaPaths) {
+        const clientMetaVersion = readVersionFromJson(candidatePath, 'version');
+        if (clientMetaVersion) {
+            cachedCliPackageVersion = clientMetaVersion;
+            return clientMetaVersion;
+        }
+    }
     const packageJsonPath = path_1.default.resolve(__dirname, '..', 'package.json');
-    const packageJson = JSON.parse((0, fs_1.readFileSync)(packageJsonPath, 'utf8'));
-    const version = typeof packageJson.version === 'string' ? packageJson.version.trim() : '';
-    if (!/^\d+\.\d+\.\d+$/.test(version)) {
-        throw new Error(`invalid_cli_package_version:${version}`);
+    const version = readVersionFromJson(packageJsonPath, 'version');
+    if (!version) {
+        throw new Error(`invalid_cli_package_version:${packageJsonPath}`);
     }
     cachedCliPackageVersion = version;
     return version;

package/dist/commands/capture.js

@@ -283,42 +283,6 @@ async function capture(targetArg, options = {}) {
             process.exitCode = 1;
             return;
         }
-        let registeredApp = null;
-        try {
-            registeredApp = await (0, devShared_1.assertAppRegistered)(client, currentUsername, appName);
-        }
-        catch (error) {
-            if (error instanceof http_1.CLIUnsupportedClientError) {
-                return;
-            }
-            if (error instanceof types_1.UnsupportedClientError) {
-                (0, http_1.handleUnsupportedError)(error, 'Capture');
-                process.exitCode = 1;
-                return;
-            }
-            if (error instanceof types_1.ApiError) {
-                if (error.status === 404) {
-                    (0, messages_1.printErrorWithHelp)(`App ${currentUsername}/${appName} is not registered on ${env}.`, [
-                        `Run "playdrop project create app ${appName}" to register the app before running capture.`,
-                        'If you expected it to exist, ensure you are logged into the correct environment.',
-                    ], { command: 'project capture' });
-                }
-                else {
-                    (0, messages_1.printErrorWithHelp)(`Failed to verify app registration (status ${error.status}).`, [
-                        'Retry in a moment.',
-                        'If the issue persists, contact the Playdrop team.',
-                    ], { command: 'project capture' });
-                }
-                process.exitCode = 1;
-                return;
-            }
-            if ((0, devShared_1.isNetworkError)(error)) {
-                (0, messages_1.printNetworkIssue)('Could not reach the Playdrop API to verify the app registration.', 'project capture');
-                process.exitCode = 1;
-                return;
-            }
-            throw error;
-        }
         const entryLabel = (0, node_path_1.relative)(process.cwd(), filePath) || filePath;
         console.log(`[capture] Preparing ${entryLabel} for ${env} (${appTypeSlug}).`);
         const serverAlreadyRunning = await (0, devServer_1.isDevServerAvailable)({
@@ -442,14 +406,61 @@ async function capture(targetArg, options = {}) {
             await new Promise(resolve => setTimeout(resolve, 1000));
         }
         const webBase = envConfig.webBase ?? 'https://www.playdrop.ai';
-        const frameUrl = (0, devAuth_1.applyHostedDevAuthSelectionToUrl)(`${webBase}/creators/${encodeURIComponent(currentUsername)}/apps/${appTypeSlug}/${encodeURIComponent(appName)}/dev`, devOptions.selection);
-        console.log(`[capture] Launching Playwright against ${frameUrl}`);
         const shouldResetBefore = devOptions.selection.devAuth === 'player'
             && (devOptions.resetMode === 'before' || devOptions.resetMode === 'before-and-after');
         const shouldResetAfter = devOptions.selection.devAuth === 'player'
             && (devOptions.resetMode === 'after' || devOptions.resetMode === 'before-and-after');
+        const requiresRegisteredApp = devOptions.selection.devAuth !== 'anonymous' || shouldResetBefore || shouldResetAfter;
+        let registeredApp = null;
+        if (requiresRegisteredApp) {
+            try {
+                registeredApp = await (0, devShared_1.assertAppRegistered)(client, currentUsername, appName);
+            }
+            catch (error) {
+                if (error instanceof http_1.CLIUnsupportedClientError) {
+                    return;
+                }
+                if (error instanceof types_1.UnsupportedClientError) {
+                    (0, http_1.handleUnsupportedError)(error, 'Capture');
+                    process.exitCode = 1;
+                    return;
+                }
+                if (error instanceof types_1.ApiError) {
+                    if (error.status === 404) {
+                        (0, messages_1.printErrorWithHelp)(`App ${currentUsername}/${appName} is not registered on ${env}.`, [
+                            `Run "playdrop project create app ${appName}" to register the app before using viewer or player capture.`,
+                            'Use anonymous capture for local launch validation before upload.',
+                        ], { command: 'project capture' });
+                    }
+                    else {
+                        (0, messages_1.printErrorWithHelp)(`Failed to verify app registration (status ${error.status}).`, [
+                            'Retry in a moment.',
+                            'If the issue persists, contact the Playdrop team.',
+                        ], { command: 'project capture' });
+                    }
+                    process.exitCode = 1;
+                    return;
+                }
+                if ((0, devShared_1.isNetworkError)(error)) {
+                    (0, messages_1.printNetworkIssue)('Could not reach the Playdrop API to verify the app registration.', 'project capture');
+                    process.exitCode = 1;
+                    return;
+                }
+                throw error;
+            }
+        }
+        const captureBaseUrl = (0, appUrls_1.buildPlatformDevUrl)(webBase, {
+            creatorUsername: currentUsername,
+            appName,
+            appType: appTypeSlug,
+            devAuth: devOptions.selection.devAuth,
+            player: devOptions.selection.player ? String(devOptions.selection.player) : null,
+            launchCheck: devOptions.selection.devAuth === 'anonymous',
+        });
+        const frameUrl = (0, devAuth_1.applyHostedDevAuthSelectionToUrl)(captureBaseUrl, devOptions.selection);
+        console.log(`[capture] Launching Playwright against ${frameUrl}`);
         const selectedPlayerSlot = devOptions.selection.player;
-        const registeredAppId = typeof registeredApp.id === 'number' ? registeredApp.id : null;
+        const registeredAppId = typeof registeredApp?.id === 'number' ? registeredApp.id : null;
         if ((shouldResetBefore || shouldResetAfter) && registeredAppId === null) {
             (0, messages_1.printErrorWithHelp)('The registered app is missing a numeric id, so test-player reset is unavailable.', [], { command: 'project capture' });
             process.exitCode = 1;
@@ -463,6 +474,7 @@ async function capture(targetArg, options = {}) {
                 targetUrl: frameUrl,
                 expectedUrl: frameUrl,
                 timeoutMs,
+                settleAfterReadyMs: timeoutMs,
                 minimumLogLevel,
                 screenshotPath,
                 contextOptions: surfaceContextOptions,
@@ -472,6 +484,7 @@ async function capture(targetArg, options = {}) {
                 } : undefined,
                 savedSessionBootstrap: false,
                 enableCaptureBridge: true,
+                requireHostedLaunchReady: true,
             });
             if (result.errorCount > 0) {
                 console.error(`[capture] Completed with ${result.errorCount} error(s) after ${timeoutSeconds} seconds.`);

package/dist/commands/devServer.js

@@ -396,15 +396,23 @@ async function startDevServer(options) {
     };
 }
 async function isDevServerAvailable(input, timeoutMs = 1000) {
+    const port = input.port ?? exports.DEV_ROUTER_PORT;
+    const health = await fetchRouterHealth(port, Math.min(timeoutMs, 400));
+    if (!health || !isCompatibleRouterHealth(health)) {
+        return false;
+    }
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), timeoutMs);
     timeout.unref?.();
     try {
-        await fetch(buildLocalDevAppUrl(input), {
+        const response = await fetch(buildLocalDevAppUrl({
+            ...input,
+            port,
+        }), {
             method: 'GET',
             signal: controller.signal,
         });
-        return true;
+        return response.ok;
     }
     catch {
         return false;

package/dist/commands/upload.js

@@ -150,18 +150,19 @@ async function fetchCurrentUserInfo(client, apiBase) {
         return {
             username: data?.user?.username ?? null,
             role: data?.user?.role ?? null,
+            user: data?.user ?? null,
         };
     }
     catch (error) {
         if (error instanceof types_1.UnsupportedClientError) {
             (0, http_1.handleUnsupportedError)(error, 'Upload');
-            return { username: null, role: null };
+            return { username: null, role: null, user: null };
         }
         if (error instanceof http_1.CLIUnsupportedClientError) {
             throw error;
         }
         if (error instanceof types_1.ApiError) {
-            return { username: null, role: null };
+            return { username: null, role: null, user: null };
         }
         if (isConnectionRefusedError(error)) {
             throw new Error(buildApiUnavailableMessage(apiBase));
@@ -282,6 +283,13 @@ async function uploadAppTask(state, task, taskCreator, options) {
         skipReview: options?.skipReview,
         clearTags: options?.clearTags,
         creatorUsername: taskCreator,
+        apiBase: state.apiBase,
+        webBase: state.portalBase,
+        token: state.token,
+        user: state.currentUser,
+        runLocalLaunchCheck: true,
+        runStagedUploadLaunchCheck: true,
+        ensureRegisteredAppShell: true,
     });
     if (!upload.versionCreated || !upload.version) {
         throw new Error(`App "${task.name}" upload did not return a created version.`);
@@ -476,7 +484,7 @@ async function flushGraphState(client, graphState, results) {
         process.exitCode = process.exitCode || 1;
     }
 }
-async function processUploadTasks(client, tasks, owner, ownerUsername, currentUserRole, warnings, webBase, options) {
+async function processUploadTasks(client, tasks, owner, ownerUsername, currentUserRole, currentUser, token, warnings, apiBase, webBase, options) {
     const portalBase = normalizePortalBase(webBase);
     const defaultCreator = normalizeCreatorUsername(ownerUsername) ?? owner;
     const results = [];
@@ -494,6 +502,9 @@ async function processUploadTasks(client, tasks, owner, ownerUsername, currentUs
         sortedTasks,
         defaultCreator,
         currentUserRole,
+        currentUser,
+        token,
+        apiBase,
         portalBase,
         uploadedAppsByName: new Map(),
         uploadedAssetsByKey: new Map(),
@@ -539,7 +550,7 @@ async function upload(pathOrName, options) {
         return;
     }
     const { client, env, envConfig } = ctx;
-    let userInfo = { username: null, role: null };
+    let userInfo = { username: null, role: null, user: null };
     try {
         userInfo = await fetchCurrentUserInfo(client, envConfig.apiBase);
     }
@@ -589,7 +600,7 @@ async function upload(pathOrName, options) {
         taxonomyEntries.forEach((entry) => pushLoggedEntry(results, entry));
     }
     if (tasks.length > 0) {
-        const uploadEntries = await processUploadTasks(client, tasks, owner, userInfo.username, userInfo.role, warnings, envConfig.webBase, options);
+        const uploadEntries = await processUploadTasks(client, tasks, owner, userInfo.username, userInfo.role, userInfo.user, ctx.token, warnings, envConfig.apiBase, envConfig.webBase, options);
         results.push(...uploadEntries);
     }
     (0, uploadLog_1.printTaskSummary)(results, warnings, { action: 'upload', environment: env });