@playdrop/playdrop-cli 0.9.5 → 0.10.0

package/dist/captureRuntime.js

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MAX_CAPTURE_TIMEOUT_SECONDS = exports.CAPTURE_LOG_LEVEL_VALUES = void 0;
 exports.resolveCaptureLogLevel = resolveCaptureLogLevel;
@@ -6,6 +9,7 @@ exports.validateCaptureTimeout = validateCaptureTimeout;
 exports.runCapture = runCapture;
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
+const sharp_1 = __importDefault(require("sharp"));
 const playwright_1 = require("./playwright");
 const sessionCookie_1 = require("./sessionCookie");
 const FRAME_SELECTOR = 'iframe[title="Game"]';
@@ -18,6 +22,11 @@ const GOOGLE_TELEMETRY_HOSTS = [
     'doubleclick.net',
 ];
 const GOOGLE_COUNTRY_SECOND_LEVEL_DOMAINS = new Set(['ac', 'co', 'com', 'edu', 'gov', 'net', 'org']);
+const CANVAS_VISUAL_SAMPLE_SIZE = 64;
+const MIN_VISIBLE_CANVAS_EDGE_PX = 48;
+const MIN_CANVAS_FOREGROUND_RATIO = 0.018;
+const MIN_CANVAS_COLOR_RANGE = 34;
+const CANVAS_BACKGROUND_DISTANCE_THRESHOLD = 28;
 function isHostOrSubdomain(hostname, domain) {
     return hostname === domain || hostname.endsWith(`.${domain}`);
 }
@@ -232,6 +241,298 @@ function shouldSettleHostedLaunchWaiter(state, expectedState) {
     }
     return state.state === expectedState;
 }
+function shouldAssertHostedVisualReadiness(input) {
+    return Boolean(input.requireHostedLaunchReady) && (input.expectedHostedLaunchState ?? 'ready') === 'ready';
+}
+function summarizeRgbaPixels(pixels, pixelCount, channels) {
+    let bgR = 0;
+    let bgG = 0;
+    let bgB = 0;
+    const edge = Math.max(1, Math.round(Math.sqrt(pixelCount)));
+    const cornerIndexes = [
+        0,
+        edge - 1,
+        edge * (edge - 1),
+        (edge * edge) - 1,
+    ].filter(index => index >= 0 && index < pixelCount);
+    for (const index of cornerIndexes) {
+        const offset = index * channels;
+        bgR += pixels[offset] ?? 0;
+        bgG += pixels[offset + 1] ?? 0;
+        bgB += pixels[offset + 2] ?? 0;
+    }
+    bgR /= cornerIndexes.length || 1;
+    bgG /= cornerIndexes.length || 1;
+    bgB /= cornerIndexes.length || 1;
+    let minLuma = 255;
+    let maxLuma = 0;
+    let foreground = 0;
+    let opaque = 0;
+    for (let index = 0; index < pixelCount; index += 1) {
+        const offset = index * channels;
+        const r = pixels[offset] ?? 0;
+        const g = pixels[offset + 1] ?? 0;
+        const b = pixels[offset + 2] ?? 0;
+        const alpha = channels >= 4 ? pixels[offset + 3] ?? 255 : 255;
+        if (alpha > 8) {
+            opaque += 1;
+        }
+        const luma = (0.2126 * r) + (0.7152 * g) + (0.0722 * b);
+        minLuma = Math.min(minLuma, luma);
+        maxLuma = Math.max(maxLuma, luma);
+        const distance = Math.hypot(r - bgR, g - bgG, b - bgB);
+        if (distance >= CANVAS_BACKGROUND_DISTANCE_THRESHOLD && alpha > 8) {
+            foreground += 1;
+        }
+    }
+    const foregroundRatio = foreground / pixelCount;
+    const opaqueRatio = opaque / pixelCount;
+    const colorRange = maxLuma - minLuma;
+    return {
+        foregroundRatio,
+        colorRange,
+        opaqueRatio,
+        pass: opaqueRatio > 0.05
+            && (foregroundRatio >= MIN_CANVAS_FOREGROUND_RATIO || colorRange >= MIN_CANVAS_COLOR_RANGE),
+    };
+}
+async function summarizeVisibleCanvases(frame) {
+    return await frame.evaluate((config) => {
+        const canvases = Array.from(document.querySelectorAll('canvas'));
+        const visibleCanvases = canvases.filter((canvas) => {
+            const rect = canvas.getBoundingClientRect();
+            const style = window.getComputedStyle(canvas);
+            const opacity = Number.parseFloat(style.opacity || '1');
+            return rect.width >= config.minEdge
+                && rect.height >= config.minEdge
+                && style.display !== 'none'
+                && style.visibility !== 'hidden'
+                && opacity > 0.05;
+        });
+        const summaries = visibleCanvases.map((canvas) => {
+            const rect = canvas.getBoundingClientRect();
+            const sample = document.createElement('canvas');
+            sample.width = config.sampleSize;
+            sample.height = config.sampleSize;
+            const context = sample.getContext('2d', { willReadFrequently: true });
+            if (!context) {
+                return {
+                    x: Math.round(rect.left),
+                    y: Math.round(rect.top),
+                    width: Math.round(rect.width),
+                    height: Math.round(rect.height),
+                    foregroundRatio: 0,
+                    colorRange: 0,
+                    opaqueRatio: 0,
+                    readable: false,
+                    pass: false,
+                    error: 'canvas_2d_context_unavailable',
+                };
+            }
+            try {
+                context.drawImage(canvas, 0, 0, config.sampleSize, config.sampleSize);
+                const pixels = context.getImageData(0, 0, config.sampleSize, config.sampleSize).data;
+                const cornerIndexes = [
+                    0,
+                    config.sampleSize - 1,
+                    config.sampleSize * (config.sampleSize - 1),
+                    (config.sampleSize * config.sampleSize) - 1,
+                ];
+                let bgR = 0;
+                let bgG = 0;
+                let bgB = 0;
+                for (const index of cornerIndexes) {
+                    const offset = index * 4;
+                    bgR += pixels[offset] ?? 0;
+                    bgG += pixels[offset + 1] ?? 0;
+                    bgB += pixels[offset + 2] ?? 0;
+                }
+                bgR /= cornerIndexes.length;
+                bgG /= cornerIndexes.length;
+                bgB /= cornerIndexes.length;
+                let minLuma = 255;
+                let maxLuma = 0;
+                let foreground = 0;
+                let opaque = 0;
+                const total = config.sampleSize * config.sampleSize;
+                for (let offset = 0; offset < pixels.length; offset += 4) {
+                    const r = pixels[offset] ?? 0;
+                    const g = pixels[offset + 1] ?? 0;
+                    const b = pixels[offset + 2] ?? 0;
+                    const alpha = pixels[offset + 3] ?? 0;
+                    if (alpha > 8) {
+                        opaque += 1;
+                    }
+                    const luma = (0.2126 * r) + (0.7152 * g) + (0.0722 * b);
+                    minLuma = Math.min(minLuma, luma);
+                    maxLuma = Math.max(maxLuma, luma);
+                    const distance = Math.hypot(r - bgR, g - bgG, b - bgB);
+                    if (distance >= config.backgroundDistanceThreshold && alpha > 8) {
+                        foreground += 1;
+                    }
+                }
+                const foregroundRatio = foreground / total;
+                const opaqueRatio = opaque / total;
+                const colorRange = maxLuma - minLuma;
+                return {
+                    x: Math.round(rect.left),
+                    y: Math.round(rect.top),
+                    width: Math.round(rect.width),
+                    height: Math.round(rect.height),
+                    foregroundRatio,
+                    colorRange,
+                    opaqueRatio,
+                    readable: true,
+                    pass: opaqueRatio > 0.05
+                        && (foregroundRatio >= config.minForegroundRatio || colorRange >= config.minColorRange),
+                };
+            }
+            catch (error) {
+                return {
+                    x: Math.round(rect.left),
+                    y: Math.round(rect.top),
+                    width: Math.round(rect.width),
+                    height: Math.round(rect.height),
+                    foregroundRatio: 0,
+                    colorRange: 0,
+                    opaqueRatio: 0,
+                    readable: false,
+                    pass: false,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        });
+        return {
+            canvasCount: canvases.length,
+            visibleCanvasCount: visibleCanvases.length,
+            readableCanvasCount: summaries.filter((summary) => summary.readable).length,
+            passingCanvasCount: summaries.filter((summary) => summary.pass).length,
+            canvases: summaries,
+        };
+    }, {
+        sampleSize: CANVAS_VISUAL_SAMPLE_SIZE,
+        minEdge: MIN_VISIBLE_CANVAS_EDGE_PX,
+        minForegroundRatio: MIN_CANVAS_FOREGROUND_RATIO,
+        minColorRange: MIN_CANVAS_COLOR_RANGE,
+        backgroundDistanceThreshold: CANVAS_BACKGROUND_DISTANCE_THRESHOLD,
+    });
+}
+function formatCanvasVisualSummary(summary) {
+    const readable = summary.canvases.filter(canvas => canvas.readable);
+    const first = readable[0];
+    if (!first) {
+        return `${summary.visibleCanvasCount} visible canvas(es), none readable`;
+    }
+    return `${summary.visibleCanvasCount} visible canvas(es), foregroundRatio=${first.foregroundRatio.toFixed(3)}, colorRange=${first.colorRange.toFixed(1)}, opaqueRatio=${first.opaqueRatio.toFixed(3)}`;
+}
+async function getFramePageOffset(frame) {
+    try {
+        const element = await frame.frameElement();
+        try {
+            const box = await element.boundingBox();
+            return box ? { x: box.x, y: box.y } : null;
+        }
+        finally {
+            await element.dispose().catch(() => { });
+        }
+    }
+    catch {
+        return null;
+    }
+}
+function buildCanvasScreenshotClip(frameOffset, canvas, viewport) {
+    if (!Number.isFinite(canvas.x) || !Number.isFinite(canvas.y)) {
+        return null;
+    }
+    const x = Math.max(0, frameOffset.x + Number(canvas.x));
+    const y = Math.max(0, frameOffset.y + Number(canvas.y));
+    const viewportWidth = viewport?.width ?? Number.POSITIVE_INFINITY;
+    const viewportHeight = viewport?.height ?? Number.POSITIVE_INFINITY;
+    const width = Math.min(canvas.width, viewportWidth - x);
+    const height = Math.min(canvas.height, viewportHeight - y);
+    if (width < MIN_VISIBLE_CANVAS_EDGE_PX || height < MIN_VISIBLE_CANVAS_EDGE_PX) {
+        return null;
+    }
+    return { x, y, width, height };
+}
+async function summarizeScreenshotClip(page, clip) {
+    try {
+        const png = await page.screenshot({ type: 'png', clip });
+        const { data, info } = await (0, sharp_1.default)(png)
+            .ensureAlpha()
+            .resize(CANVAS_VISUAL_SAMPLE_SIZE, CANVAS_VISUAL_SAMPLE_SIZE, { fit: 'fill' })
+            .raw()
+            .toBuffer({ resolveWithObject: true });
+        const pixelSummary = summarizeRgbaPixels(data, info.width * info.height, info.channels);
+        return {
+            x: Math.round(clip.x),
+            y: Math.round(clip.y),
+            width: Math.round(clip.width),
+            height: Math.round(clip.height),
+            foregroundRatio: pixelSummary.foregroundRatio,
+            colorRange: pixelSummary.colorRange,
+            opaqueRatio: pixelSummary.opaqueRatio,
+            readable: true,
+            pass: pixelSummary.pass,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function summarizeCanvasScreenshots(page, frames, summaries) {
+    const viewport = typeof page.viewportSize === 'function' ? page.viewportSize() : null;
+    const screenshotSummaries = [];
+    for (let index = 0; index < frames.length; index += 1) {
+        const frame = frames[index];
+        const summary = summaries[index];
+        if (!frame || !summary || summary.visibleCanvasCount === 0 || summary.passingCanvasCount > 0) {
+            continue;
+        }
+        const frameOffset = await getFramePageOffset(frame);
+        if (!frameOffset) {
+            continue;
+        }
+        for (const canvas of summary.canvases) {
+            const clip = buildCanvasScreenshotClip(frameOffset, canvas, viewport);
+            if (!clip) {
+                continue;
+            }
+            const screenshotSummary = await summarizeScreenshotClip(page, clip);
+            if (screenshotSummary) {
+                screenshotSummaries.push(screenshotSummary);
+            }
+        }
+    }
+    return screenshotSummaries;
+}
+async function assertHostedFrameVisualReadiness(page) {
+    const childFrames = page.frames().filter(frame => frame.parentFrame() !== null);
+    if (childFrames.length === 0) {
+        throw new Error('hosted_app_visual_blank: The hosted app reported ready but no game frame was available for visual validation.');
+    }
+    const summaries = await Promise.all(childFrames.map(frame => summarizeVisibleCanvases(frame)));
+    const framesWithCanvases = summaries.filter(summary => summary.visibleCanvasCount > 0);
+    if (framesWithCanvases.length === 0) {
+        return;
+    }
+    if (framesWithCanvases.some(summary => summary.passingCanvasCount > 0)) {
+        return;
+    }
+    const screenshotSummaries = await summarizeCanvasScreenshots(page, childFrames, summaries);
+    if (screenshotSummaries.some(summary => summary.pass)) {
+        return;
+    }
+    const readableFrames = framesWithCanvases.filter(summary => summary.readableCanvasCount > 0);
+    if (readableFrames.length === 0) {
+        return;
+    }
+    const screenshotDetail = screenshotSummaries.length > 0
+        ? `; screenshot foregroundRatio=${screenshotSummaries[0].foregroundRatio.toFixed(3)}, colorRange=${screenshotSummaries[0].colorRange.toFixed(1)}, opaqueRatio=${screenshotSummaries[0].opaqueRatio.toFixed(3)}`
+        : '';
+    const detail = `${readableFrames.map(formatCanvasVisualSummary).join('; ')}${screenshotDetail}`;
+    throw new Error(`hosted_app_visual_blank: The hosted app reported ready, but its visible canvas looked empty or background-only after startup. ${detail}. Make the playable objects visible in the initial ready state.`);
+}
 async function writeLogFile(logPath, lines) {
     if (!logPath || logPath.trim().length === 0) {
         return;
@@ -623,6 +924,12 @@ async function runCapture(options) {
             finalUrl = await assertPageState();
             await page.waitForTimeout(options.settleAfterReadyMs ?? options.timeoutMs);
             finalUrl = await assertPageState();
+            if (shouldAssertHostedVisualReadiness({
+                requireHostedLaunchReady: options.requireHostedLaunchReady,
+                expectedHostedLaunchState,
+            })) {
+                await assertHostedFrameVisualReadiness(page);
+            }
             if (options.screenshotPath) {
                 const targetDir = (0, node_path_1.dirname)(options.screenshotPath);
                 if (targetDir && targetDir !== '.' && targetDir !== '/') {
@@ -641,6 +948,7 @@ async function runCapture(options) {
     }
     return {
         errorCount: errors.length,
+        errors: errors.slice(0, 10),
         warningCount: warnings.length,
         warnings,
         finalUrl,

package/dist/catalogue.d.ts

@@ -57,8 +57,8 @@ export type AppCatalogueEntry = {
     ownedAssets?: OwnedAssetCatalogueEntry[];
     assetSpecSupport?: AppMetadataAssetSpecSupport[];
     uses?: {
-        assets?: string[];
-        packs?: string[];
+        assets?: unknown[];
+        packs?: unknown[];
     };
     tags?: string[];
     relations?: Array<{
@@ -183,6 +183,8 @@ export type AppTask = {
     version?: string;
     releaseNotes?: string;
     versionVisibility?: AppVersionVisibility;
+    sourceArchiveExcludeRelativeFiles?: string[];
+    bundleArchiveExcludeRelativeFiles?: string[];
     license: ContentLicense;
     tags: string[];
     hostingMode?: AppHostingMode;

package/dist/catalogue.js

@@ -270,6 +270,37 @@ function normalizeCatalogueAppDependencyAssets(value, errors, context) {
     }
     return rows;
 }
+function normalizeCatalogueAppDependencyPacks(value, errors, context) {
+    if (value === undefined || value === null) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        errors.push(`${context} uses.packs must be an array of canonical pack version ref strings.`);
+        return [];
+    }
+    const rows = [];
+    const seenRefs = new Set();
+    for (let index = 0; index < value.length; index += 1) {
+        const entry = value[index];
+        if (typeof entry !== 'string' || entry.trim().length === 0) {
+            errors.push(`${context} uses.packs[${index}] must be a non-empty pack version ref string. Use "pack:playdrop/name@version", not { ref, runtimeKey }.`);
+            continue;
+        }
+        const parsed = (0, types_1.parseContentVersionRef)(entry.trim());
+        if (!parsed || parsed.kind !== 'pack') {
+            errors.push(`${context} uses.packs[${index}] must be a canonical pack version ref.`);
+            continue;
+        }
+        const normalizedRef = (0, types_1.formatContentVersionRef)(parsed);
+        if (seenRefs.has(normalizedRef)) {
+            errors.push(`${context} uses.packs contains duplicate ref "${normalizedRef}".`);
+            continue;
+        }
+        seenRefs.add(normalizedRef);
+        rows.push(normalizedRef);
+    }
+    return rows;
+}
 function rejectLegacyShopPriceCoinsField(value, errors, context) {
     if (Object.prototype.hasOwnProperty.call(value, 'shopPriceCoins')) {
         errors.push(`${context} uses legacy shopPriceCoins. Rename it to shopPriceCredits.`);
@@ -1130,8 +1161,13 @@ function buildAppTasks(rootDir, catalogues, options) {
                     }
                 }
                 // Hero images
-                if (!listingValidationFailed && typeof rawListing.heroPortrait === 'string' && rawListing.heroPortrait.trim()) {
-                    const heroPortraitPath = rawListing.heroPortrait.trim();
+                const rawHeroPortrait = typeof rawListing.heroPortrait === 'string' && rawListing.heroPortrait.trim()
+                    ? rawListing.heroPortrait.trim()
+                    : typeof rawListing.heroPortraitPath === 'string' && rawListing.heroPortraitPath.trim()
+                        ? rawListing.heroPortraitPath.trim()
+                        : '';
+                if (!listingValidationFailed && rawHeroPortrait) {
+                    const heroPortraitPath = rawHeroPortrait;
                     const extensionError = validateListingAssetExtension(heroPortraitPath, 'listing.heroPortrait', 'image');
                     if (extensionError) {
                         errors.push(`[${label}] Skipping ${rawName}: ${extensionError}`);
@@ -1148,8 +1184,13 @@ function buildAppTasks(rootDir, catalogues, options) {
                         }
                     }
                 }
-                if (!listingValidationFailed && typeof rawListing.heroLandscape === 'string' && rawListing.heroLandscape.trim()) {
-                    const heroLandscapePath = rawListing.heroLandscape.trim();
+                const rawHeroLandscape = typeof rawListing.heroLandscape === 'string' && rawListing.heroLandscape.trim()
+                    ? rawListing.heroLandscape.trim()
+                    : typeof rawListing.heroLandscapePath === 'string' && rawListing.heroLandscapePath.trim()
+                        ? rawListing.heroLandscapePath.trim()
+                        : '';
+                if (!listingValidationFailed && rawHeroLandscape) {
+                    const heroLandscapePath = rawHeroLandscape;
                     const extensionError = validateListingAssetExtension(heroLandscapePath, 'listing.heroLandscape', 'image');
                     if (extensionError) {
                         errors.push(`[${label}] Skipping ${rawName}: ${extensionError}`);
@@ -1253,10 +1294,12 @@ function buildAppTasks(rootDir, catalogues, options) {
                 }
                 listing = resolvedListing;
             }
+            const errorCountBeforeDependencies = errors.length;
             const usesAssets = normalizeCatalogueAppDependencyAssets(entry.uses?.assets, errors, `[${label}] App "${rawName}"`);
-            const usesPacks = Array.isArray(entry.uses?.packs)
-                ? entry.uses.packs.filter((value) => typeof value === 'string' && value.trim().length > 0)
-                : [];
+            const usesPacks = normalizeCatalogueAppDependencyPacks(entry.uses?.packs, errors, `[${label}] App "${rawName}"`);
+            if (errors.length > errorCountBeforeDependencies) {
+                continue;
+            }
             const errorCountBeforeTagMetadata = errors.length;
             const remix = normalizeCatalogueRemixRef(entry.remix, 'app', errors, `[${label}] App "${rawName}"`);
             const tags = normalizeCatalogueTags(entry.tags, errors, `[${label}] App "${rawName}"`);

package/dist/commandContext.js

@@ -38,8 +38,10 @@ function resolveConfiguredEnvironment(envName, command, options) {
 }
 function buildContext(cfg, envConfig, account, workspaceAuth = null) {
     const token = account?.token ?? cfg.token ?? '';
-    const client = (0, apiClient_1.createCliApiClient)({ baseUrl: envConfig.apiBase, token });
-    const aiClient = (0, apiClient_1.createCliAiClient)({ baseUrl: envConfig.aiBase, token });
+    const onBehalfCreatorUsername = workspaceAuth?.config.ownerUsername ?? null;
+    const agentTaskToken = workspaceAuth?.config.taskToken ?? null;
+    const client = (0, apiClient_1.createCliApiClient)({ baseUrl: envConfig.apiBase, token, onBehalfCreatorUsername, agentTaskToken });
+    const aiClient = (0, apiClient_1.createCliAiClient)({ baseUrl: envConfig.aiBase, token, onBehalfCreatorUsername, agentTaskToken });
     return {
         client,
         aiClient,
@@ -124,8 +126,30 @@ function resolveWorkspaceSelectedAccount(cfg, currentAccount, workspaceAuth, req
     const matchingSessions = (0, config_1.listAccountSessionsForUsername)(workspaceAuth.config.ownerUsername, cfg);
     const preferredEnv = normalizeRequestedEnv(requestedEnv) ?? workspaceAuth.config.env;
     if (preferredEnv) {
+        const ownerAccount = (0, config_1.findAccountSession)(workspaceAuth.config.ownerUsername, preferredEnv, cfg);
+        if (ownerAccount) {
+            return {
+                account: ownerAccount,
+                matchingSessions,
+            };
+        }
+        if (workspaceAuth.config.taskToken && currentAccount) {
+            if (currentAccount.env === preferredEnv) {
+                return {
+                    account: currentAccount,
+                    matchingSessions,
+                };
+            }
+            const currentAccountForEnv = (0, config_1.findAccountSession)(currentAccount.username, preferredEnv, cfg);
+            if (currentAccountForEnv) {
+                return {
+                    account: currentAccountForEnv,
+                    matchingSessions,
+                };
+            }
+        }
         return {
-            account: (0, config_1.findAccountSession)(workspaceAuth.config.ownerUsername, preferredEnv, cfg),
+            account: null,
             matchingSessions,
         };
     }
@@ -141,6 +165,21 @@ function resolveWorkspaceSelectedAccount(cfg, currentAccount, workspaceAuth, req
             matchingSessions,
         };
     }
+    if (currentAccount) {
+        if (!preferredEnv || currentAccount.env === preferredEnv) {
+            return {
+                account: currentAccount,
+                matchingSessions,
+            };
+        }
+        const currentAccountForEnv = (0, config_1.findAccountSession)(currentAccount.username, preferredEnv, cfg);
+        if (currentAccountForEnv) {
+            return {
+                account: currentAccountForEnv,
+                matchingSessions,
+            };
+        }
+    }
     return {
         account: null,
         matchingSessions,

package/dist/commands/capture.d.ts

@@ -3,6 +3,7 @@ type CaptureOptions = {
     appName?: string;
     logLevel?: string;
     screenshotPath?: string;
+    port?: string | number;
     surfaceTarget?: string;
     devAuth?: string;
     player?: string | number;

package/dist/commands/capture.js

@@ -16,6 +16,7 @@ const captureRuntime_1 = require("../captureRuntime");
 const devAuth_1 = require("../devAuth");
 const devRuntimeAssets_1 = require("./devRuntimeAssets");
 const dev_1 = require("./dev");
+const dev_2 = require("./dev");
 const MOBILE_USER_AGENT = 'Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Mobile/15E148 Safari/604.1';
 const SURFACE_PRESETS = {
     desktop: {
@@ -120,6 +121,7 @@ function resolveCaptureDevOptions(options) {
 async function capture(targetArg, options = {}) {
     const timeoutSeconds = (0, captureRuntime_1.validateCaptureTimeout)(options.timeoutSeconds);
     const timeoutMs = Math.round(timeoutSeconds * 1000);
+    const devRouterPort = (0, dev_2.resolveDevRouterPort)(options.port ?? process.env.PLAYDROP_DEV_ROUTER_PORT);
     let minimumLogLevel;
     let loginOverride;
     let devOptions;
@@ -242,11 +244,13 @@ async function capture(targetArg, options = {}) {
     }
     const projectInfo = (0, devShared_1.findProjectInfo)(filePath);
     const devScriptAvailable = Boolean(projectInfo.projectDir && projectInfo.packageJson && typeof projectInfo.packageJson.scripts?.dev === 'string');
-    await (0, commandContext_1.withEnvironment)('project capture', 'Capturing app logs', async ({ client, env, envConfig }) => {
+    await (0, commandContext_1.withEnvironment)('project capture', 'Capturing app logs', async ({ client, env, envConfig, token, workspaceAuth }) => {
         let currentUsername = '';
+        let currentUser = null;
         try {
-            const currentUser = await (0, devShared_1.fetchDevUser)(client);
-            currentUsername = currentUser.username.trim();
+            const fetchedCurrentUser = await (0, devShared_1.fetchDevUser)(client);
+            currentUser = fetchedCurrentUser;
+            currentUsername = fetchedCurrentUser.username.trim();
         }
         catch (error) {
             if (error instanceof http_1.CLIUnsupportedClientError) {
@@ -280,8 +284,14 @@ async function capture(targetArg, options = {}) {
             }
             throw error;
         }
-        if ((devOptions.selection.devAuth === 'viewer' || devOptions.selection.devAuth === 'player') && !loginOverride) {
-            (0, messages_1.printErrorWithHelp)(`Use --username and --password to establish a browser session before running --dev-auth ${devOptions.selection.devAuth}.`, [], { command: 'project capture' });
+        const taskScoped = Boolean(workspaceAuth?.config.taskToken);
+        if (devOptions.selection.devAuth === 'viewer' && !loginOverride && !taskScoped) {
+            (0, messages_1.printErrorWithHelp)('Use --username and --password to establish a browser session before running --dev-auth viewer.', [], { command: 'project capture' });
+            process.exitCode = 1;
+            return;
+        }
+        if (devOptions.selection.devAuth === 'player' && !loginOverride) {
+            (0, messages_1.printErrorWithHelp)('Use --username and --password to establish a browser session before running --dev-auth player.', [], { command: 'project capture' });
             process.exitCode = 1;
             return;
         }
@@ -291,7 +301,7 @@ async function capture(targetArg, options = {}) {
             creatorUsername: currentUsername,
             appType: appTypeSlug,
             appName,
-            port: devServer_1.DEV_ROUTER_PORT,
+            port: devRouterPort,
         }, 750);
         const devServerStartedByCapture = !serverAlreadyRunning;
         let serverHandle = null;
@@ -328,7 +338,7 @@ async function capture(targetArg, options = {}) {
                         creatorUsername: currentUsername,
                         appType: appTypeSlug,
                         appName,
-                        port: devServer_1.DEV_ROUTER_PORT,
+                        port: devRouterPort,
                     })).toString(),
                 });
             }
@@ -344,14 +354,14 @@ async function capture(targetArg, options = {}) {
                 creatorUsername: currentUsername,
                 appType: appTypeSlug,
                 appName,
-                port: devServer_1.DEV_ROUTER_PORT,
+                port: devRouterPort,
             })}`);
             try {
                 await (0, devServer_1.updateMountedDevRuntimeAssetManifest)({
                     creatorUsername: currentUsername,
                     appName,
                     runtimeAssetManifest,
-                    port: devServer_1.DEV_ROUTER_PORT,
+                    port: devRouterPort,
                 });
             }
             catch (error) {
@@ -369,7 +379,7 @@ async function capture(targetArg, options = {}) {
                     appType: appTypeSlug,
                     creatorUsername: currentUsername,
                     htmlPath: filePath,
-                    port: devServer_1.DEV_ROUTER_PORT,
+                    port: devRouterPort,
                     projectInfo,
                     runtimeAssetManifest,
                 });
@@ -389,7 +399,7 @@ async function capture(targetArg, options = {}) {
                     ], { command: 'project capture' });
                 }
                 else {
-                    (0, messages_1.printErrorWithHelp)(error?.message || `Failed to start the shared dev router on port ${devServer_1.DEV_ROUTER_PORT}.`, [
+                    (0, messages_1.printErrorWithHelp)(error?.message || `Failed to start the shared dev router on port ${devRouterPort}.`, [
                         'Close the conflicting process or wait for the stale mount to exit.',
                         'Ensure the HTML file exists and is readable.',
                     ], { command: 'project capture' });
@@ -412,7 +422,11 @@ async function capture(targetArg, options = {}) {
             && (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;
+        const savedSessionViewerCapture = devOptions.selection.devAuth === 'viewer' && !loginOverride && taskScoped;
+        const requiresRegisteredApp = devOptions.selection.devAuth === 'player'
+            || shouldResetBefore
+            || shouldResetAfter
+            || (devOptions.selection.devAuth === 'viewer' && !savedSessionViewerCapture);
         let registeredApp = null;
         if (requiresRegisteredApp) {
             try {
@@ -458,6 +472,7 @@ async function capture(targetArg, options = {}) {
             devAuth: devOptions.selection.devAuth,
             player: devOptions.selection.player ? String(devOptions.selection.player) : null,
             launchCheck: true,
+            localDevPort: devRouterPort === devServer_1.DEV_ROUTER_PORT ? null : devRouterPort,
         });
         const frameUrl = (0, devAuth_1.applyHostedDevAuthSelectionToUrl)(captureBaseUrl, devOptions.selection);
         console.log(`[capture] Launching Playwright against ${frameUrl}`);
@@ -484,7 +499,9 @@ async function capture(targetArg, options = {}) {
                     username: loginOverride.username,
                     password: loginOverride.password,
                 } : undefined,
-                savedSessionBootstrap: false,
+                token: savedSessionViewerCapture ? token : undefined,
+                user: savedSessionViewerCapture ? currentUser : undefined,
+                savedSessionBootstrap: savedSessionViewerCapture,
                 enableCaptureBridge: true,
                 requireHostedLaunchReady: true,
             });

package/dist/commands/create.d.ts

@@ -1,7 +1,6 @@
 type CreateOptions = {
     template?: string;
     remix?: string;
-    gameIdea?: string;
 };
 export declare function createAssetSpecProject(name: string): Promise<void>;
 export declare function create(name: string, options?: CreateOptions): Promise<void>;