@playdrop/playdrop-cli 0.5.2 → 0.5.4

package/dist/commandContext.js

@@ -6,21 +6,19 @@ const config_1 = require("./config");
 const apiClient_1 = require("./apiClient");
 const environment_1 = require("./environment");
 const messages_1 = require("./messages");
+const workspaceAuth_1 = require("./workspaceAuth");
 const DEFAULT_PUBLIC_ENV = 'prod';
-function resolveConfiguredEnvironment(cfg, command, options) {
-    const configuredEnv = typeof cfg.env === 'string' && cfg.env.trim().length > 0
-        ? cfg.env.trim()
-        : undefined;
-    if (!configuredEnv && options.requireAuth) {
+function resolveConfiguredEnvironment(envName, command, options) {
+    if (!envName && options.requireAuth) {
         (0, messages_1.printConfigEnvironmentMissing)(command);
         process.exitCode = 1;
         return null;
     }
-    const envName = configuredEnv ?? (options.allowDefaultPublicEnv ? DEFAULT_PUBLIC_ENV : undefined);
-    const envConfig = (0, environment_1.resolveEnvironmentConfig)(envName);
+    const resolvedEnvName = envName ?? (options.allowDefaultPublicEnv ? DEFAULT_PUBLIC_ENV : undefined);
+    const envConfig = (0, environment_1.resolveEnvironmentConfig)(resolvedEnvName);
     if (!envConfig) {
         const choices = (0, environment_1.formatEnvironmentList)();
-        (0, messages_1.printUnknownEnvironment)(envName || '', choices, command);
+        (0, messages_1.printUnknownEnvironment)(resolvedEnvName || '', choices, command);
         process.exitCode = 1;
         return null;
     }
@@ -29,42 +27,168 @@ function resolveConfiguredEnvironment(cfg, command, options) {
     }
     return envConfig;
 }
-function buildContext(cfg, envConfig) {
-    const client = (0, apiClient_1.createCliApiClient)({ baseUrl: envConfig.apiBase, token: cfg.token });
-    const aiClient = (0, apiClient_1.createCliAiClient)({ baseUrl: envConfig.aiBase, token: cfg.token });
+function buildContext(cfg, envConfig, account) {
+    const token = account?.token ?? cfg.token ?? '';
+    const client = (0, apiClient_1.createCliApiClient)({ baseUrl: envConfig.apiBase, token });
+    const aiClient = (0, apiClient_1.createCliAiClient)({ baseUrl: envConfig.aiBase, token });
     return {
         client,
         aiClient,
         env: envConfig.name,
         envConfig,
-        token: cfg.token || '',
+        token,
         config: cfg,
+        account,
     };
 }
-async function withEnvironment(command, actionLabel, callback) {
-    const cfg = (0, config_1.loadConfig)();
-    if (!cfg.token) {
+function buildLegacyAccountSession(cfg) {
+    if (!cfg.token || !cfg.env) {
+        return null;
+    }
+    return {
+        username: cfg.currentUsername ?? '',
+        env: cfg.env,
+        token: cfg.token,
+        updatedAt: '',
+    };
+}
+async function migrateLegacyConfigIfNeeded(cfg, envConfig, command) {
+    if ((0, config_1.getCurrentAccountSession)(cfg) || !cfg.token || !cfg.env) {
+        return cfg;
+    }
+    const client = (0, apiClient_1.createCliApiClient)({ baseUrl: envConfig.apiBase, token: cfg.token });
+    try {
+        const data = await client.me();
+        const username = typeof data.user?.username === 'string' ? data.user.username.trim() : '';
+        if (!username) {
+            (0, messages_1.printErrorWithHelp)('Could not migrate your existing Playdrop CLI session.', ['Run "playdrop auth login" to reauthenticate and rebuild your local account store.'], { command });
+            process.exitCode = 1;
+            return null;
+        }
+        return (0, config_1.migrateLegacySession)({
+            username,
+            env: envConfig.name,
+            token: cfg.token,
+        });
+    }
+    catch {
+        (0, messages_1.printErrorWithHelp)('Could not migrate your existing Playdrop CLI session.', ['Run "playdrop auth login" to reauthenticate and rebuild your local account store.'], { command });
+        process.exitCode = 1;
+        return null;
+    }
+}
+function resolveWorkspaceSelectedAccount(cfg, currentAccount, workspaceAuth) {
+    const matchingSessions = (0, config_1.listAccountSessionsForUsername)(workspaceAuth.config.ownerUsername, cfg);
+    if (workspaceAuth.config.env) {
+        return {
+            account: (0, config_1.findAccountSession)(workspaceAuth.config.ownerUsername, workspaceAuth.config.env, cfg),
+            matchingSessions,
+        };
+    }
+    if (matchingSessions.length === 1) {
+        return {
+            account: matchingSessions[0],
+            matchingSessions,
+        };
+    }
+    if (currentAccount && currentAccount.username === workspaceAuth.config.ownerUsername) {
+        return {
+            account: (0, config_1.findAccountSession)(workspaceAuth.config.ownerUsername, currentAccount.env, cfg),
+            matchingSessions,
+        };
+    }
+    return {
+        account: null,
+        matchingSessions,
+    };
+}
+async function resolveAuthenticatedEnvironment(command, actionLabel, options = {}) {
+    let cfg = (0, config_1.loadConfig)();
+    let workspaceAuth = null;
+    try {
+        workspaceAuth = options.workspacePath ? (0, workspaceAuth_1.findWorkspaceAuthConfig)(options.workspacePath) : null;
+    }
+    catch (error) {
+        if (error instanceof workspaceAuth_1.WorkspaceAuthConfigError) {
+            (0, messages_1.printErrorWithHelp)(`Invalid .playdrop.json at ${error.filePath}.`, [
+                'The file must be valid JSON.',
+                'It must include a non-empty "ownerUsername" string.',
+            ], { command });
+            process.exitCode = 1;
+            return null;
+        }
+        throw error;
+    }
+    if (workspaceAuth && !(0, config_1.getCurrentAccountSession)(cfg) && cfg.token && cfg.env) {
+        const provisionalEnvConfig = resolveConfiguredEnvironment(cfg.env, command, {
+            requireAuth: true,
+            allowDefaultPublicEnv: false,
+        });
+        if (!provisionalEnvConfig) {
+            return null;
+        }
+        const migrated = await migrateLegacyConfigIfNeeded(cfg, provisionalEnvConfig, command);
+        if (!migrated) {
+            return null;
+        }
+        cfg = migrated;
+    }
+    const currentAccount = (0, config_1.getCurrentAccountSession)(cfg) ?? buildLegacyAccountSession(cfg);
+    const selectedAccount = workspaceAuth
+        ? resolveWorkspaceSelectedAccount(cfg, currentAccount, workspaceAuth).account
+        : currentAccount;
+    if (!selectedAccount) {
+        if (workspaceAuth) {
+            const matchingSessions = (0, config_1.listAccountSessionsForUsername)(workspaceAuth.config.ownerUsername, cfg);
+            if (!workspaceAuth.config.env && matchingSessions.length > 1) {
+                (0, messages_1.printErrorWithHelp)(`This workspace is pinned to ${workspaceAuth.config.ownerUsername}, but that account is logged in on multiple environments.`, [
+                    `Run "playdrop auth use ${workspaceAuth.config.ownerUsername} --env <env>" to select the matching environment.`,
+                    'Or add an "env" field to .playdrop.json.',
+                ], { command });
+                process.exitCode = 1;
+                return null;
+            }
+            const envSuffix = workspaceAuth.config.env ? ` on ${workspaceAuth.config.env}` : '';
+            (0, messages_1.printErrorWithHelp)(`This workspace is pinned to ${workspaceAuth.config.ownerUsername}${envSuffix}, but that account is not logged in.`, [
+                `Run "playdrop auth login${workspaceAuth.config.env ? ` --env ${workspaceAuth.config.env}` : ''}" while authenticated as ${workspaceAuth.config.ownerUsername}.`,
+                'Or remove .playdrop.json if this workspace should use your current default account.',
+            ], { command });
+            process.exitCode = 1;
+            return null;
+        }
         (0, messages_1.printLoginRequired)(actionLabel, command);
         process.exitCode = 1;
-        return;
+        return null;
     }
-    const envConfig = resolveConfiguredEnvironment(cfg, command, {
+    const envConfig = resolveConfiguredEnvironment(selectedAccount.env, command, {
         requireAuth: true,
         allowDefaultPublicEnv: false,
     });
     if (!envConfig) {
+        return null;
+    }
+    return {
+        cfg: (0, config_1.loadConfig)(),
+        account: selectedAccount,
+        envConfig,
+    };
+}
+async function withEnvironment(command, actionLabel, callback, options = {}) {
+    const resolved = await resolveAuthenticatedEnvironment(command, actionLabel, options);
+    if (!resolved) {
         return;
     }
-    await callback(buildContext(cfg, envConfig));
+    await callback(buildContext(resolved.cfg, resolved.envConfig, resolved.account));
 }
 async function withPublicEnvironment(command, callback) {
     const cfg = (0, config_1.loadConfig)();
-    const envConfig = resolveConfiguredEnvironment(cfg, command, {
+    const account = (0, config_1.getCurrentAccountSession)(cfg);
+    const envConfig = resolveConfiguredEnvironment(account?.env ?? cfg.env, command, {
         requireAuth: false,
         allowDefaultPublicEnv: true,
     });
     if (!envConfig) {
         return;
     }
-    await callback(buildContext(cfg, envConfig));
+    await callback(buildContext(cfg, envConfig, account));
 }

package/dist/commands/accounts.d.ts

@@ -0,0 +1,2 @@
+export declare function listAccounts(): void;
+export declare function useAccount(username: string, env?: string): void;

package/dist/commands/accounts.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listAccounts = listAccounts;
+exports.useAccount = useAccount;
+const config_1 = require("../config");
+const messages_1 = require("../messages");
+function listAccounts() {
+    const accounts = (0, config_1.listAccountSessions)();
+    if (accounts.length === 0) {
+        const cfg = (0, config_1.loadConfig)();
+        if (cfg.token && cfg.env) {
+            console.log('Your current Playdrop session is using the legacy single-account format.');
+            console.log('Next: run "playdrop auth whoami" to migrate it into the multi-account store.');
+            return;
+        }
+        console.log('No Playdrop accounts are stored.');
+        console.log('Next: run "playdrop auth login" to add an account.');
+        return;
+    }
+    const current = (0, config_1.getCurrentAccountSession)();
+    for (const account of accounts) {
+        const marker = current && current.username === account.username && current.env === account.env ? '*' : ' ';
+        console.log(`${marker} ${account.username} (${account.env})`);
+    }
+    console.log('Next: run "playdrop auth use <username>" to switch the default account.');
+}
+function useAccount(username, env) {
+    const normalizedUsername = username.trim();
+    if (!normalizedUsername) {
+        (0, messages_1.printErrorWithHelp)('Provide the username of the account you want to use.', ['Run "playdrop auth accounts" to list stored accounts.'], { command: 'auth use' });
+        process.exitCode = 1;
+        return;
+    }
+    const existing = (0, config_1.findAccountSession)(normalizedUsername, env);
+    if (!existing) {
+        (0, messages_1.printErrorWithHelp)(env
+            ? `No stored Playdrop session was found for ${normalizedUsername} on ${env}.`
+            : `No stored Playdrop session was found for ${normalizedUsername}.`, [
+            'Run "playdrop auth accounts" to list stored accounts.',
+            `Run "playdrop auth login${env ? ` --env ${env}` : ''}" to add the missing session.`,
+        ], { command: 'auth use' });
+        process.exitCode = 1;
+        return;
+    }
+    (0, config_1.setCurrentAccount)({ username: normalizedUsername, env: env?.trim() || undefined });
+    console.log(`Current Playdrop account is now ${existing.username} (${existing.env}).`);
+    console.log('Next: run "playdrop auth whoami" to confirm your session.');
+}

package/dist/commands/ads.d.ts

@@ -0,0 +1,8 @@
+type AdsCommandOptions = {
+    app?: string;
+    days?: string | number;
+    json?: boolean;
+};
+export declare function showAdsEarnings(options?: AdsCommandOptions): Promise<void>;
+export declare function showAdsReport(options?: AdsCommandOptions): Promise<void>;
+export {};

package/dist/commands/ads.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showAdsEarnings = showAdsEarnings;
+exports.showAdsReport = showAdsReport;
+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, command) {
+    if (raw === undefined) {
+        return 30;
+    }
+    const parsed = typeof raw === 'number' ? raw : Number.parseInt(String(raw), 10);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        (0, messages_1.printErrorWithHelp)('The --days value must be a positive integer.', ['Example: --days 30'], { command });
+        process.exitCode = 1;
+        return null;
+    }
+    return parsed;
+}
+async function resolveOptionalAppId(client, rawAppRef) {
+    if (!rawAppRef) {
+        return undefined;
+    }
+    const ref = (0, refs_1.parseContentRef)(rawAppRef);
+    if (ref.kind !== 'app') {
+        throw new Error('invalid_app_ref');
+    }
+    const detail = await client.fetchAppBySlug(ref.creator, ref.name);
+    return Number(detail.app.id);
+}
+async function showAdsEarnings(options = {}) {
+    const days = parsePositiveInteger(options.days, 'ads earnings');
+    if (days === null) {
+        return;
+    }
+    await (0, commandContext_1.withEnvironment)('ads earnings', 'Checking creator ad earnings', async ({ client }) => {
+        try {
+            const appId = await resolveOptionalAppId(client, options.app);
+            const response = await client.fetchCreatorEarnings({
+                days,
+                ...(typeof appId === 'number' && appId > 0 ? { appId } : {}),
+            });
+            if (options.json) {
+                (0, output_1.printJson)(response);
+                return;
+            }
+            const aggregateRows = new Map();
+            for (const day of response.days) {
+                for (const row of day.apps) {
+                    const key = `${row.appId}:${row.format}`;
+                    const current = aggregateRows.get(key) ?? {
+                        appName: row.appName,
+                        format: row.format,
+                        amount: 0,
+                        servedCount: 0,
+                        creditedCount: 0,
+                    };
+                    current.amount += row.amount;
+                    current.servedCount += row.servedCount;
+                    current.creditedCount += row.creditedCount;
+                    aggregateRows.set(key, current);
+                }
+            }
+            console.log(`Today provisional: ${response.summary.provisionalToday}`);
+            console.log(`Last 7 days settled: ${response.summary.settledLast7Days}`);
+            console.log(`Last 30 days settled: ${response.summary.settledLast30Days}`);
+            if (aggregateRows.size === 0) {
+                console.log('\nNo ad earnings found for the selected window.');
+                return;
+            }
+            console.log('\nBy app and format:\n');
+            for (const row of aggregateRows.values()) {
+                console.log(`${row.appName} | ${row.format} | earnings ${row.amount} | served ${row.servedCount} | credited ${row.creditedCount}`);
+            }
+        }
+        catch (error) {
+            const handled = (0, errors_1.handleCommandFailure)(error, 'ads earnings', 'Ad earnings lookup', {
+                apiMessage: (apiError) => ({
+                    problem: `Ad earnings lookup failed with status ${apiError.status}.`,
+                    suggestions: ['Run "playdrop auth login" and retry.'],
+                }),
+            });
+            if (!handled) {
+                throw error;
+            }
+        }
+    });
+}
+async function showAdsReport(options = {}) {
+    const days = parsePositiveInteger(options.days, 'ads report');
+    if (days === null) {
+        return;
+    }
+    await (0, commandContext_1.withEnvironment)('ads report', 'Checking creator ad report', async ({ client }) => {
+        try {
+            const appId = await resolveOptionalAppId(client, options.app);
+            const response = await client.fetchCreatorEarnings({
+                days,
+                ...(typeof appId === 'number' && appId > 0 ? { appId } : {}),
+            });
+            if (options.json) {
+                (0, output_1.printJson)(response);
+                return;
+            }
+            console.log('Daily ad report:\n');
+            for (const row of response.days) {
+                console.log(`${row.dateUtc} | total ${row.totalAmount} | interstitial ${row.interstitialAmount} | rewarded ${row.rewardedAmount} | served ${row.servedCount} | credited ${row.creditedCount}${row.provisional ? ' | provisional' : ''}`);
+            }
+        }
+        catch (error) {
+            const handled = (0, errors_1.handleCommandFailure)(error, 'ads report', 'Ad report lookup', {
+                apiMessage: (apiError) => ({
+                    problem: `Ad report lookup failed with status ${apiError.status}.`,
+                    suggestions: ['Run "playdrop auth login" and retry.'],
+                }),
+            });
+            if (!handled) {
+                throw error;
+            }
+        }
+    });
+}

package/dist/commands/boosts.d.ts

@@ -0,0 +1,25 @@
+export declare function showBoostBalance(options?: {
+    json?: boolean;
+}): Promise<void>;
+export declare function browseBoostOffers(options?: {
+    json?: boolean;
+}): Promise<void>;
+export declare function buyBoostPack(sku: string, options?: {
+    quantity?: string | number;
+    json?: boolean;
+}): Promise<void>;
+export declare function activateBoost(rawRef: string, options?: {
+    units?: string | number;
+    json?: boolean;
+}): Promise<void>;
+export declare function showBoostStatus(rawRef: string, options?: {
+    json?: boolean;
+}): Promise<void>;
+export declare function showBoostHistory(rawRef: string, options?: {
+    limit?: string | number;
+    json?: boolean;
+}): Promise<void>;
+export declare function showBoostReport(rawRef: string, options?: {
+    days?: string | number;
+    json?: boolean;
+}): Promise<void>;

package/dist/commands/boosts.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showBoostBalance = showBoostBalance;
+exports.browseBoostOffers = browseBoostOffers;
+exports.buyBoostPack = buyBoostPack;
+exports.activateBoost = activateBoost;
+exports.showBoostStatus = showBoostStatus;
+exports.showBoostHistory = showBoostHistory;
+exports.showBoostReport = showBoostReport;
+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;
+    }
+    return parsed;
+}
+async function resolveAppForBoost(client, rawRef) {
+    const ref = (0, refs_1.parseContentRef)(rawRef);
+    if (ref.kind !== 'app') {
+        throw new Error('invalid_app_ref');
+    }
+    const detail = await client.fetchAppBySlug(ref.creator, ref.name);
+    return {
+        ref,
+        app: detail.app,
+    };
+}
+function formatReportRow(row) {
+    return [
+        row.dateUtc,
+        `impressions ${row.interstitialImpressions + row.rewardedImpressions}`,
+        `views ${row.regularDetailViews} regular / ${row.promotedDetailViews} boosted`,
+        `plays ${row.regularPlays} regular / ${row.promotedPlays} boosted`,
+        `earnings ${row.adEarnings}`,
+    ].join(' | ');
+}
+function formatRunDuration(startedAt, endsAt) {
+    const totalHours = Math.max(1, Math.round((new Date(endsAt).getTime() - new Date(startedAt).getTime()) / (60 * 60 * 1000)));
+    const days = Math.floor(totalHours / 24);
+    const hours = totalHours % 24;
+    if (days > 0 && hours > 0) {
+        return `${days}d ${hours}h`;
+    }
+    if (days > 0) {
+        return `${days}d`;
+    }
+    return `${hours}h`;
+}
+function formatUtcDate(value) {
+    return value.toISOString().slice(0, 10);
+}
+function resolveReportRangeFromDays(days, now = new Date()) {
+    const end = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()));
+    const start = new Date(end.getTime() - ((days - 1) * 24 * 60 * 60 * 1000));
+    return {
+        startDateUtc: formatUtcDate(start),
+        endDateUtc: formatUtcDate(end),
+    };
+}
+async function showBoostBalance(options = {}) {
+    await (0, commandContext_1.withEnvironment)('boosts balance', 'Checking your boost balance', async ({ client }) => {
+        const response = await client.fetchBoostBalance();
+        if (options.json) {
+            (0, output_1.printJson)(response);
+            return;
+        }
+        (0, output_1.printSuccess)(`Boost balance: ${response.balance}`, ['Next: run "playdrop boosts offers" or "playdrop boosts buy boost_1".']);
+    });
+}
+async function browseBoostOffers(options = {}) {
+    await (0, commandContext_1.withEnvironment)('boosts offers', 'Checking available boost packs', async ({ client }) => {
+        const response = await client.fetchBoostBalance();
+        if (options.json) {
+            (0, output_1.printJson)({ offers: response.offers });
+            return;
+        }
+        console.log('Boost offers:\n');
+        for (const offer of response.offers) {
+            console.log(`${offer.sku} | ${offer.units} units | ${offer.priceCredits} credits`);
+        }
+    });
+}
+async function buyBoostPack(sku, options = {}) {
+    const normalizedSku = sku.trim().toLowerCase();
+    if (!['boost_1', 'boost_3', 'boost_7', 'boost_14', 'boost_31'].includes(normalizedSku)) {
+        (0, messages_1.printErrorWithHelp)('Boost SKU must be one of boost_1, boost_3, boost_7, boost_14, or boost_31.', ['Example: playdrop boosts buy boost_1'], { command: 'boosts buy' });
+        process.exitCode = 1;
+        return;
+    }
+    const quantity = parsePositiveInteger(options.quantity, 'quantity', 1);
+    if (quantity === null) {
+        (0, messages_1.printErrorWithHelp)('The --quantity value must be a positive integer.', ['Example: --quantity 2'], { command: 'boosts buy' });
+        process.exitCode = 1;
+        return;
+    }
+    await (0, commandContext_1.withEnvironment)('boosts buy', 'Buying boost pack', async ({ client }) => {
+        try {
+            const response = await client.purchaseBoostPack({ sku: normalizedSku, quantity });
+            if (options.json) {
+                (0, output_1.printJson)(response);
+                return;
+            }
+            (0, output_1.printSuccess)(`Purchased ${response.offer.displayName}${response.quantity > 1 ? ` x ${response.quantity}` : ''}. Added ${response.unitsAdded} boost${response.unitsAdded === 1 ? '' : 's'}. Boost balance: ${response.boostBalance}. Credit balance: ${response.creditBalance}.`, ['Next: run "playdrop boosts activate <creator>/app/<name>".']);
+        }
+        catch (error) {
+            const handled = (0, errors_1.handleCommandFailure)(error, 'boosts buy', 'Boost purchase', {
+                apiMessage: (apiError) => ({
+                    problem: `Boost purchase failed with status ${apiError.status}.`,
+                    suggestions: ['Check your credit balance with "playdrop credits balance".'],
+                }),
+            });
+            if (!handled) {
+                throw error;
+            }
+        }
+    });
+}
+async function activateBoost(rawRef, options = {}) {
+    const units = parsePositiveInteger(options.units, 'units', 1);
+    if (units === null) {
+        (0, messages_1.printErrorWithHelp)('The --units value must be a positive integer.', ['Example: --units 2'], { command: 'boosts activate' });
+        process.exitCode = 1;
+        return;
+    }
+    await (0, commandContext_1.withEnvironment)('boosts activate', 'Activating boost', async ({ client }) => {
+        const { app } = await resolveAppForBoost(client, rawRef);
+        const response = await client.activateAppBoost(app.id, { units });
+        if (options.json) {
+            (0, output_1.printJson)(response);
+            return;
+        }
+        (0, output_1.printSuccess)(`Boost active until ${response.boostedUntil ?? 'unknown'}. Remaining inventory: ${response.boostsAvailable}.`);
+    });
+}
+async function showBoostStatus(rawRef, options = {}) {
+    await (0, commandContext_1.withEnvironment)('boosts status', 'Checking boost status', async ({ client }) => {
+        const { app } = await resolveAppForBoost(client, rawRef);
+        const response = await client.fetchAppBoostStatus(app.id);
+        if (options.json) {
+            (0, output_1.printJson)(response);
+            return;
+        }
+        console.log(`${response.app.displayName || response.app.name}`);
+        console.log(`Status: ${response.isActive ? 'boosted' : 'inactive'}`);
+        console.log(`Boosts available: ${response.boostsAvailable}`);
+        console.log(`Boosted until: ${response.boostedUntil ?? 'none'}`);
+        if (response.currentRun) {
+            console.log(`Current run started: ${(0, output_1.formatTimestamp)(response.currentRun.startedAt)}`);
+            console.log(`Current run ends: ${(0, output_1.formatTimestamp)(response.currentRun.endsAt)}`);
+            console.log(`Current run units: ${response.currentRun.consumedUnits}`);
+            console.log(`Current run impressions: ${response.currentRun.deliveredImpressionCount}`);
+            console.log(`Current run views: ${response.currentRun.promotedDetailViewCount}`);
+            console.log(`Current run plays: ${response.currentRun.promotedPlayCount}`);
+        }
+    });
+}
+async function showBoostHistory(rawRef, options = {}) {
+    const limit = parsePositiveInteger(options.limit, 'limit', 30);
+    if (limit === null) {
+        (0, messages_1.printErrorWithHelp)('The --limit value must be a positive integer.', ['Example: --limit 20'], { command: 'boosts history' });
+        process.exitCode = 1;
+        return;
+    }
+    await (0, commandContext_1.withEnvironment)('boosts history', 'Checking boost history', async ({ client }) => {
+        const { app } = await resolveAppForBoost(client, rawRef);
+        const response = await client.fetchAppBoostHistory(app.id, { limit });
+        if (options.json) {
+            (0, output_1.printJson)(response);
+            return;
+        }
+        if (response.runs.length === 0) {
+            console.log('No boost runs found.');
+            return;
+        }
+        console.log('Boost history:\n');
+        for (const run of response.runs) {
+            console.log(`#${run.id} | ${run.status.toLowerCase()} | ${(0, output_1.formatTimestamp)(run.startedAt)} -> ${(0, output_1.formatTimestamp)(run.endsAt)}`);
+            console.log(`  duration ${formatRunDuration(run.startedAt, run.endsAt)} | units ${run.consumedUnits} | impressions ${run.deliveredImpressionCount} | views ${run.promotedDetailViewCount} | plays ${run.promotedPlayCount}`);
+        }
+    });
+}
+async function showBoostReport(rawRef, options = {}) {
+    const days = parsePositiveInteger(options.days, 'days', 30);
+    if (days === null) {
+        (0, messages_1.printErrorWithHelp)('The --days value must be a positive integer.', ['Example: --days 30'], { command: 'boosts report' });
+        process.exitCode = 1;
+        return;
+    }
+    await (0, commandContext_1.withEnvironment)('boosts report', 'Checking boost report', async ({ client }) => {
+        const { app } = await resolveAppForBoost(client, rawRef);
+        const response = await client.fetchAppBoostReport(app.id, resolveReportRangeFromDays(days));
+        if (options.json) {
+            (0, output_1.printJson)(response);
+            return;
+        }
+        console.log(`Boost report for ${app.displayName || app.name}:\n`);
+        for (const row of response.days) {
+            console.log(formatReportRow(row));
+        }
+    });
+}

package/dist/commands/browse.d.ts

@@ -1,4 +1,4 @@
-export type BrowseKind = 'app' | 'asset' | 'asset-pack' | 'all';
+export type BrowseKind = 'app' | 'asset' | 'asset-pack' | 'asset-spec' | 'all';
 export type BrowseCreator = 'all' | 'me' | string;
 export type BrowseOptions = {
     kind?: string;
@@ -6,8 +6,13 @@ export type BrowseOptions = {
     appType?: string;
     assetCategory?: string;
     assetSubcategory?: string;
+    assetSpec?: string;
+    assetSpecOwner?: string;
+    assetSpecName?: string;
+    sort?: string;
     limit?: string | number;
     offset?: string | number;
+    tag?: string[];
     json?: boolean;
 };
 export declare function browse(options?: BrowseOptions): Promise<void>;