@playdrop/playdrop-cli 0.5.2 → 0.5.4

package/dist/commands/versionsBrowse.js

@@ -57,18 +57,144 @@ function printEntry(entry) {
         }
         return;
     }
+    if (entry.kind === 'asset-spec') {
+        const currentLabel = entry.isCurrent ? ' | current' : '';
+        console.log(`${entry.version} | ${entry.visibility.toLowerCase()} | ${entry.status.toLowerCase()}${currentLabel} | ${(0, output_1.formatTimestamp)(entry.createdAt)}`);
+        console.log(`  Documentation URL: ${(0, output_1.formatOptionalValue)(entry.documentationUrl)}`);
+        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 loadVersionEntries(input) {
+    const { client, envConfig, ref, limit, offset } = input;
+    if (ref.kind === 'app') {
+        const [appDetail, response] = await Promise.all([
+            client.fetchAppBySlug(ref.creator, ref.name),
+            client.listAppVersions(ref.creator, ref.name),
+        ]);
+        const listed = response.versions ?? [];
+        const selected = listed.slice(offset, offset + limit);
+        const entries = 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: (0, appUrls_1.buildPlatformPlayUrl)(envConfig.webBase, {
+                        creatorUsername: ref.creator,
+                        appName: ref.name,
+                        appType: appDetail.app.type,
+                    }),
+                    source: typeof detail.version.sourceUrl === 'string' ? detail.version.sourceUrl : null,
+                },
+            };
+        }));
+        return {
+            entries,
+            pagination: {
+                limit,
+                offset,
+                count: entries.length,
+                hasMore: listed.length > offset + limit,
+            },
+        };
+    }
+    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;
+        return {
+            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: (response.versions ?? []).length,
+                hasMore: false,
+            },
+        };
+    }
+    if (ref.kind === 'asset-pack') {
+        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;
+        return {
+            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: buildAssetPackDownloadUrl(envConfig.apiBase, ref, version.version),
+                    source: buildAssetPackSourceUrl(envConfig.apiBase, ref, version.version),
+                },
+            })),
+            pagination: response.pagination ?? {
+                limit,
+                offset,
+                count: (response.versions ?? []).length,
+                hasMore: false,
+            },
+        };
+    }
+    const [detail, response] = await Promise.all([
+        client.fetchAssetSpecBySlug(ref.creator, ref.name),
+        client.listAssetSpecVersions(ref.creator, ref.name, { limit, offset }),
+    ]);
+    const currentVersion = detail.assetSpec.currentVersion?.version ?? null;
+    return {
+        entries: (response.versions ?? []).map((version) => ({
+            kind: 'asset-spec',
+            version: version.version,
+            visibility: version.visibility,
+            status: version.status,
+            createdAt: version.createdAt,
+            updatedAt: version.updatedAt,
+            isCurrent: currentVersion === version.version,
+            documentationUrl: version.documentationUrl ?? null,
+        })),
+        pagination: response.pagination ?? {
+            limit,
+            offset,
+            count: (response.versions ?? []).length,
+            hasMore: false,
+        },
+    };
+}
 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' });
+        (0, messages_1.printErrorWithHelp)('A canonical ref is required.', ['Use the format <creator>/<kind>/<name>.', 'Example: playdrop versions browse playdrop/app/hangingout', 'Example: playdrop versions browse playdrop/asset-spec/platformer-level'], { command: 'versions browse' });
         process.exitCode = 1;
         return;
     }
@@ -86,96 +212,7 @@ async function browseVersions(rawRef, options = {}) {
     }
     await (0, commandContext_1.withPublicEnvironment)('versions browse', async ({ client, envConfig }) => {
         try {
-            let entries = [];
-            let pagination;
-            if (ref.kind === 'app') {
-                const [appDetail, response] = await Promise.all([
-                    client.fetchAppBySlug(ref.creator, ref.name),
-                    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: (0, appUrls_1.buildPlatformPlayUrl)(envConfig.webBase, {
-                                creatorUsername: ref.creator,
-                                appName: ref.name,
-                                appType: appDetail.app.type,
-                            }),
-                            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: buildAssetPackDownloadUrl(envConfig.apiBase, ref, version.version),
-                        source: buildAssetPackSourceUrl(envConfig.apiBase, ref, version.version),
-                    },
-                }));
-                pagination = response.pagination ?? {
-                    limit,
-                    offset,
-                    count: entries.length,
-                    hasMore: false,
-                };
-            }
+            const { entries, pagination } = await loadVersionEntries({ client, envConfig, ref, limit, offset });
             if (options.json) {
                 (0, output_1.printJson)({ kind: ref.kind, ref: ref.ref, entries, pagination });
                 return;

package/dist/commands/whoami.js

@@ -9,6 +9,7 @@ const environment_1 = require("../environment");
 const messages_1 = require("../messages");
 async function whoami() {
     const cfg = (0, config_1.loadConfig)();
+    const currentAccount = (0, config_1.getCurrentAccountSession)(cfg);
     if (!cfg.token || !cfg.env) {
         (0, messages_1.printLoginRequired)('Checking your Playdrop account status', 'whoami');
         process.exitCode = 1;
@@ -59,7 +60,7 @@ async function whoami() {
     }
     if (!data)
         return;
-    const username = data.user?.username;
+    const username = data.user?.username?.trim();
     if (!username) {
         (0, messages_1.printErrorWithHelp)('The Playdrop API returned an unexpected response.', [
             'Retry "playdrop auth whoami" in a moment.',
@@ -68,6 +69,13 @@ async function whoami() {
         process.exitCode = 1;
         return;
     }
-    console.log(`${username} (${cfg.env})`);
+    if (!currentAccount) {
+        (0, config_1.migrateLegacySession)({
+            username,
+            env: envConfig.name,
+            token: cfg.token,
+        });
+    }
+    console.log(`${username} (${envConfig.name})`);
     console.log('Next: run "playdrop getting-started" to see the recommended workflow.');
 }

package/dist/config.d.ts

@@ -1,6 +1,20 @@
+export interface CliAccountRef {
+    username: string;
+    env: string;
+}
+export interface CliStoredSession {
+    token: string;
+    updatedAt: string;
+}
+export interface CliAccountSession extends CliAccountRef, CliStoredSession {
+}
 export interface CliConfig {
+    version?: number;
+    currentAccount?: CliAccountRef | null;
+    accounts?: Record<string, Record<string, CliStoredSession>>;
     token?: string;
     env?: string;
+    currentUsername?: string;
 }
 export declare function loadConfig(): CliConfig;
 export declare function saveConfig(cfg: CliConfig): void;
@@ -8,3 +22,26 @@ export declare function clearConfig(): void;
 export declare function getConfig(): {
     path: string;
 };
+export declare function listAccountSessions(cfg?: CliConfig): CliAccountSession[];
+export declare function getCurrentAccountSession(cfg?: CliConfig): CliAccountSession | null;
+export declare function findAccountSession(username: string, env?: string, cfg?: CliConfig): CliAccountSession | null;
+export declare function listAccountSessionsForUsername(username: string, cfg?: CliConfig): CliAccountSession[];
+export declare function saveAccountSession(input: {
+    username: string;
+    env: string;
+    token: string;
+    updatedAt?: string;
+}): CliConfig;
+export declare function migrateLegacySession(input: {
+    username: string;
+    env: string;
+    token: string;
+}): CliConfig;
+export declare function setCurrentAccount(input: {
+    username: string;
+    env?: string;
+}): CliConfig;
+export declare function removeAccountSession(input?: {
+    username?: string;
+    env?: string;
+}): CliConfig;

package/dist/config.js

@@ -7,29 +7,74 @@ exports.loadConfig = loadConfig;
 exports.saveConfig = saveConfig;
 exports.clearConfig = clearConfig;
 exports.getConfig = getConfig;
+exports.listAccountSessions = listAccountSessions;
+exports.getCurrentAccountSession = getCurrentAccountSession;
+exports.findAccountSession = findAccountSession;
+exports.listAccountSessionsForUsername = listAccountSessionsForUsername;
+exports.saveAccountSession = saveAccountSession;
+exports.migrateLegacySession = migrateLegacySession;
+exports.setCurrentAccount = setCurrentAccount;
+exports.removeAccountSession = removeAccountSession;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const os_1 = __importDefault(require("os"));
+const CONFIG_VERSION = 2;
 function getConfigPath() {
     const custom = process.env.PLAYDROP_CONFIG_PATH;
     if (custom)
         return custom;
     return (0, path_1.join)(os_1.default.homedir(), '.playdrop', 'config.json');
 }
-function loadConfig() {
+function normalizeKey(value) {
+    return value.trim();
+}
+function clonePersistedConfig(cfg) {
+    return JSON.parse(JSON.stringify(cfg));
+}
+function buildDerivedConfig(cfg) {
+    const next = clonePersistedConfig(cfg);
+    const current = getCurrentAccountSession(next);
+    if (current) {
+        next.currentUsername = current.username;
+        next.env = current.env;
+        next.token = current.token;
+    }
+    return next;
+}
+function readRawConfig() {
     const file = getConfigPath();
     try {
         const data = (0, fs_1.readFileSync)(file, 'utf8');
-        return JSON.parse(data);
+        const parsed = JSON.parse(data);
+        return parsed && typeof parsed === 'object' ? parsed : {};
     }
     catch {
         return {};
     }
 }
+function stripDerivedFields(cfg) {
+    const next = {
+        version: typeof cfg.version === 'number' ? cfg.version : undefined,
+        currentAccount: cfg.currentAccount ?? undefined,
+        accounts: cfg.accounts ? clonePersistedConfig({ accounts: cfg.accounts }).accounts : undefined,
+    };
+    if (!next.accounts || Object.keys(next.accounts).length === 0) {
+        if (typeof cfg.token === 'string' && cfg.token.trim().length > 0) {
+            next.token = cfg.token.trim();
+        }
+        if (typeof cfg.env === 'string' && cfg.env.trim().length > 0) {
+            next.env = cfg.env.trim();
+        }
+    }
+    return next;
+}
+function loadConfig() {
+    return buildDerivedConfig(readRawConfig());
+}
 function saveConfig(cfg) {
     const file = getConfigPath();
     (0, fs_1.mkdirSync)((0, path_1.dirname)(file), { recursive: true });
-    (0, fs_1.writeFileSync)(file, JSON.stringify(cfg, null, 2));
+    (0, fs_1.writeFileSync)(file, JSON.stringify(stripDerivedFields(cfg), null, 2));
 }
 function clearConfig() {
     const file = getConfigPath();
@@ -39,3 +84,160 @@ function clearConfig() {
 function getConfig() {
     return { path: getConfigPath() };
 }
+function listAccountSessions(cfg = loadConfig()) {
+    const accounts = cfg.accounts ?? {};
+    const sessions = [];
+    for (const [username, envMap] of Object.entries(accounts)) {
+        for (const [env, session] of Object.entries(envMap ?? {})) {
+            if (!session || typeof session.token !== 'string' || session.token.trim().length === 0) {
+                continue;
+            }
+            sessions.push({
+                username,
+                env,
+                token: session.token,
+                updatedAt: typeof session.updatedAt === 'string' ? session.updatedAt : '',
+            });
+        }
+    }
+    sessions.sort((left, right) => {
+        if (left.username === right.username) {
+            return left.env.localeCompare(right.env);
+        }
+        return left.username.localeCompare(right.username);
+    });
+    return sessions;
+}
+function getCurrentAccountSession(cfg = loadConfig()) {
+    const current = cfg.currentAccount;
+    if (!current) {
+        return null;
+    }
+    return findAccountSession(current.username, current.env, cfg);
+}
+function findAccountSession(username, env, cfg = loadConfig()) {
+    const normalizedUsername = normalizeKey(username);
+    if (!normalizedUsername) {
+        return null;
+    }
+    const envMap = cfg.accounts?.[normalizedUsername];
+    if (!envMap) {
+        return null;
+    }
+    if (typeof env === 'string' && env.trim().length > 0) {
+        const session = envMap[env.trim()];
+        if (!session?.token) {
+            return null;
+        }
+        return {
+            username: normalizedUsername,
+            env: env.trim(),
+            token: session.token,
+            updatedAt: typeof session.updatedAt === 'string' ? session.updatedAt : '',
+        };
+    }
+    const envs = Object.keys(envMap);
+    if (envs.length === 1) {
+        const selectedEnv = envs[0];
+        const session = envMap[selectedEnv];
+        if (!session?.token) {
+            return null;
+        }
+        return {
+            username: normalizedUsername,
+            env: selectedEnv,
+            token: session.token,
+            updatedAt: typeof session.updatedAt === 'string' ? session.updatedAt : '',
+        };
+    }
+    return null;
+}
+function listAccountSessionsForUsername(username, cfg = loadConfig()) {
+    const normalizedUsername = normalizeKey(username);
+    if (!normalizedUsername) {
+        return [];
+    }
+    return listAccountSessions(cfg).filter((session) => session.username === normalizedUsername);
+}
+function saveAccountSession(input) {
+    const cfg = loadConfig();
+    const username = normalizeKey(input.username);
+    const env = normalizeKey(input.env);
+    const token = input.token.trim();
+    if (!username || !env || !token) {
+        throw new Error('invalid_account_session');
+    }
+    const next = {
+        version: CONFIG_VERSION,
+        currentAccount: { username, env },
+        accounts: {
+            ...(cfg.accounts ?? {}),
+            [username]: {
+                ...(cfg.accounts?.[username] ?? {}),
+                [env]: {
+                    token,
+                    updatedAt: input.updatedAt ?? new Date().toISOString(),
+                },
+            },
+        },
+    };
+    saveConfig(next);
+    return loadConfig();
+}
+function migrateLegacySession(input) {
+    return saveAccountSession(input);
+}
+function setCurrentAccount(input) {
+    const cfg = loadConfig();
+    const username = normalizeKey(input.username);
+    const env = typeof input.env === 'string' ? normalizeKey(input.env) : '';
+    const session = findAccountSession(username, env || undefined, cfg);
+    if (!session) {
+        throw new Error(env ? 'account_session_not_found' : 'account_not_found');
+    }
+    const next = {
+        version: CONFIG_VERSION,
+        currentAccount: { username: session.username, env: session.env },
+        accounts: cfg.accounts ?? {},
+    };
+    saveConfig(next);
+    return loadConfig();
+}
+// eslint-disable-next-line complexity
+function removeAccountSession(input = {}) {
+    const cfg = loadConfig();
+    const current = getCurrentAccountSession(cfg);
+    const username = normalizeKey(input.username ?? current?.username ?? '');
+    const env = normalizeKey(input.env ?? current?.env ?? '');
+    if (!username) {
+        return cfg;
+    }
+    const accounts = clonePersistedConfig({ accounts: cfg.accounts ?? {} }).accounts ?? {};
+    if (!accounts[username]) {
+        return cfg;
+    }
+    if (env) {
+        delete accounts[username][env];
+    }
+    else {
+        delete accounts[username];
+    }
+    if (accounts[username] && Object.keys(accounts[username]).length === 0) {
+        delete accounts[username];
+    }
+    const remainingSessions = listAccountSessions({ accounts });
+    const nextCurrent = remainingSessions[0]
+        ? { username: remainingSessions[0].username, env: remainingSessions[0].env }
+        : null;
+    const next = {
+        version: CONFIG_VERSION,
+        currentAccount: nextCurrent,
+        accounts,
+    };
+    if (!nextCurrent && typeof cfg.token === 'string' && typeof cfg.env === 'string' && (!cfg.accounts || Object.keys(cfg.accounts).length === 0)) {
+        clearConfig();
+        return {};
+    }
+    saveConfig(next);
+    return loadConfig();
+}