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

package/dist/commands/versionsBrowse.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.browseVersions = browseVersions;
+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 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 buildAssetSourceUrl(apiBase, ref, revision) {
+    return `${apiBase}/assets/${encodeURIComponent(ref.creator)}/${encodeURIComponent(ref.name)}/versions/${revision}/source`;
+}
+function buildAssetPackSourceUrl(apiBase, ref, version) {
+    return `${apiBase}/asset-packs/${encodeURIComponent(ref.creator)}/${encodeURIComponent(ref.name)}/versions/${encodeURIComponent(version)}/source`;
+}
+function assetFileUrls(version) {
+    const files = version.fileManifest?.files;
+    if (!Array.isArray(files)) {
+        return [];
+    }
+    return files
+        .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 printEntry(entry) {
+    if (entry.kind === 'app') {
+        const currentLabel = entry.isCurrent ? ' | current' : '';
+        console.log(`${entry.version} | ${entry.visibility.toLowerCase()}${currentLabel} | ${(0, output_1.formatTimestamp)(entry.createdAt)}`);
+        console.log(`  Play URL: ${(0, output_1.formatOptionalValue)(entry.urls.play)}`);
+        console.log(`  Source URL: ${(0, output_1.formatOptionalValue)(entry.urls.source)}`);
+        return;
+    }
+    if (entry.kind === 'asset') {
+        const currentLabel = entry.isCurrent ? ' | current' : '';
+        console.log(`${entry.revisionLabel} | ${entry.visibility.toLowerCase()}${currentLabel} | ${entry.format.toLowerCase()} | ${entry.subcategory} | ${(0, output_1.formatTimestamp)(entry.createdAt)}`);
+        console.log(`  Source URL: ${entry.urls.source}`);
+        if (entry.urls.files.length > 0) {
+            for (const file of entry.urls.files) {
+                console.log(`  File URL (${file.role}): ${file.url}`);
+            }
+        }
+        return;
+    }
+    const currentLabel = entry.isCurrent ? ' | current' : '';
+    console.log(`${entry.version} | ${entry.visibility.toLowerCase()}${currentLabel} | ${(0, output_1.formatTimestamp)(entry.createdAt)}`);
+    console.log(`  Download URL: ${(0, output_1.formatOptionalValue)(entry.urls.download)}`);
+    console.log(`  Source URL: ${entry.urls.source}`);
+}
+async function browseVersions(rawRef, options = {}) {
+    let ref;
+    try {
+        ref = (0, refs_1.parseContentRef)(rawRef ?? '');
+    }
+    catch {
+        (0, messages_1.printErrorWithHelp)('A canonical ref is required.', ['Use the format <creator>/<kind>/<name>.', 'Example: playdrop versions browse playdrop/app/hangingout'], { command: 'versions 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: 'versions 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: 'versions browse' });
+        process.exitCode = 1;
+        return;
+    }
+    await (0, commandContext_1.withPublicEnvironment)('versions browse', async ({ client, envConfig }) => {
+        try {
+            let entries = [];
+            let pagination;
+            if (ref.kind === 'app') {
+                const response = await client.listAppVersions(ref.creator, ref.name);
+                const listed = response.versions ?? [];
+                const selected = listed.slice(offset, offset + limit);
+                const details = await Promise.all(selected.map(async (version) => {
+                    const detail = await client.getAppVersion(ref.creator, ref.name, version.version);
+                    return {
+                        kind: 'app',
+                        version: version.version,
+                        visibility: version.visibility,
+                        createdAt: version.createdAt,
+                        updatedAt: detail.version.updatedAt,
+                        releaseNotes: version.releaseNotes ?? null,
+                        isCurrent: Boolean(version.isCurrent),
+                        urls: {
+                            play: typeof detail.version.assetUrl === 'string' ? detail.version.assetUrl : null,
+                            source: typeof detail.version.sourceUrl === 'string' ? detail.version.sourceUrl : null,
+                        },
+                    };
+                }));
+                entries = details;
+                pagination = {
+                    limit,
+                    offset,
+                    count: entries.length,
+                    hasMore: listed.length > offset + limit,
+                };
+            }
+            else if (ref.kind === 'asset') {
+                const [detail, response] = await Promise.all([
+                    client.fetchAssetBySlug(ref.creator, ref.name),
+                    client.listAssetVersions(ref.creator, ref.name, { limit, offset }),
+                ]);
+                const currentRevision = detail.asset.currentVersion?.revision ?? null;
+                entries = (response.versions ?? []).map((version) => ({
+                    kind: 'asset',
+                    revision: version.revision,
+                    revisionLabel: version.revisionLabel,
+                    visibility: version.visibility,
+                    createdAt: version.createdAt,
+                    updatedAt: version.updatedAt,
+                    subcategory: version.subcategory,
+                    format: version.format,
+                    isCurrent: currentRevision === version.revision,
+                    urls: {
+                        source: buildAssetSourceUrl(envConfig.apiBase, ref, version.revision),
+                        files: assetFileUrls(version),
+                    },
+                }));
+                pagination = response.pagination ?? {
+                    limit,
+                    offset,
+                    count: entries.length,
+                    hasMore: false,
+                };
+            }
+            else {
+                const [detail, response] = await Promise.all([
+                    client.fetchAssetPackBySlug(ref.creator, ref.name),
+                    client.listAssetPackVersions(ref.creator, ref.name, { limit, offset }),
+                ]);
+                const currentVersion = detail.pack.currentVersion?.version ?? null;
+                entries = (response.versions ?? []).map((version) => ({
+                    kind: 'asset-pack',
+                    version: version.version,
+                    visibility: version.visibility,
+                    createdAt: version.createdAt,
+                    updatedAt: version.updatedAt,
+                    isCurrent: currentVersion === version.version,
+                    urls: {
+                        download: typeof version.downloadUrl === 'string' && version.downloadUrl.trim().length > 0 ? version.downloadUrl : null,
+                        source: buildAssetPackSourceUrl(envConfig.apiBase, ref, version.version),
+                    },
+                }));
+                pagination = response.pagination ?? {
+                    limit,
+                    offset,
+                    count: entries.length,
+                    hasMore: false,
+                };
+            }
+            if (options.json) {
+                (0, output_1.printJson)({ kind: ref.kind, ref: ref.ref, entries, pagination });
+                return;
+            }
+            if (entries.length === 0) {
+                console.log(`No versions found for "${ref.ref}".`);
+                console.log('Next: run "playdrop detail ' + ref.ref + '" to inspect the current item state.');
+                return;
+            }
+            console.log(`Versions for ${ref.ref}:\n`);
+            for (const entry of entries) {
+                printEntry(entry);
+            }
+            console.log('\nNext: use the URLs above directly, or run "playdrop detail ' + ref.ref + '" for the current item summary.');
+        }
+        catch (error) {
+            const handled = (0, errors_1.handleCommandFailure)(error, 'versions browse', 'Version lookup', {
+                apiMessage: (apiError) => {
+                    if (apiError.status === 404) {
+                        return {
+                            problem: `No item was found for "${ref.ref}".`,
+                            suggestions: ['Check the ref and retry.', 'Run "playdrop browse" to explore available content.'],
+                        };
+                    }
+                    if (apiError.status === 401 || apiError.status === 403) {
+                        return {
+                            problem: `You do not have access to version history for "${ref.ref}".`,
+                            suggestions: ['Run "playdrop auth login" if this is private content you own.'],
+                        };
+                    }
+                    return {
+                        problem: `Version lookup failed with status ${apiError.status}.`,
+                        suggestions: ['Retry in a moment.', 'Use "playdrop help versions browse" for usage details.'],
+                    };
+                },
+            });
+            if (!handled) {
+                throw error;
+            }
+        }
+    });
+}

package/dist/commands/whoami.js

@@ -10,14 +10,14 @@ const messages_1 = require("../messages");
 async function whoami() {
     const cfg = (0, config_1.loadConfig)();
     if (!cfg.token || !cfg.env) {
-        (0, messages_1.printLoginRequired)('Checking your Playdrop account status', 'whoami');
+        (0, messages_1.printLoginRequired)('Checking your Playdrop account status', 'auth whoami');
         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, 'whoami');
+        (0, messages_1.printUnknownEnvironment)(cfg.env, choices, 'auth whoami');
         process.exitCode = 1;
         return;
     }
@@ -36,9 +36,9 @@ async function whoami() {
             }
             if (unknownError instanceof types_1.ApiError) {
                 (0, messages_1.printErrorWithHelp)(`Request failed with status ${unknownError.status}.`, [
-                    'Run "playdrop-cli login" to refresh your credentials.',
-                    'Use "playdrop-cli whoami" again after logging in to confirm your status.'
-                ], { command: 'whoami' });
+                    'Run "playdrop auth login" to refresh your credentials.',
+                    'Use "playdrop auth whoami" again after logging in to confirm your status.'
+                ], { command: 'auth whoami' });
                 process.exitCode = 1;
                 return null;
             }
@@ -53,7 +53,7 @@ async function whoami() {
         if (e instanceof http_1.CLIUnsupportedClientError) {
             return;
         }
-        (0, messages_1.printNetworkIssue)('Could not reach the Playdrop API to check your account.', 'whoami');
+        (0, messages_1.printNetworkIssue)('Could not reach the Playdrop API to check your account.', 'auth whoami');
         process.exitCode = 1;
         return;
     }
@@ -62,11 +62,12 @@ async function whoami() {
     const username = data.user?.username;
     if (!username) {
         (0, messages_1.printErrorWithHelp)('The Playdrop API returned an unexpected response.', [
-            'Retry "playdrop-cli whoami" in a moment.',
+            'Retry "playdrop auth whoami" in a moment.',
             'If the problem continues, contact the Playdrop team.'
-        ], { command: 'whoami' });
+        ], { command: 'auth whoami' });
         process.exitCode = 1;
         return;
     }
     console.log(`${username} (${cfg.env})`);
+    console.log('Next: run "playdrop getting-started" to see the recommended workflow.');
 }

package/dist/errors.d.ts

@@ -0,0 +1,9 @@
+import { ApiError } from '@playdrop/types';
+export declare function isNetworkError(error: unknown): boolean;
+export declare function handleCommandFailure(error: unknown, command: string, context: string, options?: {
+    networkMessage?: string;
+    apiMessage?: (error: ApiError) => {
+        problem: string;
+        suggestions?: string[];
+    };
+}): boolean;

package/dist/errors.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNetworkError = isNetworkError;
+exports.handleCommandFailure = handleCommandFailure;
+const types_1 = require("@playdrop/types");
+const http_1 = require("./http");
+const messages_1 = require("./messages");
+function isNetworkError(error) {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const candidate = error;
+    if (candidate instanceof TypeError) {
+        return true;
+    }
+    const code = typeof candidate.code === 'string' ? candidate.code : undefined;
+    if (code === 'ECONNREFUSED' || code === 'ENOTFOUND') {
+        return true;
+    }
+    const cause = candidate.cause;
+    if (cause && typeof cause === 'object' && typeof cause.code === 'string') {
+        const nestedCode = cause.code;
+        return nestedCode === 'ECONNREFUSED' || nestedCode === 'ENOTFOUND';
+    }
+    return false;
+}
+function handleCommandFailure(error, command, context, options = {}) {
+    if (error instanceof http_1.CLIUnsupportedClientError) {
+        return true;
+    }
+    if (error instanceof types_1.UnsupportedClientError) {
+        (0, http_1.handleUnsupportedError)(error, context);
+        return true;
+    }
+    if (error instanceof types_1.ApiError) {
+        const apiMessage = options.apiMessage
+            ? options.apiMessage(error)
+            : {
+                problem: `${context} failed with status ${error.status}.`,
+                suggestions: ['Retry in a moment.'],
+            };
+        (0, messages_1.printErrorWithHelp)(apiMessage.problem, apiMessage.suggestions ?? [], { command });
+        process.exitCode = 1;
+        return true;
+    }
+    if (isNetworkError(error)) {
+        (0, messages_1.printNetworkIssue)(options.networkMessage || 'Could not reach the Playdrop API.', command);
+        process.exitCode = 1;
+        return true;
+    }
+    return false;
+}

package/dist/externalAssetPackValidation.d.ts

@@ -0,0 +1,2 @@
+import type { CliTask } from './taskUtils';
+export declare function validateExternalAssetPackTasks(tasks: CliTask[]): Promise<string[]>;

package/dist/externalAssetPackValidation.js

@@ -0,0 +1,115 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateExternalAssetPackTasks = validateExternalAssetPackTasks;
+const dnsPromises = __importStar(require("node:dns/promises"));
+const node_net_1 = require("node:net");
+function isExternalAssetPackTask(task) {
+    return task.kind === 'asset-pack' && task.hostingMode === 'EXTERNAL';
+}
+function isPrivateNetworkIpAddress(address) {
+    const normalized = address.trim().toLowerCase();
+    if (!normalized) {
+        return true;
+    }
+    if (normalized === '::1') {
+        return true;
+    }
+    if (normalized.startsWith('fe80:') || normalized.startsWith('fc') || normalized.startsWith('fd')) {
+        return true;
+    }
+    if (normalized.startsWith('::ffff:')) {
+        return isPrivateNetworkIpAddress(normalized.slice('::ffff:'.length));
+    }
+    if ((0, node_net_1.isIP)(normalized) !== 4) {
+        return false;
+    }
+    const octets = normalized.split('.').map((part) => Number.parseInt(part, 10));
+    if (octets.length !== 4 || octets.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) {
+        return true;
+    }
+    const [first, second] = octets;
+    if (first === 10 || first === 127) {
+        return true;
+    }
+    if (first === 169 && second === 254) {
+        return true;
+    }
+    if (first === 172 && second >= 16 && second <= 31) {
+        return true;
+    }
+    if (first === 192 && second === 168) {
+        return true;
+    }
+    return false;
+}
+async function validateExternalAssetPackTasks(tasks) {
+    const errors = [];
+    for (const task of tasks) {
+        if (!isExternalAssetPackTask(task)) {
+            continue;
+        }
+        const downloadUrl = typeof task.downloadUrl === 'string' ? task.downloadUrl.trim() : '';
+        if (!downloadUrl) {
+            continue;
+        }
+        let hostname = '';
+        try {
+            hostname = new URL(downloadUrl).hostname;
+        }
+        catch {
+            continue;
+        }
+        let resolvedAddresses;
+        try {
+            resolvedAddresses = await dnsPromises.lookup(hostname, { all: true, verbatim: true });
+        }
+        catch {
+            errors.push(`[${task.cataloguePath}] Asset pack "${task.name}" downloadUrl hostname could not be resolved.`);
+            continue;
+        }
+        if (!Array.isArray(resolvedAddresses) || resolvedAddresses.length === 0) {
+            errors.push(`[${task.cataloguePath}] Asset pack "${task.name}" downloadUrl hostname did not resolve to a public address.`);
+            continue;
+        }
+        if (resolvedAddresses.some((entry) => {
+            const address = typeof entry?.address === 'string' ? entry.address.trim() : '';
+            return !address || isPrivateNetworkIpAddress(address);
+        })) {
+            errors.push(`[${task.cataloguePath}] Asset pack "${task.name}" downloadUrl must resolve only to public IP addresses.`);
+        }
+    }
+    return errors;
+}

package/dist/http.js

@@ -43,7 +43,7 @@ function handleUnsupportedError(error, context) {
     if (requiredParts.length > 0) {
         console.error(`Required: ${requiredParts.join(', ')}`);
     }
-    console.error('Run `playdrop-cli upgrade` to update the Playdrop CLI.');
+    console.error('Run `playdrop update` to update Playdrop.');
     process.exitCode = 1;
     throw new CLIUnsupportedClientError(error.message);
 }