@playdrop/playdrop-cli 0.3.16 → 0.4.1

package/config/client-meta.json

@@ -1,6 +1,6 @@
 {
-  "version": "0.3.16",
-  "build": 1,
+  "version": "0.4.1",
+  "build": 3,
   "platforms": {
     "ios": {
       "minimumVersion": "16.0"
@@ -26,19 +26,19 @@
   },
   "clients": {
     "web": {
-      "minimumVersion": "0.3.16",
-      "minimumBuild": 1
+      "minimumVersion": "0.4.1",
+      "minimumBuild": 3
     },
     "admin": {
-      "minimumVersion": "0.3.16",
-      "minimumBuild": 1
+      "minimumVersion": "0.4.1",
+      "minimumBuild": 3
     },
     "apple": {
       "minimumVersion": "0.3.10",
       "minimumBuild": 1
     },
     "cli": {
-      "minimumVersion": "0.3.16"
+      "minimumVersion": "0.4.1"
     }
   }
 }

package/dist/appUrls.d.ts

@@ -0,0 +1,9 @@
+import type { AppType } from '@playdrop/types';
+export type AppUrlInput = {
+    creatorUsername: string;
+    appName: string;
+    appType?: AppType | string | null;
+};
+export declare function normalizePlaydropWebBase(webBase?: string | null): string;
+export declare function getAppTypeSlug(type: AppType | string | null | undefined): string;
+export declare function buildPlatformPlayUrl(webBase: string | null | undefined, input: AppUrlInput): string;

package/dist/appUrls.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePlaydropWebBase = normalizePlaydropWebBase;
+exports.getAppTypeSlug = getAppTypeSlug;
+exports.buildPlatformPlayUrl = buildPlatformPlayUrl;
+const DEFAULT_WEB_BASE = 'https://www.playdrop.ai';
+function normalizePlaydropWebBase(webBase) {
+    const base = typeof webBase === 'string' && webBase.trim().length > 0 ? webBase.trim() : DEFAULT_WEB_BASE;
+    return base.replace(/\/$/, '');
+}
+function getAppTypeSlug(type) {
+    if (typeof type !== 'string') {
+        return 'game';
+    }
+    switch (type) {
+        case 'DEMO':
+            return 'demo';
+        case 'TOOL':
+            return 'tool';
+        case 'TEMPLATE':
+            return 'template';
+        case 'GAME':
+        default:
+            return 'game';
+    }
+}
+function buildPlatformPlayUrl(webBase, input) {
+    const base = normalizePlaydropWebBase(webBase);
+    const creator = encodeURIComponent(input.creatorUsername);
+    const typeSlug = getAppTypeSlug(input.appType);
+    const appName = encodeURIComponent(input.appName);
+    return `${base}/creators/${creator}/apps/${typeSlug}/${appName}/play`;
+}

package/dist/browser.d.ts

@@ -0,0 +1,5 @@
+type OpenBrowserFn = (url: string) => Promise<boolean>;
+export declare function openBrowserUrl(url: string): Promise<boolean>;
+export declare function setOpenBrowserForTests(fn: OpenBrowserFn): void;
+export declare function resetOpenBrowserForTests(): void;
+export {};

package/dist/browser.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openBrowserUrl = openBrowserUrl;
+exports.setOpenBrowserForTests = setOpenBrowserForTests;
+exports.resetOpenBrowserForTests = resetOpenBrowserForTests;
+const node_child_process_1 = require("node:child_process");
+function getBrowserCommand(url) {
+    if (process.platform === 'darwin') {
+        return { command: 'open', args: [url] };
+    }
+    if (process.platform === 'win32') {
+        return { command: 'cmd', args: ['/c', 'start', '', url] };
+    }
+    if (process.platform === 'linux') {
+        return { command: 'xdg-open', args: [url] };
+    }
+    return null;
+}
+async function defaultOpenBrowser(url) {
+    const command = getBrowserCommand(url);
+    if (!command) {
+        return false;
+    }
+    return await new Promise((resolve) => {
+        const child = (0, node_child_process_1.spawn)(command.command, command.args, {
+            detached: true,
+            stdio: 'ignore',
+        });
+        child.once('error', () => resolve(false));
+        child.once('spawn', () => {
+            child.unref();
+            resolve(true);
+        });
+    });
+}
+let openBrowser = defaultOpenBrowser;
+async function openBrowserUrl(url) {
+    return await openBrowser(url);
+}
+function setOpenBrowserForTests(fn) {
+    openBrowser = fn;
+}
+function resetOpenBrowserForTests() {
+    openBrowser = defaultOpenBrowser;
+}

package/dist/captureRuntime.d.ts

@@ -0,0 +1,31 @@
+import type { UserResponse } from '@playdrop/types';
+import type { BrowserContextOptions } from 'playwright-core';
+export type CaptureLogLevel = 'debug' | 'info' | 'warn' | 'error';
+export declare const CAPTURE_LOG_LEVEL_VALUES: CaptureLogLevel[];
+export declare const MAX_CAPTURE_TIMEOUT_SECONDS = 600;
+type LoginOptions = {
+    username: string;
+    password: string;
+    loginUrl?: string | null;
+};
+export type RunCaptureOptions = {
+    targetUrl: string;
+    expectedUrl?: string | null;
+    timeoutMs: number;
+    minimumLogLevel: CaptureLogLevel;
+    screenshotPath?: string | null;
+    logPath?: string | null;
+    contextOptions?: BrowserContextOptions;
+    token?: string | null;
+    user?: UserResponse | null;
+    login?: LoginOptions | null;
+    enableCaptureBridge?: boolean;
+};
+export type CaptureRunResult = {
+    errorCount: number;
+    finalUrl: string;
+};
+export declare function resolveCaptureLogLevel(value: string | undefined): CaptureLogLevel;
+export declare function validateCaptureTimeout(value: number | undefined): number;
+export declare function runCapture(options: RunCaptureOptions): Promise<CaptureRunResult>;
+export {};

package/dist/captureRuntime.js

@@ -0,0 +1,414 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_CAPTURE_TIMEOUT_SECONDS = exports.CAPTURE_LOG_LEVEL_VALUES = void 0;
+exports.resolveCaptureLogLevel = resolveCaptureLogLevel;
+exports.validateCaptureTimeout = validateCaptureTimeout;
+exports.runCapture = runCapture;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const playwright_1 = require("./playwright");
+const ACCESS_TOKEN_COOKIE_NAME = 'playdrop_access_token';
+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) {
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'number' || typeof value === 'boolean' || value === null) {
+        return String(value);
+    }
+    if (typeof value === 'undefined') {
+        return 'undefined';
+    }
+    if (typeof value === 'function') {
+        return '[function]';
+    }
+    if (typeof value === 'object') {
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            return '[object]';
+        }
+    }
+    return String(value);
+}
+function serializePayload(payload) {
+    if (payload === undefined) {
+        return '';
+    }
+    if (typeof payload === 'string') {
+        return payload;
+    }
+    try {
+        return JSON.stringify(payload);
+    }
+    catch {
+        return String(payload);
+    }
+}
+function severityOrder(level) {
+    switch (level) {
+        case 'debug':
+            return 0;
+        case 'info':
+            return 1;
+        case 'warn':
+            return 2;
+        case 'error':
+            return 3;
+        default:
+            return 1;
+    }
+}
+function mapConsoleTypeToLevel(type) {
+    const normalized = type.toLowerCase();
+    if (normalized === 'debug')
+        return 'debug';
+    if (normalized === 'warning' || normalized === 'warn')
+        return 'warn';
+    if (normalized === 'error' || normalized === 'assert' || normalized === 'trace')
+        return 'error';
+    return 'info';
+}
+function shouldEmit(level, threshold) {
+    return severityOrder(level) >= severityOrder(threshold);
+}
+function normalizeComparableUrl(rawUrl) {
+    const parsed = new URL(rawUrl);
+    const pathname = parsed.pathname.replace(/\/+$/, '') || '/';
+    return `${parsed.origin}${pathname}`;
+}
+async function writeLogFile(logPath, lines) {
+    if (!logPath || logPath.trim().length === 0) {
+        return;
+    }
+    await (0, promises_1.mkdir)((0, node_path_1.dirname)(logPath), { recursive: true });
+    await (0, promises_1.writeFile)(logPath, `${lines.join('\n')}\n`, 'utf8');
+    console.log(`[capture] Saved logs to ${(0, node_path_1.relative)(process.cwd(), logPath) || logPath}`);
+}
+function resolveCaptureLogLevel(value) {
+    if (!value)
+        return 'info';
+    const normalized = value.trim().toLowerCase();
+    if (exports.CAPTURE_LOG_LEVEL_VALUES.includes(normalized)) {
+        return normalized;
+    }
+    throw new Error(`Unsupported log level "${value}". Choose one of: ${exports.CAPTURE_LOG_LEVEL_VALUES.join(', ')}`);
+}
+function validateCaptureTimeout(value) {
+    if (value === undefined || Number.isNaN(value)) {
+        return 5;
+    }
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new Error('Timeout must be a positive number of seconds.');
+    }
+    if (value > exports.MAX_CAPTURE_TIMEOUT_SECONDS) {
+        throw new Error(`Timeout cannot exceed ${exports.MAX_CAPTURE_TIMEOUT_SECONDS} seconds (10 minutes).`);
+    }
+    return value;
+}
+async function runCapture(options) {
+    const errors = [];
+    const outputLines = [];
+    const expectedUrl = options.expectedUrl ? normalizeComparableUrl(options.expectedUrl) : null;
+    const hasExplicitLogin = Boolean(options.login?.username);
+    const bootstrapToken = hasExplicitLogin ? null : options.token?.trim() || null;
+    const bootstrapUser = hasExplicitLogin ? null : options.user ?? null;
+    let finalUrl = options.targetUrl;
+    const record = (level, message) => {
+        const line = `[capture][${level}] ${message}`;
+        outputLines.push(line);
+        if (level === 'error') {
+            console.error(line);
+            return;
+        }
+        if (level === 'warn') {
+            console.warn(line);
+            return;
+        }
+        if (level === 'debug') {
+            console.debug(line);
+            return;
+        }
+        console.log(line);
+    };
+    const recordError = (message) => {
+        errors.push(message);
+        record('error', message);
+    };
+    try {
+        await (0, playwright_1.withChromiumPage)(async ({ context, page }) => {
+            const targetOrigin = new URL(options.targetUrl).origin;
+            if (bootstrapToken) {
+                await context.addCookies([
+                    {
+                        name: ACCESS_TOKEN_COOKIE_NAME,
+                        value: bootstrapToken,
+                        url: targetOrigin,
+                        path: '/',
+                    },
+                ]);
+            }
+            if (bootstrapToken || bootstrapUser) {
+                await page.addInitScript(({ token, user }) => {
+                    try {
+                        if (token) {
+                            window.localStorage.setItem('playdrop.accessToken', token);
+                        }
+                    }
+                    catch {
+                        // ignore storage errors
+                    }
+                    try {
+                        if (user) {
+                            window.localStorage.setItem('playdrop.user', JSON.stringify(user));
+                        }
+                    }
+                    catch {
+                        // ignore storage errors
+                    }
+                    try {
+                        window.sessionStorage.removeItem('playdrop.logoutReason');
+                    }
+                    catch {
+                        // ignore storage errors
+                    }
+                }, { token: bootstrapToken, user: bootstrapUser });
+            }
+            if (options.enableCaptureBridge) {
+                await page.exposeBinding('__playdropCaptureLog', async (_source, type, payload) => {
+                    const normalized = typeof type === 'string' ? type.toLowerCase() : 'info';
+                    const level = normalized === 'error' || normalized === 'fatal'
+                        ? 'error'
+                        : normalized === 'warn' || normalized === 'warning'
+                            ? 'warn'
+                            : normalized === 'debug'
+                                ? 'debug'
+                                : 'info';
+                    const serialized = serializePayload(payload);
+                    const line = ['[capture][custom]', normalized, serialized].filter(Boolean).join(' ');
+                    if (level === 'error') {
+                        errors.push(line);
+                        if (shouldEmit(level, options.minimumLogLevel)) {
+                            console.error(line);
+                        }
+                        outputLines.push(line);
+                        return;
+                    }
+                    outputLines.push(line);
+                    if (!shouldEmit(level, options.minimumLogLevel)) {
+                        return;
+                    }
+                    if (level === 'warn') {
+                        console.warn(line);
+                    }
+                    else if (level === 'debug') {
+                        console.debug(line);
+                    }
+                    else {
+                        console.log(line);
+                    }
+                });
+                await page.addInitScript(() => {
+                    window.addEventListener('unhandledrejection', event => {
+                        try {
+                            console.error('[capture][unhandledrejection]', event.reason);
+                        }
+                        catch {
+                            console.error('[capture][unhandledrejection]');
+                        }
+                    });
+                    const bridgeWindow = window;
+                    bridgeWindow.playdrop = bridgeWindow.playdrop || {};
+                    const bridge = (type, payload) => {
+                        try {
+                            const binding = bridgeWindow.__playdropCaptureLog;
+                            if (typeof binding === 'function') {
+                                binding(type, payload);
+                            }
+                        }
+                        catch (error) {
+                            console.error('[capture][bridge-error]', error);
+                        }
+                    };
+                    Object.defineProperty(bridgeWindow.playdrop, 'capture', {
+                        value: bridge,
+                        configurable: true,
+                        writable: true,
+                    });
+                });
+            }
+            const handleConsoleMessage = async (message) => {
+                const type = message.type();
+                const level = mapConsoleTypeToLevel(type);
+                const args = await Promise.all(message.args().map(arg => arg.jsonValue().catch(() => arg.toString())));
+                const rendered = args.length > 0 ? args.map(formatConsoleValue).join(' ') : message.text();
+                const line = `[capture][console:${type}] ${rendered}`;
+                outputLines.push(line);
+                let effectiveLevel = level;
+                if (level === 'warn' && line.includes('GL Driver Message')) {
+                    effectiveLevel = 'debug';
+                }
+                if (type === 'error' || type === 'assert' || type === 'trace') {
+                    errors.push(line);
+                    if (shouldEmit(effectiveLevel, options.minimumLogLevel)) {
+                        console.error(line);
+                    }
+                    return;
+                }
+                if (!shouldEmit(effectiveLevel, options.minimumLogLevel)) {
+                    return;
+                }
+                if (effectiveLevel === 'warn') {
+                    console.warn(line);
+                }
+                else if (effectiveLevel === 'debug') {
+                    console.debug(line);
+                }
+                else if (effectiveLevel === 'info') {
+                    console.info(line);
+                }
+                else {
+                    console.log(line);
+                }
+            };
+            page.on('console', message => {
+                void handleConsoleMessage(message);
+            });
+            page.on('pageerror', error => {
+                const text = error?.message ?? String(error);
+                errors.push(text);
+                outputLines.push(`[capture][pageerror] ${text}`);
+                if (shouldEmit('error', options.minimumLogLevel)) {
+                    console.error(`[capture][pageerror] ${text}`);
+                }
+            });
+            page.on('requestfailed', request => {
+                const failure = request.failure();
+                const errorText = failure?.errorText ?? '';
+                const text = `${request.method()} ${request.url()} - ${errorText || 'failed'}`;
+                if (/ERR_ABORTED/i.test(errorText) || /ERR_HTTP2_PROTOCOL_ERROR/i.test(errorText)) {
+                    const line = `[capture][requestcancelled] ${text}`;
+                    outputLines.push(line);
+                    if (shouldEmit('debug', options.minimumLogLevel)) {
+                        console.debug(line);
+                    }
+                    return;
+                }
+                errors.push(text);
+                outputLines.push(`[capture][requestfailed] ${text}`);
+                if (shouldEmit('warn', options.minimumLogLevel)) {
+                    console.error(`[capture][requestfailed] ${text}`);
+                }
+            });
+            page.on('response', response => {
+                const status = response.status();
+                if (status < 400) {
+                    return;
+                }
+                const text = `${status} ${response.statusText()} ${response.url()}`;
+                if (status === 404 && /\\?playdrop_channel=/.test(response.url())) {
+                    const line = `[capture][response-reload] ${text}`;
+                    outputLines.push(line);
+                    if (shouldEmit('debug', options.minimumLogLevel)) {
+                        console.debug(line);
+                    }
+                    return;
+                }
+                errors.push(text);
+                outputLines.push(`[capture][response] ${text}`);
+                if (shouldEmit('warn', options.minimumLogLevel)) {
+                    console.error(`[capture][response] ${text}`);
+                }
+            });
+            if (options.login?.username) {
+                const loginUrl = options.login.loginUrl?.trim() || `${targetOrigin}/login`;
+                record('info', `Opening login page ${loginUrl}`);
+                await page.goto(loginUrl, { waitUntil: 'domcontentloaded', timeout: 30000 });
+                await page.waitForLoadState('networkidle', { timeout: 30000 });
+                await page.fill('input[name="username"]', options.login.username);
+                await page.fill('input[name="password"]', options.login.password);
+                await page.getByRole('button', { name: 'Login' }).click();
+                await page.waitForURL((url) => {
+                    try {
+                        return !new URL(url.toString()).pathname.startsWith('/login');
+                    }
+                    catch {
+                        return false;
+                    }
+                }, { timeout: 30000 });
+                await page.waitForLoadState('networkidle', { timeout: 30000 });
+                record('info', 'Login succeeded');
+            }
+            record('info', `Opening ${options.targetUrl}`);
+            const response = await page.goto(options.targetUrl, { waitUntil: 'domcontentloaded', timeout: 30000 });
+            if (response && !response.ok()) {
+                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 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';
+                }
+                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.');
+            }
+            const assertPageState = async () => {
+                const currentUrl = page.url();
+                if (!currentUrl) {
+                    throw new Error('Capture page did not finish loading a URL.');
+                }
+                const finalComparableUrl = normalizeComparableUrl(currentUrl);
+                if (expectedUrl && finalComparableUrl !== expectedUrl) {
+                    throw new Error(`Capture landed on ${finalComparableUrl} instead of ${expectedUrl}.`);
+                }
+                const finalPathname = new URL(currentUrl).pathname;
+                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) {
+                    throw new Error('The Playdrop app frame never appeared.');
+                }
+                return currentUrl;
+            };
+            finalUrl = await assertPageState();
+            await page.waitForTimeout(options.timeoutMs);
+            finalUrl = await assertPageState();
+            if (options.screenshotPath) {
+                const targetDir = (0, node_path_1.dirname)(options.screenshotPath);
+                if (targetDir && targetDir !== '.' && targetDir !== '/') {
+                    await (0, promises_1.mkdir)(targetDir, { recursive: true });
+                }
+                await page.screenshot({ path: options.screenshotPath, fullPage: true });
+                console.log(`[capture] Saved screenshot to ${(0, node_path_1.relative)(process.cwd(), options.screenshotPath) || options.screenshotPath}`);
+            }
+        }, options.contextOptions ?? {});
+    }
+    finally {
+        await writeLogFile(options.logPath, outputLines);
+    }
+    return {
+        errorCount: errors.length,
+        finalUrl,
+    };
+}

package/dist/commands/browse.js

@@ -365,7 +365,7 @@ async function browse(options = {}) {
                     if (apiError.status === 401 || apiError.status === 403) {
                         return {
                             problem: 'Browsing this content requires you to be logged in.',
-                            suggestions: ['Run "playdrop login" and retry.'],
+                            suggestions: ['Run "playdrop auth login" and retry.'],
                         };
                     }
                     return {