@playdrop/playdrop-cli 0.9.6 → 0.10.1

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,318 @@ 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 runCaptureActions(page, actions) {
+    if (!actions?.length) {
+        return;
+    }
+    for (const action of actions) {
+        if (action.type === 'click') {
+            await page.mouse.click(action.x, action.y, { button: action.button ?? 'left' });
+            continue;
+        }
+        if (action.type === 'press') {
+            await page.keyboard.press(action.key);
+            continue;
+        }
+        if (action.type === 'wait') {
+            await page.waitForTimeout(action.ms);
+            continue;
+        }
+        throw new Error('capture_action_type_unknown');
+    }
+}
+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;
@@ -621,8 +942,15 @@ async function runCapture(options) {
                 }
             }
             finalUrl = await assertPageState();
+            await runCaptureActions(page, options.actions);
             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 +969,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,26 @@ 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 agentTaskId = workspaceAuth?.config.taskId ?? null;
+    const agentTaskAttempt = workspaceAuth?.config.taskAttempt ?? null;
+    const client = (0, apiClient_1.createCliApiClient)({
+        baseUrl: envConfig.apiBase,
+        token,
+        onBehalfCreatorUsername,
+        agentTaskToken,
+        agentTaskId,
+        agentTaskAttempt,
+    });
+    const aiClient = (0, apiClient_1.createCliAiClient)({
+        baseUrl: envConfig.aiBase,
+        token,
+        onBehalfCreatorUsername,
+        agentTaskToken,
+        agentTaskId,
+        agentTaskAttempt,
+    });
     return {
         client,
         aiClient,
@@ -90,8 +108,10 @@ async function migrateLegacyConfigIfNeeded(cfg, envConfig, command) {
 async function loadWorkspaceAwareConfig(command, options) {
     let cfg = (0, config_1.loadConfig)();
     let workspaceAuth = null;
+    const workspacePath = options.workspacePath
+        ?? (process.env.PLAYDROP_WORKER_CONTEXT === '1' ? process.cwd() : undefined);
     try {
-        workspaceAuth = options.workspacePath ? (0, workspaceAuth_1.findWorkspaceAuthConfig)(options.workspacePath) : null;
+        workspaceAuth = workspacePath ? (0, workspaceAuth_1.findWorkspaceAuthConfig)(workspacePath) : null;
     }
     catch (error) {
         if (error instanceof workspaceAuth_1.WorkspaceAuthConfigError) {
@@ -124,8 +144,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 +183,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;