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

package/dist/commands/notifications.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.browseNotifications = browseNotifications;
+exports.readNotification = readNotification;
+exports.readAllNotifications = readAllNotifications;
+const commandContext_1 = require("../commandContext");
+const errors_1 = require("../errors");
+const messages_1 = require("../messages");
+const output_1 = require("../output");
+function parseStatus(raw) {
+    if (!raw || raw.trim().length === 0) {
+        return 'unread';
+    }
+    const normalized = raw.trim().toLowerCase();
+    if (normalized === 'all' || normalized === 'read' || normalized === 'unread') {
+        return normalized;
+    }
+    return null;
+}
+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;
+}
+async function fetchNotificationsByStatus(fetchPage, status, limit, offset) {
+    if (status === 'all' || status === 'unread') {
+        return fetchPage(status, limit, offset);
+    }
+    const pageSize = Math.max(limit, 50);
+    const collected = [];
+    let unreadCount = 0;
+    let cursor = 0;
+    let hasMore = true;
+    while (hasMore && collected.length < offset + limit) {
+        const response = await fetchPage('all', pageSize, cursor);
+        unreadCount = response.unreadCount;
+        const matching = response.notifications.filter((notification) => notification.readAt !== null);
+        collected.push(...matching);
+        if (!response.pagination.hasMore || response.notifications.length === 0) {
+            hasMore = false;
+            break;
+        }
+        cursor += response.notifications.length;
+    }
+    const notifications = collected.slice(offset, offset + limit);
+    return {
+        notifications,
+        unreadCount,
+        pagination: {
+            limit,
+            offset,
+            count: notifications.length,
+            hasMore: collected.length > offset + limit || hasMore,
+        },
+    };
+}
+async function browseNotifications(options = {}) {
+    const status = parseStatus(options.status);
+    if (!status) {
+        (0, messages_1.printErrorWithHelp)(`Status "${options.status ?? ''}" is not supported.`, ['Use one of: unread, read, all.'], { command: 'notifications browse' });
+        process.exitCode = 1;
+        return;
+    }
+    const limit = parsePositiveInteger(options.limit, 'limit', 20);
+    if (limit === null) {
+        (0, messages_1.printErrorWithHelp)('The --limit value must be a positive integer.', ['Example: --limit 20'], { command: 'notifications 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: 'notifications browse' });
+        process.exitCode = 1;
+        return;
+    }
+    await (0, commandContext_1.withEnvironment)('notifications browse', 'Checking your notifications', async ({ client }) => {
+        try {
+            const response = await fetchNotificationsByStatus(async (requestStatus, requestLimit, requestOffset) => client.fetchNotifications({
+                status: requestStatus,
+                limit: requestLimit,
+                offset: requestOffset,
+            }), status, limit, offset);
+            if (options.json) {
+                (0, output_1.printJson)({
+                    notifications: response.notifications,
+                    unreadCount: response.unreadCount,
+                    pagination: response.pagination,
+                });
+                return;
+            }
+            if (response.notifications.length === 0) {
+                console.log(`No ${status} notifications found.`);
+                console.log('Next: run "playdrop browse" or "playdrop creations browse" to check recent activity.');
+                return;
+            }
+            console.log(`Notifications (${status}):\n`);
+            for (const notification of response.notifications) {
+                const state = notification.readAt ? 'read' : 'unread';
+                console.log(`#${notification.id} | ${state} | ${(0, output_1.formatTimestamp)(notification.createdAt)}`);
+                console.log(`  ${notification.title}`);
+                if (notification.body) {
+                    console.log(`  ${notification.body}`);
+                }
+            }
+            console.log('\nNext: run "playdrop notifications read <id>" or "playdrop notifications read-all".');
+        }
+        catch (error) {
+            const handled = (0, errors_1.handleCommandFailure)(error, 'notifications browse', 'Notification lookup', {
+                apiMessage: (apiError) => ({
+                    problem: `Notification lookup failed with status ${apiError.status}.`,
+                    suggestions: ['Run "playdrop auth login" and retry.'],
+                }),
+            });
+            if (!handled) {
+                throw error;
+            }
+        }
+    });
+}
+async function readNotification(rawId, options = {}) {
+    const id = parsePositiveInteger(rawId, 'Notification id', 0);
+    if (id === null || id === 0) {
+        (0, messages_1.printErrorWithHelp)('Notification id must be a positive integer.', ['Example: playdrop notifications read 42'], { command: 'notifications read' });
+        process.exitCode = 1;
+        return;
+    }
+    await (0, commandContext_1.withEnvironment)('notifications read', 'Marking a notification as read', async ({ client }) => {
+        try {
+            const response = await client.markNotificationRead(id);
+            if (options.json) {
+                (0, output_1.printJson)({ success: Boolean(response.success), unreadCount: response.unreadCount });
+                return;
+            }
+            (0, output_1.printSuccess)(`Notification #${id} marked as read.`, ['Next: run "playdrop notifications browse --status unread" to review what remains.']);
+        }
+        catch (error) {
+            const handled = (0, errors_1.handleCommandFailure)(error, 'notifications read', 'Notification update', {
+                apiMessage: (apiError) => ({
+                    problem: `Notification update failed with status ${apiError.status}.`,
+                    suggestions: ['Run "playdrop auth login" and retry.'],
+                }),
+            });
+            if (!handled) {
+                throw error;
+            }
+        }
+    });
+}
+async function readAllNotifications(options = {}) {
+    await (0, commandContext_1.withEnvironment)('notifications read-all', 'Marking all notifications as read', async ({ client }) => {
+        try {
+            const response = await client.markAllNotificationsRead();
+            if (options.json) {
+                (0, output_1.printJson)({ success: Boolean(response.success), unreadCount: response.unreadCount });
+                return;
+            }
+            (0, output_1.printSuccess)('All notifications marked as read.', ['Next: run "playdrop notifications browse --status unread" to confirm your inbox is clear.']);
+        }
+        catch (error) {
+            const handled = (0, errors_1.handleCommandFailure)(error, 'notifications read-all', 'Notification update', {
+                apiMessage: (apiError) => ({
+                    problem: `Notification update failed with status ${apiError.status}.`,
+                    suggestions: ['Run "playdrop auth login" and retry.'],
+                }),
+            });
+            if (!handled) {
+                throw error;
+            }
+        }
+    });
+}

package/dist/commands/search.d.ts

@@ -0,0 +1,13 @@
+type SearchOptions = {
+    kind?: string;
+    appType?: string;
+    assetCategory?: string;
+    assetSubcategory?: string;
+    packContainsCategory?: string;
+    packContainsSubcategory?: string;
+    limit?: string | number;
+    offset?: string | number;
+    json?: boolean;
+};
+export declare function search(query: string | undefined, options?: SearchOptions): Promise<void>;
+export {};

package/dist/commands/search.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.search = search;
+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");
+function parseSearchKind(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 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.length > 0 ? normalized : null;
+}
+function toSearchItem(result) {
+    if (result.kind === 'app') {
+        return {
+            kind: 'app',
+            ref: `${result.app.creatorUsername}/app/${result.app.name}`,
+            targetPath: result.targetPath,
+            item: result.app,
+        };
+    }
+    if (result.kind === 'asset') {
+        return {
+            kind: 'asset',
+            ref: `${result.asset.creatorUsername}/asset/${result.asset.name}`,
+            targetPath: result.targetPath,
+            item: result.asset,
+        };
+    }
+    if (result.kind === 'pack') {
+        return {
+            kind: 'asset-pack',
+            ref: `${result.pack.creatorUsername}/asset-pack/${result.pack.name}`,
+            targetPath: result.targetPath,
+            item: result.pack,
+        };
+    }
+    return null;
+}
+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 search(query, options = {}) {
+    const trimmedQuery = typeof query === 'string' ? query.trim() : '';
+    if (!trimmedQuery) {
+        (0, messages_1.printErrorWithHelp)('A search query is required.', ['Example: playdrop search "city builder"'], { command: 'search' });
+        process.exitCode = 1;
+        return;
+    }
+    const kind = parseSearchKind(options.kind);
+    if (!kind) {
+        (0, messages_1.printErrorWithHelp)(`Kind "${options.kind ?? ''}" is not supported.`, ['Use one of: app, asset, asset-pack, all.'], { command: 'search' });
+        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: 'search' });
+        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: 'search' });
+        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: 'search' });
+        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: 'search' });
+        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: 'search' });
+        process.exitCode = 1;
+        return;
+    }
+    const packContainsCategory = parseAssetCategory(options.packContainsCategory);
+    if (packContainsCategory === null) {
+        (0, messages_1.printErrorWithHelp)(`Pack category "${options.packContainsCategory}" is not supported.`, ['Use a canonical asset category like IMAGE, VIDEO, AUDIO, SPRITESHEET, or MODEL_3D.'], { command: 'search' });
+        process.exitCode = 1;
+        return;
+    }
+    const packContainsSubcategory = parseAssetSubcategory(options.packContainsSubcategory);
+    if (packContainsSubcategory === null) {
+        (0, messages_1.printErrorWithHelp)(`Pack subcategory "${options.packContainsSubcategory}" is invalid.`, ['Use lowercase slug values like generic, avatar, music, or sfx.'], { command: 'search' });
+        process.exitCode = 1;
+        return;
+    }
+    await (0, commandContext_1.withPublicEnvironment)('search', async ({ client }) => {
+        try {
+            const requestLimit = limit + offset;
+            const response = await client.search({
+                q: trimmedQuery,
+                mode: 'flat',
+                kind: (0, refs_1.contentKindToSearchKind)(kind),
+                page: 1,
+                pageSize: requestLimit,
+                appType: appType,
+                assetCategory: assetCategory ?? undefined,
+                assetSubcategory: assetSubcategory ?? undefined,
+                packContainsCategory: packContainsCategory ?? undefined,
+                packContainsSubcategory: packContainsSubcategory ?? undefined,
+            });
+            const normalizedItems = (response.results ?? [])
+                .map((result) => toSearchItem(result))
+                .filter((item) => Boolean(item));
+            const items = normalizedItems.slice(offset, offset + limit);
+            const pagination = {
+                limit,
+                offset,
+                count: items.length,
+                hasMore: normalizedItems.length > offset + limit || Boolean(response.pagination?.hasMore),
+            };
+            if (options.json) {
+                (0, output_1.printJson)({ items, pagination });
+                return;
+            }
+            if (items.length === 0) {
+                console.log(`No results found for "${trimmedQuery}".`);
+                console.log('Next: adjust your filters or run "playdrop browse" to explore available content.');
+                return;
+            }
+            console.log(`Search results for "${trimmedQuery}":\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 result.');
+        }
+        catch (error) {
+            const handled = (0, errors_1.handleCommandFailure)(error, 'search', 'Search', {
+                apiMessage: (apiError) => ({
+                    problem: `Search failed with status ${apiError.status}.`,
+                    suggestions: ['Retry in a moment.', 'Use "playdrop help search" for usage details.'],
+                }),
+            });
+            if (!handled) {
+                throw error;
+            }
+        }
+    });
+}

package/dist/commands/upload.js

@@ -242,7 +242,11 @@ async function uploadAssetTask(client, task, sourceAppVersionId, creatorUsername
         fieldName: role,
         filename: (0, node_path_1.basename)(filePath),
     }));
-    const response = await client.createAssetVersion(task.name, {
+    const targetCreatorUsername = typeof creatorUsername === 'string' ? creatorUsername.trim() : '';
+    if (!targetCreatorUsername) {
+        throw new Error(`Asset "${task.name}" upload is missing creator username.`);
+    }
+    const response = await client.createAssetVersion(targetCreatorUsername, task.name, {
         displayName: task.kind === 'asset' ? task.displayName : undefined,
         category: task.category,
         subcategory,
@@ -253,8 +257,6 @@ async function uploadAssetTask(client, task, sourceAppVersionId, creatorUsername
         shopListed: task.shopListed,
         shopPriceCredits: task.shopPriceCredits,
         files,
-    }, {
-        creatorUsername,
     });
     const uploadedCreatorUsername = response.asset.creatorUsername;
     const name = response.asset.name;
@@ -329,10 +331,19 @@ async function uploadAssetPackTask(client, task, creatorUsername, uploadedAssets
     for (const ref of task.assets) {
         assetRefs.push(await resolveAssetReference(client, ref, creatorUsername, uploadedAssets));
     }
-    const response = await client.uploadAssetPackVersion(task.name, {
+    const mutationCreatorUsername = typeof targetCreatorUsername === 'string' && targetCreatorUsername.trim().length > 0
+        ? targetCreatorUsername.trim()
+        : creatorUsername.trim();
+    if (!mutationCreatorUsername) {
+        throw new Error(`Asset pack "${task.name}@${task.version}" upload is missing creator username.`);
+    }
+    const response = await client.uploadAssetPackVersion(mutationCreatorUsername, task.name, {
         request: {
             version: task.version,
             visibility: task.visibility,
+            hostingMode: task.hostingMode,
+            externalUrl: task.externalUrl,
+            downloadUrl: task.downloadUrl,
             releaseNotes: task.releaseNotes,
             assets: assetRefs.map((assetRef) => ({ assetRef })),
         },
@@ -343,8 +354,6 @@ async function uploadAssetPackTask(client, task, creatorUsername, uploadedAssets
         screenshotsLandscape: task.listing?.screenshotLandscapePaths?.map((filePath) => createListingFileFromPath(filePath, 'image/png')),
         videosPortrait: task.listing?.videoPortraitPaths?.map((filePath) => createListingFileFromPath(filePath, 'video/mp4')),
         videosLandscape: task.listing?.videoLandscapePaths?.map((filePath) => createListingFileFromPath(filePath, 'video/mp4')),
-    }, {
-        creatorUsername: targetCreatorUsername,
     });
     const versionNodeId = typeof response.versionNodeId === 'string' ? response.versionNodeId.trim() : '';
     if (!versionNodeId) {
@@ -497,7 +506,7 @@ async function processUploadTasks(client, tasks, owner, ownerUsername, currentUs
             if (task.kind === 'app') {
                 const { upload } = await (0, apps_1.runAppPipeline)(client, task, {
                     skipEcs: options?.skipEcs,
-                    creatorUsername: task.username,
+                    creatorUsername: taskCreator,
                 });
                 if (!upload.versionCreated || !upload.version) {
                     throw new Error(`App "${task.name}" upload did not return a created version.`);
@@ -542,10 +551,7 @@ async function processUploadTasks(client, tasks, owner, ownerUsername, currentUs
                 console.log((0, uploadLog_1.formatTaskLogLine)(entry));
             }
             else if (task.kind === 'asset') {
-                const mutationTargetCreator = typeof task.username === 'string' && task.username.trim().length > 0
-                    ? taskCreator
-                    : undefined;
-                const uploaded = await uploadAssetTask(client, task, undefined, mutationTargetCreator);
+                const uploaded = await uploadAssetTask(client, task, undefined, taskCreator);
                 uploadedAssetsByKey.set(`${uploaded.creatorUsername}/${uploaded.name}`, uploaded);
                 registerCanonicalNode(graphState, uploaded.ref, uploaded.versionNodeId);
                 registerLocalRef(graphState.localAssetNodeByName, graphState.ambiguousAssetNames, task.name, uploaded.versionNodeId);
@@ -569,10 +575,7 @@ async function processUploadTasks(client, tasks, owner, ownerUsername, currentUs
                 if (!sourceApp) {
                     throw new Error(`Embedded asset "${task.name}" references app "${task.appName}" that was not uploaded in this run.`);
                 }
-                const mutationTargetCreator = sourceApp.creatorUsername !== defaultCreator
-                    ? sourceApp.creatorUsername
-                    : undefined;
-                const uploaded = await uploadAssetTask(client, task, sourceApp.versionId, mutationTargetCreator);
+                const uploaded = await uploadAssetTask(client, task, sourceApp.versionId, sourceApp.creatorUsername);
                 uploadedAssetsByKey.set(`${uploaded.creatorUsername}/${uploaded.name}`, uploaded);
                 registerCanonicalNode(graphState, uploaded.ref, uploaded.versionNodeId);
                 registerLocalRef(graphState.localAssetNodeByName, graphState.ambiguousAssetNames, task.name, uploaded.versionNodeId);
@@ -664,7 +667,7 @@ async function processUploadTasks(client, tasks, owner, ownerUsername, currentUs
     return results;
 }
 async function upload(pathOrName, options) {
-    await (0, commandContext_1.withEnvironment)('upload', 'Uploading content', async ({ client, env, envConfig }) => {
+    await (0, commandContext_1.withEnvironment)('project publish', 'Publishing content', async ({ client, env, envConfig }) => {
         let userInfo = { username: null, role: null };
         try {
             userInfo = await fetchCurrentUserInfo(client, envConfig.apiBase);
@@ -680,7 +683,7 @@ async function upload(pathOrName, options) {
             : 'unknown';
         const selection = (0, taskSelection_1.selectTasks)(pathOrName);
         if (selection.errors.length > 0) {
-            (0, taskSelection_1.reportTaskErrors)(selection.errors, 'upload');
+            (0, taskSelection_1.reportTaskErrors)(selection.errors, 'project publish');
             process.exitCode = 1;
             return;
         }

package/dist/commands/validate.js

@@ -5,10 +5,21 @@ const taskSelection_1 = require("../taskSelection");
 const taskUtils_1 = require("../taskUtils");
 const uploadLog_1 = require("../uploadLog");
 const apps_1 = require("../apps");
+const externalAssetPackValidation_1 = require("../externalAssetPackValidation");
 async function validate(pathOrName) {
     const selection = (0, taskSelection_1.selectTasks)(pathOrName);
     if (selection.errors.length > 0) {
-        (0, taskSelection_1.reportTaskErrors)(selection.errors, 'validate');
+        (0, taskSelection_1.reportTaskErrors)(selection.errors, 'project validate');
+        process.exitCode = 1;
+        return;
+    }
+    const externalAssetPackErrors = await (0, externalAssetPackValidation_1.validateExternalAssetPackTasks)(selection.tasks);
+    if (externalAssetPackErrors.length > 0) {
+        (0, taskSelection_1.reportTaskErrors)(externalAssetPackErrors.map((message) => ({
+            type: 'invalid-catalogue',
+            message,
+            help: ['Update the asset pack downloadUrl to a public hostname that resolves successfully, then try again.'],
+        })), 'project validate');
         process.exitCode = 1;
         return;
     }
@@ -25,6 +36,9 @@ async function validate(pathOrName) {
             if (task.kind === 'app') {
                 await (0, apps_1.validateAppTask)(task);
             }
+            else {
+                throw new Error(`project validate does not support ${task.kind} "${entityId}".`);
+            }
             const entry = {
                 action: 'validate',
                 status: 'success',

package/dist/commands/versionsBrowse.d.ts

@@ -0,0 +1,7 @@
+type BrowseVersionsOptions = {
+    limit?: string | number;
+    offset?: string | number;
+    json?: boolean;
+};
+export declare function browseVersions(rawRef: string | undefined, options?: BrowseVersionsOptions): Promise<void>;
+export {};