@playdrop/playdrop-cli 0.5.4 → 0.5.6

package/dist/commands/captureListing.js

@@ -1,4 +1,5 @@
 "use strict";
+/* eslint-disable max-lines */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -33,6 +34,8 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveListingCaptureRouteSegment = resolveListingCaptureRouteSegment;
+exports.resolveListingCaptureSceneId = resolveListingCaptureSceneId;
 exports.parseCaptureListingOptions = parseCaptureListingOptions;
 exports.assertSupportedListingEnvironment = assertSupportedListingEnvironment;
 exports.resolveListingRecorderPath = resolveListingRecorderPath;
@@ -47,7 +50,6 @@ const commandContext_1 = require("../commandContext");
 const http_1 = require("../http");
 const messages_1 = require("../messages");
 const playwright_1 = require("../playwright");
-const sessionCookie_1 = require("../sessionCookie");
 const devShared_1 = require("./devShared");
 const devServer_1 = require("./devServer");
 const appUrls_1 = require("../appUrls");
@@ -63,6 +65,12 @@ const MIN_DIMENSION = 16;
 const MAX_DIMENSION = 8192;
 const MAX_FPS = 120;
 const SUPPORTED_MACOS_PREFIX = '26.4';
+function resolveListingCaptureRouteSegment(previewable) {
+    return previewable ? 'dev-preview' : 'dev';
+}
+function resolveListingCaptureSceneId(width, height) {
+    return height > width ? 'listing-portrait' : 'listing-landscape';
+}
 function parsePositiveNumber(raw, fallback, fieldName, { minimum = 0, maximum = Number.POSITIVE_INFINITY, integer = false, } = {}) {
     if (raw === undefined) {
         return fallback;
@@ -223,30 +231,6 @@ async function launchListingBrowser(initialViewport) {
         throw (0, playwright_1.createPlaywrightLaunchError)('playdrop', error);
     }
 }
-async function bootstrapAuthState(context, page, targetUrl, token, user) {
-    const cookies = (0, sessionCookie_1.buildCaptureAccessTokenCookies)(targetUrl, token);
-    await context.addCookies(cookies);
-    await page.addInitScript(({ bootstrapToken, bootstrapUser }) => {
-        try {
-            window.localStorage.setItem('playdrop.accessToken', bootstrapToken);
-        }
-        catch {
-            // ignore storage failures
-        }
-        try {
-            window.localStorage.setItem('playdrop.user', JSON.stringify(bootstrapUser));
-        }
-        catch {
-            // ignore storage failures
-        }
-        try {
-            window.sessionStorage.removeItem('playdrop.logoutReason');
-        }
-        catch {
-            // ignore storage failures
-        }
-    }, { bootstrapToken: token, bootstrapUser: user });
-}
 async function waitForHostedGameMeasurement(page, timeoutMs) {
     const startedAt = Date.now();
     let lastSignature = '';
@@ -310,6 +294,74 @@ async function waitForHostedGameMeasurement(page, timeoutMs) {
     }
     throw new Error('hosted_game_measurement_timeout');
 }
+async function waitForHostedGameFrame(page, timeoutMs) {
+    const frameHandle = await page.waitForSelector(CAPTURE_FRAME_SELECTOR, {
+        state: 'attached',
+        timeout: timeoutMs,
+    });
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+        const frame = await frameHandle.contentFrame();
+        if (frame) {
+            return frame;
+        }
+        await page.waitForTimeout(200);
+    }
+    throw new Error('hosted_game_frame_missing');
+}
+async function prepareHostedListingScene(page, sceneId) {
+    const frame = await waitForHostedGameFrame(page, 20000);
+    await frame.waitForFunction(() => {
+        const captureWindow = window;
+        return typeof captureWindow.__listingCapture?.prepare === 'function';
+    }, undefined, { timeout: 20000 });
+    await frame.evaluate(async (requestedSceneId) => {
+        const captureWindow = window;
+        const hook = captureWindow.__listingCapture;
+        if (!hook || typeof hook.prepare !== 'function') {
+            throw new Error('listing_capture_hook_missing');
+        }
+        await hook.prepare(requestedSceneId);
+    }, sceneId);
+}
+async function startHostedListingAudioCapture(page) {
+    const frame = await waitForHostedGameFrame(page, 20000);
+    await frame.waitForFunction(() => {
+        const captureWindow = window;
+        return typeof captureWindow.__listingCapture?.startAudioCapture === 'function';
+    }, undefined, { timeout: 20000 });
+    await frame.evaluate(async () => {
+        const captureWindow = window;
+        const hook = captureWindow.__listingCapture;
+        if (!hook || typeof hook.startAudioCapture !== 'function') {
+            throw new Error('listing_audio_capture_hook_missing');
+        }
+        await hook.startAudioCapture();
+    });
+}
+function resolveExportedAudioFileName(mimeType) {
+    if (mimeType.includes('webm')) {
+        return 'listing-audio.webm';
+    }
+    if (mimeType.includes('mp4') || mimeType.includes('aac') || mimeType.includes('m4a')) {
+        return 'listing-audio.m4a';
+    }
+    throw new Error(`unsupported_listing_audio_mime_type:${mimeType}`);
+}
+async function stopHostedListingAudioCapture(page, outputDir) {
+    const frame = await waitForHostedGameFrame(page, 20000);
+    const exportedAudio = await frame.evaluate(async () => {
+        const captureWindow = window;
+        const hook = captureWindow.__listingCapture;
+        if (!hook || typeof hook.stopAudioCapture !== 'function') {
+            throw new Error('listing_audio_capture_hook_missing');
+        }
+        return hook.stopAudioCapture();
+    });
+    const filePath = (0, node_path_1.join)(outputDir, resolveExportedAudioFileName(exportedAudio.mimeType));
+    await (0, promises_1.writeFile)(filePath, Buffer.from(exportedAudio.base64, 'base64'));
+    return filePath;
+}
 async function fitWindowToRequestedGameplay(page, requestedWidth, requestedHeight) {
     const cdpSession = await page.context().newCDPSession(page);
     let measurement = await waitForHostedGameMeasurement(page, 15000);
@@ -531,6 +583,23 @@ async function encodeListingVideo(rawVideoPath, finalVideoPath, posterPath, crop
         posterPath,
     ], 'ffmpeg_failed');
 }
+async function muxListingAudio(finalVideoPath, audioPath) {
+    const muxedVideoPath = `${finalVideoPath}.muxed.mp4`;
+    runTool('ffmpeg', [
+        '-y',
+        '-i',
+        finalVideoPath,
+        '-i',
+        audioPath,
+        '-c:v',
+        'copy',
+        '-c:a',
+        'aac',
+        '-shortest',
+        muxedVideoPath,
+    ], 'ffmpeg_failed');
+    await (0, promises_1.rename)(muxedVideoPath, finalVideoPath);
+}
 function ensureTolerance(actual, expected, tolerance, failureCode) {
     if (Math.abs(actual - expected) > tolerance) {
         throw new Error(`${failureCode}:${actual}:${expected}`);
@@ -544,44 +613,30 @@ function createWarnings(finalProbe, requestedAudio) {
     }
     return warnings;
 }
-async function captureListing(targetArg, options = {}) {
-    let parsedOptions;
-    try {
-        parsedOptions = parseCaptureListingOptions(targetArg, options);
-        assertSupportedListingEnvironment();
-    }
-    catch (error) {
-        const detail = formatCommandError(error instanceof Error ? error : new Error(String(error)));
-        (0, messages_1.printErrorWithHelp)(detail.message, detail.suggestions, { command: 'project capture listing' });
-        process.exitCode = 1;
-        return;
-    }
-    if (!commandExists('ffmpeg')) {
-        (0, messages_1.printErrorWithHelp)('ffmpeg is required for listing capture.', ['Install ffmpeg and make sure it is available on PATH.'], {
-            command: 'project capture listing',
-        });
-        process.exitCode = 1;
-        return;
+function ensureCaptureListingToolAvailable(command) {
+    if (commandExists(command)) {
+        return true;
     }
-    if (!commandExists('ffprobe')) {
-        (0, messages_1.printErrorWithHelp)('ffprobe is required for listing capture.', ['Install ffprobe and make sure it is available on PATH.'], {
-            command: 'project capture listing',
-        });
-        process.exitCode = 1;
-        return;
-    }
-    const recorderPath = resolveListingRecorderPath();
+    (0, messages_1.printErrorWithHelp)(`${command} is required for listing capture.`, [`Install ${command} and make sure it is available on PATH.`], {
+        command: 'project capture listing',
+    });
+    process.exitCode = 1;
+    return false;
+}
+async function ensureListingRecorderAvailable(recorderPath) {
     try {
         await ensureExecutableFile(recorderPath);
+        return true;
     }
     catch {
         (0, messages_1.printErrorWithHelp)(`Native recorder binary was not found at ${recorderPath}.`, ['Build it with: (cd clients/apple/playdrop-listing-recorder && swift build -c release)'], { command: 'project capture listing' });
         process.exitCode = 1;
-        return;
+        return false;
     }
-    let resolvedTarget;
+}
+function resolveCaptureListingTarget(parsedOptions) {
     try {
-        resolvedTarget = (0, devShared_1.resolveDevTarget)(parsedOptions.targetArg, parsedOptions.appName);
+        return (0, devShared_1.resolveDevTarget)(parsedOptions.targetArg, parsedOptions.appName);
     }
     catch (error) {
         const code = error?.code;
@@ -593,6 +648,30 @@ async function captureListing(targetArg, options = {}) {
                 : ['Provide a valid app target or HTML file path.'];
         (0, messages_1.printErrorWithHelp)(message, suggestions, { command: 'project capture listing' });
         process.exitCode = 1;
+        return null;
+    }
+}
+async function captureListing(targetArg, options = {}) {
+    let parsedOptions;
+    try {
+        parsedOptions = parseCaptureListingOptions(targetArg, options);
+        assertSupportedListingEnvironment();
+    }
+    catch (error) {
+        const detail = formatCommandError(error instanceof Error ? error : new Error(String(error)));
+        (0, messages_1.printErrorWithHelp)(detail.message, detail.suggestions, { command: 'project capture listing' });
+        process.exitCode = 1;
+        return;
+    }
+    if (!ensureCaptureListingToolAvailable('ffmpeg') || !ensureCaptureListingToolAvailable('ffprobe')) {
+        return;
+    }
+    const recorderPath = resolveListingRecorderPath();
+    if (!await ensureListingRecorderAvailable(recorderPath)) {
+        return;
+    }
+    const resolvedTarget = resolveCaptureListingTarget(parsedOptions);
+    if (!resolvedTarget) {
         return;
     }
     let appName = resolvedTarget.appName;
@@ -609,11 +688,11 @@ async function captureListing(targetArg, options = {}) {
     const projectInfo = (0, devShared_1.findProjectInfo)(resolvedTarget.htmlPath);
     const devScriptAvailable = Boolean(projectInfo.projectDir && projectInfo.packageJson && typeof projectInfo.packageJson.scripts?.dev === 'string');
     // eslint-disable-next-line complexity
-    await (0, commandContext_1.withEnvironment)('project capture listing', 'Capturing listing media', async ({ client, env, envConfig, token }) => {
-        let currentUser = null;
+    await (0, commandContext_1.withEnvironment)('project capture listing', 'Capturing listing media', async ({ client, env, envConfig }) => {
         let currentUsername = '';
+        let registeredApp = null;
         try {
-            currentUser = await (0, devShared_1.fetchDevUser)(client);
+            const currentUser = await (0, devShared_1.fetchDevUser)(client);
             currentUsername = currentUser.username.trim();
         }
         catch (error) {
@@ -641,7 +720,7 @@ async function captureListing(targetArg, options = {}) {
             throw error;
         }
         try {
-            await (0, devShared_1.assertAppRegistered)(client, currentUsername, appName);
+            registeredApp = await (0, devShared_1.assertAppRegistered)(client, currentUsername, appName);
         }
         catch (error) {
             if (error instanceof http_1.CLIUnsupportedClientError) {
@@ -717,18 +796,32 @@ async function captureListing(targetArg, options = {}) {
                 await new Promise(resolve => setTimeout(resolve, 1000));
             }
             const webBase = envConfig.webBase ?? 'https://www.playdrop.ai';
-            const frameUrl = `${webBase}/creators/${encodeURIComponent(currentUsername)}/apps/${appTypeSlug}/${encodeURIComponent(appName)}/dev`;
+            const routeSegment = resolveListingCaptureRouteSegment(Boolean(registeredApp?.previewable));
+            const frameUrl = `${webBase}/creators/${encodeURIComponent(currentUsername)}/apps/${appTypeSlug}/${encodeURIComponent(appName)}/${routeSegment}`;
+            const captureSceneId = resolveListingCaptureSceneId(parsedOptions.width, parsedOptions.height);
+            const shouldExportPreviewAudio = parsedOptions.audio && routeSegment === 'dev-preview';
             browserHandle = await launchListingBrowser({
                 width: parsedOptions.width,
                 height: parsedOptions.height,
             });
-            await bootstrapAuthState(browserHandle.context, browserHandle.page, frameUrl, token, currentUser);
             await browserHandle.page.goto(frameUrl, { waitUntil: 'domcontentloaded' });
             await browserHandle.page.waitForTimeout(1000);
+            if (routeSegment === 'dev-preview') {
+                console.log(`[listing] Preparing preview scene ${captureSceneId}.`);
+                await prepareHostedListingScene(browserHandle.page, captureSceneId);
+                await browserHandle.page.waitForTimeout(1000);
+            }
+            if (shouldExportPreviewAudio) {
+                console.log('[listing] Starting in-app preview audio capture.');
+                await startHostedListingAudioCapture(browserHandle.page);
+            }
             const measurement = await fitWindowToRequestedGameplay(browserHandle.page, parsedOptions.width, parsedOptions.height);
             console.log(`[listing] Gameplay frame ${Math.round(measurement.iframeRect.width)}x${Math.round(measurement.iframeRect.height)} in window ${Math.round(measurement.outerWidth)}x${Math.round(measurement.outerHeight)}.`);
             await browserHandle.page.waitForTimeout(750);
-            const recorderMetadata = await runListingRecorder(recorderPath, browserHandle.processId, parsedOptions.durationSeconds, outputPaths.rawVideoPath, outputPaths.metadataPath, parsedOptions.audio);
+            const recorderMetadata = await runListingRecorder(recorderPath, browserHandle.processId, parsedOptions.durationSeconds, outputPaths.rawVideoPath, outputPaths.metadataPath, shouldExportPreviewAudio ? false : parsedOptions.audio);
+            const exportedAudioPath = shouldExportPreviewAudio
+                ? await stopHostedListingAudioCapture(browserHandle.page, outputPaths.outputDir)
+                : null;
             const rawProbe = await probeMediaFile(outputPaths.rawVideoPath);
             const rawVideoStream = extractVideoStream(rawProbe);
             const rawDurationSeconds = readDurationSeconds(rawProbe);
@@ -736,6 +829,9 @@ async function captureListing(targetArg, options = {}) {
             const crop = computeRecordedCrop(measurement, rawVideoStream.width, rawVideoStream.height);
             console.log(`[listing] Cropping raw capture to gameplay at ${crop.width}x${crop.height}+${crop.x}+${crop.y}.`);
             await encodeListingVideo(outputPaths.rawVideoPath, outputPaths.finalVideoPath, outputPaths.posterPath, crop, parsedOptions.width, parsedOptions.height, parsedOptions.fps, parsedOptions.posterAtSeconds);
+            if (exportedAudioPath) {
+                await muxListingAudio(outputPaths.finalVideoPath, exportedAudioPath);
+            }
             const finalProbe = await probeMediaFile(outputPaths.finalVideoPath);
             const finalVideoStream = extractVideoStream(finalProbe);
             const finalDurationSeconds = readDurationSeconds(finalProbe);

package/dist/commands/create.js

@@ -12,10 +12,8 @@ const node_path_1 = require("node:path");
 const node_child_process_1 = require("node:child_process");
 const fflate_1 = require("fflate");
 const types_1 = require("@playdrop/types");
-const config_1 = require("../config");
-const apiClient_1 = require("../apiClient");
+const commandContext_1 = require("../commandContext");
 const http_1 = require("../http");
-const environment_1 = require("../environment");
 const messages_1 = require("../messages");
 const init_1 = require("./init");
 const app_1 = require("@playdrop/types/app");
@@ -635,7 +633,7 @@ function buildPendingExternalRemixTask(name, metadata, sourceInfo, cataloguePath
         remix: typeof entry.remix === 'string' ? entry.remix : undefined,
         achievements: [],
         leaderboards: [],
-        embeddedAssets: [],
+        ownedAssets: [],
         uses: { assets: [], packs: [] },
         graph: { relations: [] },
     };
@@ -1047,31 +1045,11 @@ async function create(name, options = {}) {
     }
     const templateOption = templateOptionRaw || undefined;
     const remixOption = remixOptionRaw || undefined;
-    const cfg = (0, config_1.loadConfig)();
-    const envName = cfg.env;
-    if (!envName) {
-        (0, messages_1.printLoginRequired)('Creating an app', 'project create app');
-        process.exitCode = 1;
-        return;
-    }
-    const envConfig = (0, environment_1.resolveEnvironmentConfig)(envName);
-    if (!envConfig) {
-        const choices = (0, environment_1.formatEnvironmentList)();
-        (0, messages_1.printErrorWithHelp)(`Environment "${envName}" from your Playdrop config is not supported.`, [
-            `Available environments: ${choices}.`,
-            'Run "playdrop auth login --env <env>" to save a supported environment before creating apps.'
-        ], { command: 'project create app', includeGeneralHelp: false });
-        process.exitCode = 1;
+    const ctx = await (0, commandContext_1.resolveAuthenticatedEnvironmentContext)('project create app', 'Creating an app', { workspacePath: process.cwd() });
+    if (!ctx) {
         return;
     }
-    if (!cfg.token) {
-        (0, messages_1.printLoginRequired)('Creating an app', 'project create app');
-        process.exitCode = 1;
-        return;
-    }
-    if (envConfig.allowInsecureRequests) {
-        process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
-    }
+    const envName = ctx.env;
     const currentDir = process.cwd();
     const localCataloguePath = (0, node_path_1.resolve)(currentDir, CATALOGUE_FILENAME);
     let initSummary = null;
@@ -1080,7 +1058,7 @@ async function create(name, options = {}) {
     let projectCatalogueResult = null;
     let cataloguePathToUse = null;
     let projectCataloguePath = null;
-    const client = (0, apiClient_1.createCliApiClient)({ baseUrl: envConfig.apiBase, token: cfg.token });
+    const client = ctx.client;
     const sourceInfo = {};
     let remixSourceTarget = null;
     let scaffold = null;

package/dist/commands/createRemixContent.js

@@ -6,9 +6,7 @@ exports.createRemixContent = createRemixContent;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const types_1 = require("@playdrop/types");
-const apiClient_1 = require("../apiClient");
-const config_1 = require("../config");
-const environment_1 = require("../environment");
+const commandContext_1 = require("../commandContext");
 const http_1 = require("../http");
 const messages_1 = require("../messages");
 const init_1 = require("./init");
@@ -104,31 +102,11 @@ function assertWorkspaceRootCanOwnEntries(cataloguePath) {
     }
 }
 async function createAuthenticatedClient(commandLabel) {
-    const cfg = (0, config_1.loadConfig)();
-    const envName = cfg.env;
-    if (!envName) {
-        (0, messages_1.printLoginRequired)(commandLabel, commandLabel);
-        process.exitCode = 1;
-        throw new Error('missing_env');
-    }
-    const envConfig = (0, environment_1.resolveEnvironmentConfig)(envName);
-    if (!envConfig) {
-        (0, messages_1.printErrorWithHelp)(`Environment "${envName}" from your Playdrop config is not supported.`, [
-            `Available environments: ${(0, environment_1.formatEnvironmentList)()}.`,
-            'Run "playdrop auth login --env <env>" to save a supported environment before retrying.',
-        ], { command: commandLabel, includeGeneralHelp: false });
-        process.exitCode = 1;
-        throw new Error('unsupported_env');
-    }
-    if (!cfg.token) {
-        (0, messages_1.printLoginRequired)(commandLabel, commandLabel);
-        process.exitCode = 1;
+    const ctx = await (0, commandContext_1.resolveAuthenticatedEnvironmentContext)(commandLabel, commandLabel, { workspacePath: process.cwd() });
+    if (!ctx) {
         throw new Error('missing_token');
     }
-    if (envConfig.allowInsecureRequests) {
-        process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
-    }
-    return (0, apiClient_1.createCliApiClient)({ baseUrl: envConfig.apiBase, token: cfg.token });
+    return ctx.client;
 }
 function ensureUniqueEntryName(catalogue, kind, name) {
     const entries = kind === 'asset' ? catalogue.assets : catalogue.assetPacks;

package/dist/commands/creations.js

@@ -105,11 +105,10 @@ function buildCountsSuffix(item) {
         }
         parts.push(`launch ${formatCountValue(item.item.playCount)}`);
     }
-    if (item.kind === 'asset' && 'playCount' in item.item && typeof item.item.playCount === 'number') {
-        if (typeof item.item.viewCount === 'number') {
+    if (item.kind === 'asset') {
+        if ('viewCount' in item.item && typeof item.item.viewCount === 'number') {
             parts.push(`view ${formatCountValue(item.item.viewCount)}`);
         }
-        parts.push(`play ${formatCountValue(item.item.playCount)}`);
     }
     if (item.kind === 'asset-pack' && 'downloadCount' in item.item && typeof item.item.downloadCount === 'number') {
         parts.push(`download ${formatCountValue(item.item.downloadCount)}`);

package/dist/commands/detail.js

@@ -42,9 +42,10 @@ function extractAssetFileUrls(asset) {
         .filter((entry) => typeof entry?.role === 'string' && typeof entry?.url === 'string' && entry.url.trim().length > 0)
         .map((entry) => ({ role: entry.role, url: entry.url.trim() }));
 }
-function decorateApp(app, webBase) {
+function decorateApp(app, webBase, dependencies) {
     return {
         ...app,
+        dependencies,
         urls: {
             play: (0, appUrls_1.buildPlatformPlayUrl)(webBase, {
                 creatorUsername: app.creatorUsername,
@@ -80,6 +81,16 @@ function formatTagSummary(tags) {
     }
     return normalizedTags.map((tag) => `${tag.ref} (${tag.displayName})`).join(', ');
 }
+function printAppDependencyLines(label, items) {
+    if (items.length === 0) {
+        console.log(`${label}: none`);
+        return;
+    }
+    console.log(`${label}:`);
+    for (const item of items) {
+        console.log(`- ${item}`);
+    }
+}
 function printAppText(ref, app) {
     console.log(`[app] ${ref}`);
     console.log(`Display name: ${(0, output_1.formatOptionalValue)(app.displayName)}`);
@@ -90,6 +101,17 @@ function printAppText(ref, app) {
     console.log(`Updated: ${(0, output_1.formatTimestamp)(app.updatedAt)}`);
     console.log(`Current version: ${(0, output_1.formatOptionalValue)(app.currentVersion)}`);
     console.log(`Tags: ${formatTagSummary(app.tags)}`);
+    console.log(`Owned assets: ${app.dependencies?.ownedAssets.length ?? 0}`);
+    console.log(`Direct assets: ${app.dependencies?.directAssets.length ?? 0}`);
+    console.log(`Packs: ${app.dependencies?.packs.length ?? 0}`);
+    printAppDependencyLines('Registered assets', (app.dependencies?.ownedAssets ?? []).map((item) => {
+        const runtimeKey = typeof item.runtimeKey === 'string' && item.runtimeKey.trim().length > 0
+            ? `runtimeKey=${item.runtimeKey} `
+            : '';
+        return `${runtimeKey}${item.assetRef}`;
+    }));
+    printAppDependencyLines('Linked assets', (app.dependencies?.directAssets ?? []).map((item) => item.assetRef));
+    printAppDependencyLines('Linked packs', (app.dependencies?.packs ?? []).map((item) => item.packRef));
     console.log(`Play URL: ${(0, output_1.formatOptionalValue)(app.urls.play)}`);
     console.log(`Source URL: ${(0, output_1.formatOptionalValue)(app.urls.source)}`);
     console.log('\nNext: run "playdrop versions browse ' + ref + '" to inspect version history.');
@@ -156,7 +178,7 @@ async function detail(rawRef, options = {}) {
         try {
             if (ref.kind === 'app') {
                 const response = await client.fetchAppBySlug(ref.creator, ref.name);
-                const item = decorateApp(response.app, envConfig.webBase);
+                const item = decorateApp(response.app, envConfig.webBase, response.dependencies);
                 if (options.json) {
                     (0, output_1.printJson)({ kind: ref.kind, ref: ref.ref, item });
                     return;

package/dist/commands/dev.d.ts

@@ -1 +1,8 @@
-export declare function dev(targetArg: string | undefined, _port?: number, appOption?: string): Promise<void>;
+export declare function formatDevRuntimeAssetManifestFailure(error: unknown): {
+    message: string;
+    suggestions: string[];
+};
+export declare function dev(targetArg: string | undefined, _port?: number, appOption?: string, devOptions?: {
+    devAuth?: string;
+    player?: string | number;
+}): Promise<void>;