@playdrop/playdrop-cli 0.3.4-build.1 → 0.3.8-build.1

package/dist/commands/browse.js

@@ -0,0 +1,370 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.browse = browse;
+exports.browseCategories = browseCategories;
+const types_1 = require("@playdrop/types");
+const commandContext_1 = require("../commandContext");
+const errors_1 = require("../errors");
+const messages_1 = require("../messages");
+const output_1 = require("../output");
+const refs_1 = require("../refs");
+const MERGED_PAGE_SIZE = 100;
+function parseBrowseKind(raw) {
+    if (!raw || raw.trim().length === 0) {
+        return 'all';
+    }
+    const normalized = raw.trim().toLowerCase();
+    if (normalized === 'app' || normalized === 'asset' || normalized === 'asset-pack' || normalized === 'all') {
+        return normalized;
+    }
+    return null;
+}
+function parseBrowseCreator(raw) {
+    if (!raw || raw.trim().length === 0) {
+        return 'all';
+    }
+    const normalized = raw.trim();
+    const lowered = normalized.toLowerCase();
+    if (lowered === 'all' || lowered === 'me') {
+        return lowered;
+    }
+    if (normalized.includes('/') || normalized.includes('\\') || normalized.includes('..')) {
+        return null;
+    }
+    return normalized;
+}
+function parsePositiveInteger(raw, label, fallback) {
+    if (raw === undefined) {
+        return fallback;
+    }
+    const parsed = typeof raw === 'number' ? raw : Number.parseInt(String(raw), 10);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+        return null;
+    }
+    if (label === 'limit' && parsed <= 0) {
+        return null;
+    }
+    return parsed;
+}
+function parseAssetCategory(raw) {
+    if (!raw || raw.trim().length === 0) {
+        return undefined;
+    }
+    const normalized = raw.trim().toUpperCase().replace(/[-\s]/g, '_');
+    if (normalized === '3D' || normalized === 'MODEL3D') {
+        return 'MODEL_3D';
+    }
+    if (types_1.ASSET_CATEGORY_VALUES.includes(normalized)) {
+        return normalized;
+    }
+    return null;
+}
+function parseAssetSubcategory(raw) {
+    if (!raw || raw.trim().length === 0) {
+        return undefined;
+    }
+    const normalized = (0, types_1.normalizeAssetSubcategory)(raw);
+    return normalized || null;
+}
+function buildItemRef(kind, creator, name) {
+    return `${creator}/${kind}/${name}`;
+}
+function toBrowseItem(kind, item) {
+    return {
+        kind,
+        ref: buildItemRef(kind, item.creatorUsername, item.name),
+        item: item,
+    };
+}
+function itemSummary(item) {
+    if (item.kind === 'app') {
+        return item.item.type.toLowerCase();
+    }
+    if (item.kind === 'asset') {
+        const subcategory = item.item.currentVersion?.subcategory;
+        return subcategory ? `${item.item.category.toLowerCase()}/${subcategory}` : item.item.category.toLowerCase();
+    }
+    return 'asset-pack';
+}
+async function collectPaginatedItems(fetchPage) {
+    const items = [];
+    let offset = 0;
+    let lastPagination = null;
+    while (true) {
+        const page = await fetchPage(MERGED_PAGE_SIZE, offset);
+        items.push(...page.items);
+        lastPagination = page.pagination;
+        if (!page.pagination.hasMore) {
+            break;
+        }
+        if (page.pagination.limit <= 0) {
+            throw new Error('invalid_pagination_limit');
+        }
+        offset += page.pagination.limit;
+    }
+    return {
+        items,
+        pagination: lastPagination ?? { limit: MERGED_PAGE_SIZE, offset: 0, count: 0, hasMore: false },
+    };
+}
+function sliceMergedItems(items, limit, offset) {
+    const count = items.length;
+    return {
+        items: items.slice(offset, offset + limit),
+        pagination: {
+            limit,
+            offset,
+            count,
+            hasMore: offset + limit < count,
+        },
+    };
+}
+async function resolveCreatorUsername(creator, command, resolveMe) {
+    if (creator === 'all') {
+        return null;
+    }
+    if (creator === 'me') {
+        try {
+            return await resolveMe();
+        }
+        catch (error) {
+            if (error instanceof types_1.ApiError && (error.status === 401 || error.status === 403)) {
+                (0, messages_1.printLoginRequired)('Browsing your content', command);
+                process.exitCode = 1;
+                return null;
+            }
+            throw error;
+        }
+    }
+    return creator;
+}
+async function browse(options = {}) {
+    const kind = parseBrowseKind(options.kind);
+    if (!kind) {
+        (0, messages_1.printErrorWithHelp)(`Kind "${options.kind ?? ''}" is not supported.`, ['Use one of: app, asset, asset-pack, all.'], { command: 'browse' });
+        process.exitCode = 1;
+        return;
+    }
+    const creator = parseBrowseCreator(options.creator);
+    if (!creator) {
+        (0, messages_1.printErrorWithHelp)('The --creator value is invalid.', ['Use all, me, or a creator slug without path separators.'], { command: 'browse' });
+        process.exitCode = 1;
+        return;
+    }
+    const appType = options.appType ? (0, types_1.parseAppType)(options.appType.trim().toUpperCase()) : undefined;
+    if (options.appType !== undefined && !appType) {
+        (0, messages_1.printErrorWithHelp)(`App type "${options.appType}" is not supported.`, ['Use one of: game, demo, tool, template.'], { command: 'browse' });
+        process.exitCode = 1;
+        return;
+    }
+    const assetCategory = parseAssetCategory(options.assetCategory);
+    if (assetCategory === null) {
+        (0, messages_1.printErrorWithHelp)(`Asset category "${options.assetCategory}" is not supported.`, ['Use a canonical asset category like IMAGE, VIDEO, AUDIO, SPRITESHEET, or MODEL_3D.'], { command: 'browse' });
+        process.exitCode = 1;
+        return;
+    }
+    const assetSubcategory = parseAssetSubcategory(options.assetSubcategory);
+    if (assetSubcategory === null) {
+        (0, messages_1.printErrorWithHelp)(`Asset subcategory "${options.assetSubcategory}" is invalid.`, ['Use lowercase slug values like generic, avatar, music, or sfx.'], { command: 'browse' });
+        process.exitCode = 1;
+        return;
+    }
+    const limit = parsePositiveInteger(options.limit, 'limit', 10);
+    if (limit === null) {
+        (0, messages_1.printErrorWithHelp)('The --limit value must be a positive integer.', ['Example: --limit 10'], { command: 'browse' });
+        process.exitCode = 1;
+        return;
+    }
+    const offset = parsePositiveInteger(options.offset, 'offset', 0);
+    if (offset === null) {
+        (0, messages_1.printErrorWithHelp)('The --offset value must be zero or a positive integer.', ['Example: --offset 20'], { command: 'browse' });
+        process.exitCode = 1;
+        return;
+    }
+    await (0, commandContext_1.withPublicEnvironment)('browse', async ({ client }) => {
+        try {
+            const creatorUsername = await resolveCreatorUsername(creator, 'browse', async () => {
+                const response = await client.me();
+                const username = response.user?.username?.trim();
+                if (!username) {
+                    throw new Error('missing_current_user');
+                }
+                return username;
+            });
+            if (process.exitCode) {
+                return;
+            }
+            const items = [];
+            let pagination;
+            if (kind === 'app') {
+                let apps = [];
+                if (creatorUsername) {
+                    if (creator === 'me') {
+                        const response = await client.fetchMyApps();
+                        apps = response.apps ?? [];
+                    }
+                    else {
+                        const response = await client.fetchAppsByCreator(creatorUsername);
+                        apps = response.apps ?? [];
+                    }
+                }
+                else if (appType) {
+                    const response = await client.fetchAppsByType(appType);
+                    apps = response.apps ?? [];
+                }
+                else {
+                    const response = await client.fetchApps();
+                    apps = response.apps ?? [];
+                }
+                const filtered = appType ? apps.filter((app) => app.type === appType) : apps;
+                const sliced = sliceMergedItems(filtered, limit, offset);
+                items.push(...sliced.items.map((item) => toBrowseItem('app', item)));
+                pagination = sliced.pagination;
+            }
+            else if (kind === 'asset') {
+                const response = creatorUsername
+                    ? await client.listAssetsForCreator(creatorUsername, { limit, offset, category: assetCategory, subcategory: assetSubcategory })
+                    : await client.listAssets({ limit, offset, category: assetCategory, subcategory: assetSubcategory });
+                items.push(...(response.assets ?? []).map((item) => toBrowseItem('asset', item)));
+                pagination = response.pagination;
+            }
+            else if (kind === 'asset-pack') {
+                const response = creatorUsername
+                    ? await client.listAssetPacksForCreator(creatorUsername, { limit, offset, containsCategory: assetCategory, containsSubcategory: assetSubcategory })
+                    : await client.listAssetPacks({ limit, offset, containsCategory: assetCategory, containsSubcategory: assetSubcategory });
+                items.push(...(response.packs ?? []).map((item) => toBrowseItem('asset-pack', item)));
+                pagination = response.pagination;
+            }
+            else {
+                const [apps, assets, packs] = await Promise.all([
+                    creatorUsername
+                        ? (creator === 'me' ? client.fetchMyApps().then((response) => response.apps ?? []) : client.fetchAppsByCreator(creatorUsername).then((response) => response.apps ?? []))
+                        : (appType ? client.fetchAppsByType(appType).then((response) => response.apps ?? []) : client.fetchApps().then((response) => response.apps ?? [])),
+                    creatorUsername
+                        ? collectPaginatedItems((pageLimit, pageOffset) => client.listAssetsForCreator(creatorUsername, {
+                            limit: pageLimit,
+                            offset: pageOffset,
+                            category: assetCategory,
+                            subcategory: assetSubcategory,
+                        }).then((response) => ({
+                            items: response.assets ?? [],
+                            pagination: response.pagination,
+                        })))
+                        : collectPaginatedItems((pageLimit, pageOffset) => client.listAssets({
+                            limit: pageLimit,
+                            offset: pageOffset,
+                            category: assetCategory,
+                            subcategory: assetSubcategory,
+                        }).then((response) => ({
+                            items: response.assets ?? [],
+                            pagination: response.pagination,
+                        }))),
+                    creatorUsername
+                        ? collectPaginatedItems((pageLimit, pageOffset) => client.listAssetPacksForCreator(creatorUsername, {
+                            limit: pageLimit,
+                            offset: pageOffset,
+                            containsCategory: assetCategory,
+                            containsSubcategory: assetSubcategory,
+                        }).then((response) => ({
+                            items: response.packs ?? [],
+                            pagination: response.pagination,
+                        })))
+                        : collectPaginatedItems((pageLimit, pageOffset) => client.listAssetPacks({
+                            limit: pageLimit,
+                            offset: pageOffset,
+                            containsCategory: assetCategory,
+                            containsSubcategory: assetSubcategory,
+                        }).then((response) => ({
+                            items: response.packs ?? [],
+                            pagination: response.pagination,
+                        }))),
+                ]);
+                const combined = [
+                    ...(appType ? apps.filter((app) => app.type === appType) : apps).map((item) => toBrowseItem('app', item)),
+                    ...assets.items.map((item) => toBrowseItem('asset', item)),
+                    ...packs.items.map((item) => toBrowseItem('asset-pack', item)),
+                ];
+                const sliced = sliceMergedItems(combined, limit, offset);
+                items.push(...sliced.items);
+                pagination = sliced.pagination;
+            }
+            if (options.json) {
+                (0, output_1.printJson)({
+                    items,
+                    ...(pagination ? { pagination } : {}),
+                });
+                return;
+            }
+            if (items.length === 0) {
+                const label = kind === 'all' ? 'content' : (0, refs_1.contentKindPluralLabel)(kind);
+                console.log(`No ${label} found.`);
+                console.log('Next: adjust your filters or run "playdrop search <query>" to look for something specific.');
+                return;
+            }
+            if (kind === 'all') {
+                console.log('Browsing content (apps, then assets, then asset packs):\n');
+            }
+            else {
+                console.log(`Browsing ${(0, refs_1.contentKindPluralLabel)(kind)}:\n`);
+            }
+            for (const [index, item] of items.entries()) {
+                const displayName = item.item.displayName || item.item.name;
+                console.log(`${index + 1}. [${item.kind}] ${item.ref} | ${displayName} | @${item.item.creatorUsername} | ${itemSummary(item)}`);
+            }
+            console.log('\nNext: run "playdrop detail <creator>/<kind>/<name>" to inspect one item.');
+        }
+        catch (error) {
+            const handled = (0, errors_1.handleCommandFailure)(error, 'browse', 'Browse', {
+                apiMessage: (apiError) => {
+                    if (apiError.status === 401 || apiError.status === 403) {
+                        return {
+                            problem: 'Browsing this content requires you to be logged in.',
+                            suggestions: ['Run "playdrop auth login" and retry.'],
+                        };
+                    }
+                    return {
+                        problem: `Browse failed with status ${apiError.status}.`,
+                        suggestions: ['Retry in a moment.', 'Use "playdrop help browse" for usage details.'],
+                    };
+                },
+            });
+            if (!handled) {
+                throw error;
+            }
+        }
+    });
+}
+async function browseCategories(options = {}) {
+    await (0, commandContext_1.withPublicEnvironment)('browse categories', async ({ client }) => {
+        try {
+            const response = await client.listAssetCategories();
+            const items = response.categories ?? [];
+            if (options.json) {
+                (0, output_1.printJson)({ items });
+                return;
+            }
+            if (items.length === 0) {
+                console.log('No asset categories were returned.');
+                return;
+            }
+            console.log('Asset categories:\n');
+            for (const item of items) {
+                const formats = Array.isArray(item.formats) ? item.formats.join(', ') : 'none';
+                console.log(`${item.category} / ${item.subcategory}`);
+                console.log(`  Formats: ${formats}`);
+            }
+            console.log('\nNext: use these values with "playdrop browse" or "playdrop search".');
+        }
+        catch (error) {
+            const handled = (0, errors_1.handleCommandFailure)(error, 'browse categories', 'Browse categories', {
+                apiMessage: (apiError) => ({
+                    problem: `Category lookup failed with status ${apiError.status}.`,
+                    suggestions: ['Retry in a moment.'],
+                }),
+            });
+            if (!handled) {
+                throw error;
+            }
+        }
+    });
+}

package/dist/commands/build.js

@@ -9,7 +9,7 @@ const model_artifacts_1 = require("../assets/model-artifacts");
 async function build(pathOrName) {
     const selection = (0, taskSelection_1.selectTasks)(pathOrName);
     if (selection.errors.length > 0) {
-        (0, taskSelection_1.reportTaskErrors)(selection.errors, 'build');
+        (0, taskSelection_1.reportTaskErrors)(selection.errors, 'project build');
         process.exitCode = 1;
         return;
     }
@@ -23,8 +23,6 @@ async function build(pathOrName) {
     for (const task of (0, taskUtils_1.sortTasks)(tasks)) {
         const entityId = task.name;
         try {
-            let skipped = false;
-            let detail;
             if (task.kind === 'app') {
                 await (0, apps_1.validateAppTask)(task);
                 await (0, apps_1.buildApp)(task);
@@ -32,21 +30,18 @@ async function build(pathOrName) {
             else if (task.kind === 'asset' || task.kind === 'embedded-asset') {
                 const generated = await (0, model_artifacts_1.prepareModel3DAssetArtifacts)(task);
                 if (!generated) {
-                    skipped = true;
-                    detail = `no build step for ${task.kind}`;
+                    throw new Error(`project build does not support ${task.kind} "${entityId}" because it has no local build step.`);
                 }
             }
             else {
-                skipped = true;
-                detail = `no build step for ${task.kind}`;
+                throw new Error(`project build does not support ${task.kind} "${entityId}".`);
             }
             const entry = {
                 action: 'build',
-                status: skipped ? 'skipped' : 'success',
+                status: 'success',
                 entityType: task.kind,
                 entityId,
                 catalogue: task.cataloguePath,
-                detail,
             };
             results.push(entry);
             console.log((0, uploadLog_1.formatTaskLogLine)(entry));

package/dist/commands/capture.js

@@ -193,7 +193,7 @@ async function capture(targetArg, options = {}) {
         minimumLogLevel = resolveLogLevel(options.logLevel);
     }
     catch (error) {
-        (0, messages_1.printErrorWithHelp)(error?.message || 'Invalid log level.', [`Valid values: ${LOG_LEVEL_VALUES.join(', ')}`], { command: 'capture' });
+        (0, messages_1.printErrorWithHelp)(error?.message || 'Invalid log level.', [`Valid values: ${LOG_LEVEL_VALUES.join(', ')}`], { command: 'project capture' });
         process.exitCode = 1;
         return;
     }
@@ -202,19 +202,19 @@ async function capture(targetArg, options = {}) {
         : null;
     const cfg = (0, config_1.loadConfig)();
     if (!cfg.env) {
-        (0, messages_1.printConfigEnvironmentMissing)('capture');
+        (0, messages_1.printConfigEnvironmentMissing)('project capture');
         process.exitCode = 1;
         return;
     }
     if (!cfg.token) {
-        (0, messages_1.printLoginRequired)('Capturing app logs', 'capture');
+        (0, messages_1.printLoginRequired)('Capturing app logs', 'project capture');
         process.exitCode = 1;
         return;
     }
     const envConfig = (0, environment_1.resolveEnvironmentConfig)(cfg.env);
     if (!envConfig) {
         const choices = (0, environment_1.formatEnvironmentList)();
-        (0, messages_1.printUnknownEnvironment)(cfg.env, choices, 'capture');
+        (0, messages_1.printUnknownEnvironment)(cfg.env, choices, 'project capture');
         process.exitCode = 1;
         return;
     }
@@ -239,7 +239,7 @@ async function capture(targetArg, options = {}) {
                 suggestions = ['Confirm the app exists in catalogue.json, use "--app <name>", or pass the direct HTML file path.'];
                 break;
             case 'catalogue_missing':
-                suggestions = ['Run "playdrop-cli capture" from a workspace with catalogue.json or provide the HTML file path.'];
+                suggestions = ['Run "playdrop project capture" from a workspace with catalogue.json or provide the HTML file path.'];
                 break;
             case 'invalid_target':
                 suggestions = ['Provide a valid HTML file path or app name.'];
@@ -248,13 +248,13 @@ async function capture(targetArg, options = {}) {
                 suggestions = ['Add at least one app entry to catalogue.json before running capture.'];
                 break;
             case 'invalid_catalogue':
-                suggestions = ['Fix the catalogue.json file and rerun "playdrop-cli capture".'];
+                suggestions = ['Fix the catalogue.json file and rerun "playdrop project capture".'];
                 break;
             default:
                 suggestions = ['Provide an app name, HTML file path, or run inside a Playdrop workspace.'];
                 break;
         }
-        (0, messages_1.printErrorWithHelp)(message, suggestions, { command: 'capture' });
+        (0, messages_1.printErrorWithHelp)(message, suggestions, { command: 'project capture' });
         process.exitCode = 1;
         return;
     }
@@ -263,19 +263,19 @@ async function capture(targetArg, options = {}) {
     if (!(0, node_fs_1.existsSync)(filePath) || !(0, node_fs_1.statSync)(filePath).isFile()) {
         (0, messages_1.printErrorWithHelp)(`App HTML was not found at ${filePath}.`, [
             'Ensure the catalogue entry points to a compiled HTML file or provide the correct file path.'
-        ], { command: 'capture' });
+        ], { command: 'project capture' });
         process.exitCode = 1;
         return;
     }
     const availableSurfaces = resolvedTarget.surfaceTargets;
     const overrideSurface = normalizeSurfaceOverride(options.surfaceTarget);
     if (options.surfaceTarget && !overrideSurface) {
-        (0, messages_1.printErrorWithHelp)(`Unsupported surface target "${options.surfaceTarget}".`, ['Valid values: desktop, mobile-landscape, mobile-portrait'], { command: 'capture' });
+        (0, messages_1.printErrorWithHelp)(`Unsupported surface target "${options.surfaceTarget}".`, ['Valid values: desktop, mobile-landscape, mobile-portrait'], { command: 'project capture' });
         process.exitCode = 1;
         return;
     }
     if (overrideSurface && !availableSurfaces.map[overrideSurface]) {
-        (0, messages_1.printErrorWithHelp)(`Surface target "${options.surfaceTarget}" is not enabled for this app.`, [`Catalogue surfaces: ${formatSurfaceList(availableSurfaces)}`], { command: 'capture' });
+        (0, messages_1.printErrorWithHelp)(`Surface target "${options.surfaceTarget}" is not enabled for this app.`, [`Catalogue surfaces: ${formatSurfaceList(availableSurfaces)}`], { command: 'project capture' });
         process.exitCode = 1;
         return;
     }
@@ -301,8 +301,8 @@ async function capture(targetArg, options = {}) {
         if (resolvedTarget.cataloguePath) {
             (0, messages_1.printErrorWithHelp)(error?.message || 'Catalogue lookup failed.', [
                 'Ensure the HTML file is listed exactly once in catalogue.json with a valid type.',
-                'Run "playdrop-cli create <name>" to scaffold a new entry if needed.',
-            ], { command: 'capture' });
+                'Run "playdrop project create app <name>" to scaffold a new entry if needed.',
+            ], { command: 'project capture' });
             process.exitCode = 1;
             return;
         }
@@ -324,22 +324,22 @@ async function capture(targetArg, options = {}) {
         }
         if (error instanceof types_1.ApiError) {
             (0, messages_1.printErrorWithHelp)(`Could not fetch your account (status ${error.status}).`, [
-                'Run "playdrop-cli login" to refresh your session and ensure the API is reachable.',
-                'Use "playdrop-cli whoami" afterwards to confirm your status.'
-            ], { command: 'capture' });
+                'Run "playdrop auth login" to refresh your session and ensure the API is reachable.',
+                'Use "playdrop auth whoami" afterwards to confirm your status.'
+            ], { command: 'project capture' });
             process.exitCode = 1;
             return;
         }
         if ((0, devShared_1.isNetworkError)(error)) {
-            (0, messages_1.printNetworkIssue)('Could not reach the Playdrop API to resolve your account.', 'capture');
+            (0, messages_1.printNetworkIssue)('Could not reach the Playdrop API to resolve your account.', 'project capture');
             process.exitCode = 1;
             return;
         }
         if (error instanceof Error && error.message === 'DEV_USERNAME_EMPTY') {
             (0, messages_1.printErrorWithHelp)('Could not determine your Playdrop creator username.', [
-                'Retry "playdrop-cli capture" in a moment.',
+                'Retry "playdrop project capture" in a moment.',
                 'If the problem persists, contact the Playdrop team.'
-            ], { command: 'capture' });
+            ], { command: 'project capture' });
             process.exitCode = 1;
             return;
         }
@@ -360,21 +360,21 @@ async function capture(targetArg, options = {}) {
         if (error instanceof types_1.ApiError) {
             if (error.status === 404) {
                 (0, messages_1.printErrorWithHelp)(`App ${currentUsername}/${appName} is not registered on ${cfg.env}.`, [
-                    `Run "playdrop-cli create ${appName}" to register the app before running capture.`,
+                    `Run "playdrop project create app ${appName}" to register the app before running capture.`,
                     'If you expected it to exist, ensure you are logged into the correct environment.'
-                ], { command: 'capture' });
+                ], { command: 'project capture' });
             }
             else {
                 (0, messages_1.printErrorWithHelp)(`Failed to verify app registration (status ${error.status}).`, [
                     'Retry in a moment.',
                     'If the issue persists, contact the Playdrop team.'
-                ], { command: 'capture' });
+                ], { command: 'project capture' });
             }
             process.exitCode = 1;
             return;
         }
         if ((0, devShared_1.isNetworkError)(error)) {
-            (0, messages_1.printNetworkIssue)('Could not reach the Playdrop API to verify the app registration.', 'capture');
+            (0, messages_1.printNetworkIssue)('Could not reach the Playdrop API to verify the app registration.', 'project capture');
             process.exitCode = 1;
             return;
         }
@@ -424,7 +424,7 @@ async function capture(targetArg, options = {}) {
             (0, messages_1.printErrorWithHelp)(error?.message || `Failed to start dev server on port ${portToUse}.`, [
                 'Check if another process is already using the port.',
                 'Ensure the HTML file exists and is readable.',
-            ], { command: 'capture' });
+            ], { command: 'project capture' });
             process.exitCode = 1;
             return;
         }
@@ -652,7 +652,7 @@ async function capture(targetArg, options = {}) {
         }
         const message = error instanceof Error ? error.message : String(error);
         if (/browserType\.launch/i.test(message) || /MachPortRendezvousServer/i.test(message) || /Chromium/i.test(message)) {
-            const launchError = (0, playwright_1.createPlaywrightLaunchError)('playdrop-cli capture', error);
+            const launchError = (0, playwright_1.createPlaywrightLaunchError)('playdrop project capture', error);
             console.error(launchError.message);
         }
         else if (error instanceof Error && error.stack) {

package/dist/commands/captureRemote.d.ts

@@ -0,0 +1,11 @@
+type CaptureRemoteOptions = {
+    timeout?: string | number;
+    screenshot?: string;
+    log?: string;
+    username?: string;
+    password?: string;
+    loginUrl?: string;
+};
+export declare function buildCaptureRemoteCommandArgs(url: string, options?: CaptureRemoteOptions): string[] | null;
+export declare function captureRemote(url: string | undefined, options?: CaptureRemoteOptions): Promise<void>;
+export {};

package/dist/commands/captureRemote.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCaptureRemoteCommandArgs = buildCaptureRemoteCommandArgs;
+exports.captureRemote = captureRemote;
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = __importDefault(require("node:path"));
+const messages_1 = require("../messages");
+function parseTimeout(raw) {
+    if (raw === undefined) {
+        return null;
+    }
+    const parsed = typeof raw === 'number' ? raw : Number.parseFloat(String(raw));
+    if (!Number.isFinite(parsed) || parsed <= 0 || parsed > 600) {
+        return null;
+    }
+    return String(parsed);
+}
+function buildCaptureRemoteCommandArgs(url, options = {}) {
+    const trimmedUrl = typeof url === 'string' ? url.trim() : '';
+    if (!trimmedUrl) {
+        return null;
+    }
+    const args = [
+        node_path_1.default.resolve(__dirname, '../../scripts/capture-url.mjs'),
+        '--url',
+        trimmedUrl,
+    ];
+    const timeout = parseTimeout(options.timeout);
+    if (options.timeout !== undefined && timeout === null) {
+        throw new Error('invalid_timeout');
+    }
+    if (timeout) {
+        args.push('--timeout', timeout);
+    }
+    if (options.screenshot) {
+        args.push('--screenshot', options.screenshot);
+    }
+    if (options.log) {
+        args.push('--log', options.log);
+    }
+    const username = options.username?.trim() || '';
+    const password = options.password || '';
+    if ((username && !password) || (!username && password)) {
+        throw new Error('invalid_credentials_pair');
+    }
+    if (username) {
+        args.push('--username', username, '--password', password);
+    }
+    if (options.loginUrl) {
+        args.push('--login-url', options.loginUrl);
+    }
+    return args;
+}
+async function captureRemote(url, options = {}) {
+    let args;
+    try {
+        args = buildCaptureRemoteCommandArgs(url ?? '', options);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === 'invalid_timeout') {
+            (0, messages_1.printErrorWithHelp)('The --timeout value must be a number between 0 and 600 seconds.', [], { command: 'project capture remote' });
+            process.exitCode = 1;
+            return;
+        }
+        if (error instanceof Error && error.message === 'invalid_credentials_pair') {
+            (0, messages_1.printErrorWithHelp)('Use --username and --password together.', [], { command: 'project capture remote' });
+            process.exitCode = 1;
+            return;
+        }
+        throw error;
+    }
+    if (!args) {
+        (0, messages_1.printErrorWithHelp)('A URL is required.', ['Example: playdrop project capture remote https://www.playdrop.ai/creators/playdrop/apps/game/hangingout'], { command: 'project capture remote' });
+        process.exitCode = 1;
+        return;
+    }
+    const result = (0, node_child_process_1.spawnSync)(process.execPath, args, {
+        stdio: 'inherit',
+    });
+    if (typeof result.status === 'number' && result.status !== 0) {
+        process.exitCode = result.status;
+        return;
+    }
+    if (result.error) {
+        throw result.error;
+    }
+}