@playdrop/playdrop-cli 0.3.1-build.1

package/dist/commands/init.js

@@ -0,0 +1,300 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const promises_1 = __importDefault(require("node:readline/promises"));
+const node_process_1 = require("node:process");
+const node_child_process_1 = require("node:child_process");
+const types_1 = require("@playdrop/types");
+const config_1 = require("../config");
+const apiClient_1 = require("../apiClient");
+const http_1 = require("../http");
+const environment_1 = require("../environment");
+const messages_1 = require("../messages");
+const clientInfo_1 = require("../clientInfo");
+const DEFAULT_CATALOGUE = `${JSON.stringify({ apps: [] }, null, 2)}\n`;
+function ensureTrailingNewline(content) {
+    return content.endsWith('\n') ? content : `${content}\n`;
+}
+function renderReadmeTemplate(template, replacements) {
+    let rendered = template;
+    for (const [key, value] of Object.entries(replacements)) {
+        const token = `{${key}}`;
+        rendered = rendered.split(token).join(value);
+    }
+    return rendered;
+}
+async function resolveUsername(apiBase, token) {
+    const client = (0, apiClient_1.createCliApiClient)({ baseUrl: apiBase, token });
+    try {
+        const data = await client.me();
+        const username = data.user?.username?.trim();
+        if (!username) {
+            (0, messages_1.printErrorWithHelp)('The Playdrop API returned an unexpected response.', [
+                'Retry "playdrop-cli init" in a moment.',
+                'If the problem continues, contact the Playdrop team.'
+            ], { command: 'init' });
+            process.exitCode = 1;
+            return null;
+        }
+        return username;
+    }
+    catch (unknownError) {
+        if (unknownError instanceof types_1.UnsupportedClientError) {
+            (0, http_1.handleUnsupportedError)(unknownError, 'Project bootstrap');
+            return null;
+        }
+        if (unknownError instanceof http_1.CLIUnsupportedClientError) {
+            throw unknownError;
+        }
+        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 init" again after logging in.'
+            ], { command: 'init' });
+            process.exitCode = 1;
+            return null;
+        }
+        const message = unknownError instanceof Error ? unknownError.message : String(unknownError);
+        (0, messages_1.printErrorWithHelp)('Could not reach the Playdrop API to resolve your account information.', [message], { command: 'init' });
+        process.exitCode = 1;
+        return null;
+    }
+}
+async function promptGitInitialization(label) {
+    if (!node_process_1.stdin.isTTY || !node_process_1.stdout.isTTY) {
+        return false;
+    }
+    const rl = promises_1.default.createInterface({ input: node_process_1.stdin, output: node_process_1.stdout });
+    const answer = await rl.question(`No git repository detected in ${label}. Run "git init"? (y/N) `);
+    rl.close();
+    return /^y(es)?$/i.test(answer.trim());
+}
+function runGitInit(directory) {
+    const result = (0, node_child_process_1.spawnSync)('git', ['init'], {
+        cwd: directory,
+        stdio: 'inherit',
+    });
+    return result.status === 0;
+}
+function normalizeBootstrapPayload(payload) {
+    if (!payload) {
+        return null;
+    }
+    const readmeUri = typeof payload.readmeUri === 'string' ? payload.readmeUri.trim() : '';
+    if (!readmeUri) {
+        (0, messages_1.printErrorWithHelp)('Bootstrap payload is missing a README URI.', ['Contact the platform team or try again shortly.'], { command: 'init' });
+        process.exitCode = 1;
+        return null;
+    }
+    const agentsUri = typeof payload.agentsUri === 'string' ? payload.agentsUri.trim() : '';
+    if (!agentsUri) {
+        (0, messages_1.printErrorWithHelp)('Bootstrap payload is missing an AGENTS URI.', ['Contact the platform team or try again shortly.'], { command: 'init' });
+        process.exitCode = 1;
+        return null;
+    }
+    const catalogueRaw = typeof payload.catalogue === 'string' && payload.catalogue.trim().length > 0
+        ? payload.catalogue
+        : DEFAULT_CATALOGUE;
+    const catalogue = ensureTrailingNewline(catalogueRaw.trim() ? catalogueRaw : DEFAULT_CATALOGUE);
+    return { readmeUri, agentsUri, catalogue };
+}
+async function downloadBootstrapAsset(webBase, uri, label) {
+    if (!webBase) {
+        (0, messages_1.printErrorWithHelp)(`Cannot download ${label} because the current environment is missing a web base URL.`, [
+            'Set PLAYDROP_WEB_BASE, PLAYDROP_WEB_BASE_DEV, or the appropriate environment override before running "playdrop-cli init".'
+        ], { command: 'init' });
+        process.exitCode = 1;
+        return null;
+    }
+    const url = new URL(uri, webBase).toString();
+    let response;
+    try {
+        response = await fetch(url);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        (0, messages_1.printErrorWithHelp)(`Failed to download ${label} from ${url}.`, [message], { command: 'init' });
+        process.exitCode = 1;
+        return null;
+    }
+    if (!response.ok) {
+        (0, messages_1.printErrorWithHelp)(`Failed to download ${label} from ${url}.`, [`HTTP ${response.status} ${response.statusText}`], { command: 'init' });
+        process.exitCode = 1;
+        return null;
+    }
+    const text = await response.text();
+    return ensureTrailingNewline(text);
+}
+async function fetchBootstrap(base) {
+    const client = (0, apiClient_1.createCliApiClient)({ baseUrl: base });
+    try {
+        const payload = await client.fetchCreatorBootstrap();
+        return payload;
+    }
+    catch (unknownError) {
+        if (unknownError instanceof types_1.UnsupportedClientError) {
+            (0, http_1.handleUnsupportedError)(unknownError, 'Project bootstrap');
+            return null;
+        }
+        if (unknownError instanceof http_1.CLIUnsupportedClientError) {
+            throw unknownError;
+        }
+        if (unknownError instanceof types_1.ApiError) {
+            throw unknownError;
+        }
+        throw unknownError;
+    }
+}
+async function init(targetPath, options = {}) {
+    const resolved = (0, node_path_1.resolve)(targetPath || '.');
+    let stats = null;
+    try {
+        stats = (0, node_fs_1.statSync)(resolved);
+    }
+    catch {
+        // directory will be created
+    }
+    if (stats && !stats.isDirectory()) {
+        (0, messages_1.printErrorWithHelp)(`Cannot initialize a Playdrop project because ${resolved} is not a directory.`, [
+            'Choose a directory path (use "." for the current folder) or create the directory before running "playdrop-cli init".'
+        ], { command: 'init' });
+        process.exitCode = 1;
+        return null;
+    }
+    (0, node_fs_1.mkdirSync)(resolved, { recursive: true });
+    const cataloguePath = (0, node_path_1.join)(resolved, 'catalogue.json');
+    const catalogueExisted = (0, node_fs_1.existsSync)(cataloguePath);
+    const cfg = (0, config_1.loadConfig)();
+    if (!cfg.token) {
+        (0, messages_1.printLoginRequired)('Bootstrapping a Playdrop project', 'init');
+        process.exitCode = 1;
+        return null;
+    }
+    const preferredEnv = cfg.env ?? 'prod';
+    let envConfig = (0, environment_1.resolveEnvironmentConfig)(preferredEnv);
+    if (!envConfig && preferredEnv !== 'prod') {
+        envConfig = (0, environment_1.resolveEnvironmentConfig)('prod');
+    }
+    if (!envConfig) {
+        const choices = (0, environment_1.formatEnvironmentList)();
+        (0, messages_1.printUnknownEnvironment)(preferredEnv, choices, 'init');
+        process.exitCode = 1;
+        return null;
+    }
+    if (envConfig.allowInsecureRequests) {
+        process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+    }
+    let bootstrap = null;
+    try {
+        bootstrap = await fetchBootstrap(envConfig.apiBase);
+    }
+    catch (error) {
+        if (error instanceof http_1.CLIUnsupportedClientError) {
+            return null;
+        }
+        throw error;
+    }
+    const normalized = normalizeBootstrapPayload(bootstrap);
+    if (!normalized) {
+        return null;
+    }
+    const readmePath = (0, node_path_1.join)(resolved, 'README.md');
+    const agentsPath = (0, node_path_1.join)(resolved, 'AGENTS.md');
+    const actions = [];
+    const readmeExisted = (0, node_fs_1.existsSync)(readmePath);
+    const agentsExisted = (0, node_fs_1.existsSync)(agentsPath);
+    let username = null;
+    try {
+        username = await resolveUsername(envConfig.apiBase, cfg.token);
+    }
+    catch (error) {
+        if (error instanceof http_1.CLIUnsupportedClientError) {
+            return null;
+        }
+        throw error;
+    }
+    if (!username) {
+        return null;
+    }
+    const readmeDownload = await downloadBootstrapAsset(envConfig.webBase, normalized.readmeUri, 'README.md');
+    if (!readmeDownload) {
+        return null;
+    }
+    const replacements = {
+        username,
+        version: (0, clientInfo_1.getCliVersion)(),
+        build: String((0, clientInfo_1.getCliBuild)()),
+        date: new Date().toISOString().slice(0, 10),
+    };
+    const renderedReadme = ensureTrailingNewline(renderReadmeTemplate(readmeDownload, replacements));
+    (0, node_fs_1.writeFileSync)(readmePath, renderedReadme, 'utf8');
+    actions.push(readmeExisted ? 'Updated README.md' : 'Created README.md');
+    const agentsDownload = await downloadBootstrapAsset(envConfig.webBase, normalized.agentsUri, 'AGENTS.md');
+    if (!agentsDownload) {
+        return null;
+    }
+    (0, node_fs_1.writeFileSync)(agentsPath, agentsDownload, 'utf8');
+    actions.push(agentsExisted ? 'Updated AGENTS.md' : 'Created AGENTS.md');
+    if (!catalogueExisted) {
+        (0, node_fs_1.writeFileSync)(cataloguePath, normalized.catalogue, 'utf8');
+        actions.push('Created catalogue.json');
+    }
+    else {
+        actions.push('Skipped existing catalogue.json');
+    }
+    const label = (0, node_path_1.relative)(process.cwd(), resolved) || '.';
+    const gitDirPath = (0, node_path_1.join)(resolved, '.git');
+    const hasGitRepo = (0, node_fs_1.existsSync)(gitDirPath);
+    let gitStatus = 'skipped';
+    if (!hasGitRepo) {
+        if (!options.quiet && node_process_1.stdin.isTTY && node_process_1.stdout.isTTY) {
+            const consent = await promptGitInitialization(label);
+            if (consent) {
+                const success = runGitInit(resolved);
+                if (success) {
+                    gitStatus = 'initialized';
+                    actions.push('Initialized git repository');
+                }
+                else {
+                    gitStatus = 'declined';
+                    actions.push('git init failed (install Git and retry)');
+                    process.exitCode = process.exitCode || 1;
+                }
+            }
+            else {
+                gitStatus = 'declined';
+                actions.push('Skipped git init (declined)');
+            }
+        }
+        else if (!options.quiet) {
+            actions.push('Skipped git init (non-interactive)');
+        }
+    }
+    else if (!options.quiet) {
+        actions.push('Detected existing git repository');
+    }
+    const summary = {
+        directory: resolved,
+        cataloguePath,
+        readmeStatus: readmeExisted ? 'updated' : 'created',
+        agentsStatus: agentsExisted ? 'updated' : 'created',
+        catalogueStatus: catalogueExisted ? 'skipped' : 'created',
+        gitStatus,
+    };
+    if (!options.quiet) {
+        console.log(`Initialized Playdrop project in ${label}`);
+        for (const action of actions) {
+            console.log(` - ${action}`);
+        }
+        console.log('\nNext steps:');
+        console.log(' - Run "playdrop-cli create <app-name>" to scaffold your first app.');
+        console.log(' - Use "playdrop-cli dev <app-name>" to preview locally.');
+        console.log(' - Upload with "playdrop-cli upload ." when ready to share.');
+    }
+    return summary;
+}

package/dist/commands/list.d.ts

@@ -0,0 +1,7 @@
+type ListOptions = {
+    type?: string;
+    creator?: string;
+    max?: string | number;
+};
+export declare function list(options?: ListOptions): Promise<void>;
+export {};

package/dist/commands/list.js

@@ -0,0 +1,347 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.list = list;
+const types_1 = require("@playdrop/types");
+const http_1 = require("../http");
+const messages_1 = require("../messages");
+const commandContext_1 = require("../commandContext");
+const ALL_APP_TYPES = [...types_1.APP_TYPE_VALUES];
+function normalizePluralCandidate(value) {
+    const trimmed = value.trim();
+    if (trimmed.length > 1 && trimmed.toUpperCase().endsWith('S')) {
+        return trimmed.slice(0, -1);
+    }
+    return trimmed;
+}
+function parseAppTypeOption(value) {
+    const normalized = normalizePluralCandidate(value).toUpperCase();
+    return (0, types_1.parseAppType)(normalized);
+}
+function resolveTypeSelection(raw) {
+    if (!raw || raw.trim().length === 0) {
+        return { appTypes: ALL_APP_TYPES, includeAssets: true, includePacks: true };
+    }
+    const normalized = raw.trim().toLowerCase();
+    if (normalized === 'all') {
+        return { appTypes: ALL_APP_TYPES, includeAssets: true, includePacks: true };
+    }
+    if (normalized === 'app' || normalized === 'apps') {
+        return { appTypes: ALL_APP_TYPES, includeAssets: false, includePacks: false };
+    }
+    if (normalized === 'asset' || normalized === 'assets') {
+        return { appTypes: [], includeAssets: true, includePacks: false };
+    }
+    if (normalized === 'pack' || normalized === 'packs' || normalized === 'asset-pack' || normalized === 'asset-packs') {
+        return { appTypes: [], includeAssets: false, includePacks: true };
+    }
+    const appType = parseAppTypeOption(normalized);
+    if (appType) {
+        return { appTypes: [appType], includeAssets: false, includePacks: false };
+    }
+    return null;
+}
+function resolveCreatorSelection(raw) {
+    if (!raw || raw.trim().length === 0) {
+        return { kind: 'all' };
+    }
+    const normalized = raw.trim().toLowerCase();
+    if (normalized === 'me') {
+        return { kind: 'me' };
+    }
+    if (normalized === 'all') {
+        return { kind: 'all' };
+    }
+    if (normalized.includes(' ')) {
+        return null;
+    }
+    return { kind: 'creator', username: raw.trim() };
+}
+function resolveMaxValue(raw) {
+    if (raw === undefined) {
+        return 10;
+    }
+    const parsed = typeof raw === 'number' ? raw : Number.parseInt(String(raw), 10);
+    if (!Number.isFinite(parsed) || !Number.isInteger(parsed)) {
+        return null;
+    }
+    if (parsed < 1 || parsed > 100) {
+        return null;
+    }
+    return parsed;
+}
+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;
+}
+async function fetchCurrentUsername(client) {
+    try {
+        const response = await client.me();
+        const username = response?.user?.username;
+        if (typeof username === 'string' && username.trim().length > 0) {
+            return username.trim();
+        }
+        return null;
+    }
+    catch (error) {
+        if (error instanceof types_1.UnsupportedClientError) {
+            (0, http_1.handleUnsupportedError)(error, 'List');
+        }
+        if (error instanceof http_1.CLIUnsupportedClientError) {
+            throw error;
+        }
+        if (error instanceof types_1.ApiError) {
+            throw error;
+        }
+        throw error;
+    }
+}
+function normalizeCreatorUsername(username) {
+    if (!username) {
+        return null;
+    }
+    const trimmed = username.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function appTypeToSlug(type) {
+    return type.toLowerCase();
+}
+function getDescription(value) {
+    if (typeof value !== 'string') {
+        return '';
+    }
+    return value.trim();
+}
+function upsertRecord(recordMap, key, displayName, description, taxonomy) {
+    if (!recordMap.has(key)) {
+        recordMap.set(key, {
+            displayName,
+            description: getDescription(description),
+            taxonomy: typeof taxonomy === 'string' && taxonomy.trim().length > 0 ? taxonomy.trim() : undefined,
+        });
+    }
+}
+async function list(options = {}) {
+    await (0, commandContext_1.withEnvironment)('list', 'Listing content', async ({ client }) => {
+        const typeSelection = resolveTypeSelection(options.type);
+        if (!typeSelection) {
+            (0, messages_1.printErrorWithHelp)(`Type "${options.type ?? ''}" is not supported.`, [
+                'Use one of: all, app(s), game(s), template(s), tool(s), demo(s), asset(s), pack(s).',
+            ], { command: 'list' });
+            process.exitCode = 1;
+            return;
+        }
+        const creatorSelection = resolveCreatorSelection(options.creator);
+        if (!creatorSelection) {
+            (0, messages_1.printErrorWithHelp)('Creator value is invalid.', ['Use "me", "all", or provide a creator slug without spaces.'], { command: 'list' });
+            process.exitCode = 1;
+            return;
+        }
+        const max = resolveMaxValue(options.max);
+        if (max === null) {
+            (0, messages_1.printErrorWithHelp)('The --max value must be an integer between 1 and 100.', ['Example: --max 10'], { command: 'list' });
+            process.exitCode = 1;
+            return;
+        }
+        const activeTypeSelection = typeSelection;
+        const activeCreatorSelection = creatorSelection;
+        const activeMax = max;
+        let resolvedCreatorUsername = null;
+        if (activeCreatorSelection.kind === 'me') {
+            try {
+                resolvedCreatorUsername = await fetchCurrentUsername(client);
+            }
+            catch (error) {
+                if (error instanceof http_1.CLIUnsupportedClientError) {
+                    return;
+                }
+                if (error instanceof types_1.UnsupportedClientError) {
+                    (0, http_1.handleUnsupportedError)(error, 'List');
+                }
+                if (error instanceof types_1.ApiError) {
+                    (0, messages_1.printErrorWithHelp)(`Failed to resolve your account (status ${error.status}).`, ['Run "playdrop-cli login" to refresh your session, then try again.'], { command: 'list' });
+                    process.exitCode = 1;
+                    return;
+                }
+                if (isNetworkError(error)) {
+                    (0, messages_1.printNetworkIssue)('Could not reach the API to resolve your account.', 'list');
+                    process.exitCode = 1;
+                    return;
+                }
+                throw error;
+            }
+            resolvedCreatorUsername = normalizeCreatorUsername(resolvedCreatorUsername);
+            if (!resolvedCreatorUsername) {
+                (0, messages_1.printErrorWithHelp)('The API returned an unexpected response.', ['Retry "playdrop-cli list" in a moment.'], { command: 'list' });
+                process.exitCode = 1;
+                return;
+            }
+        }
+        else if (activeCreatorSelection.kind === 'creator') {
+            resolvedCreatorUsername = normalizeCreatorUsername(activeCreatorSelection.username);
+            if (!resolvedCreatorUsername) {
+                (0, messages_1.printErrorWithHelp)('Creator slug cannot be empty.', ['Provide a creator username like "playdrop".'], {
+                    command: 'list',
+                });
+                process.exitCode = 1;
+                return;
+            }
+        }
+        const recordMap = new Map();
+        async function listApps() {
+            if (activeTypeSelection.appTypes.length === 0) {
+                return true;
+            }
+            try {
+                let apps = [];
+                if (activeCreatorSelection.kind === 'me') {
+                    const response = await client.fetchCreatorApps();
+                    apps = Array.isArray(response?.apps) ? response.apps : [];
+                }
+                else {
+                    const response = await client.fetchApps();
+                    apps = Array.isArray(response?.apps) ? response.apps : [];
+                }
+                if ((activeCreatorSelection.kind === 'creator' || activeCreatorSelection.kind === 'me') && resolvedCreatorUsername) {
+                    const creator = resolvedCreatorUsername.toLowerCase();
+                    apps = apps.filter((app) => app.creatorUsername.toLowerCase() === creator);
+                }
+                const allowedTypes = new Set(activeTypeSelection.appTypes);
+                for (const app of apps) {
+                    if (!allowedTypes.has(app.type)) {
+                        continue;
+                    }
+                    const key = `${app.creatorUsername}/${appTypeToSlug(app.type)}/${app.name}`;
+                    upsertRecord(recordMap, key, app.displayName || app.name, app.description);
+                }
+                return true;
+            }
+            catch (error) {
+                if (error instanceof http_1.CLIUnsupportedClientError) {
+                    return false;
+                }
+                if (error instanceof types_1.UnsupportedClientError) {
+                    (0, http_1.handleUnsupportedError)(error, 'List apps');
+                }
+                if (error instanceof types_1.ApiError) {
+                    (0, messages_1.printErrorWithHelp)(`Request failed (status ${error.status}).`, ['Retry in a moment.'], {
+                        command: 'list',
+                    });
+                    process.exitCode = 1;
+                    return false;
+                }
+                if (isNetworkError(error)) {
+                    (0, messages_1.printNetworkIssue)('Could not reach the API to list apps.', 'list');
+                    process.exitCode = 1;
+                    return false;
+                }
+                throw error;
+            }
+        }
+        async function listAssets() {
+            if (!activeTypeSelection.includeAssets) {
+                return true;
+            }
+            try {
+                const response = resolvedCreatorUsername
+                    ? await client.listAssetsForCreator(resolvedCreatorUsername, { limit: activeMax, offset: 0 })
+                    : await client.listAssets({ limit: activeMax, offset: 0 });
+                const rows = Array.isArray(response?.assets) ? response.assets : [];
+                for (const asset of rows) {
+                    const key = `${asset.creatorUsername}/asset/${asset.name}`;
+                    const taxonomy = asset.currentVersion ? `${asset.category}:${asset.currentVersion.subcategory}` : asset.category;
+                    upsertRecord(recordMap, key, asset.displayName || asset.name, asset.description, taxonomy);
+                }
+                return true;
+            }
+            catch (error) {
+                if (error instanceof http_1.CLIUnsupportedClientError) {
+                    return false;
+                }
+                if (error instanceof types_1.UnsupportedClientError) {
+                    (0, http_1.handleUnsupportedError)(error, 'List assets');
+                }
+                if (error instanceof types_1.ApiError) {
+                    (0, messages_1.printErrorWithHelp)(`Request failed (status ${error.status}).`, ['Retry in a moment.'], {
+                        command: 'list',
+                    });
+                    process.exitCode = 1;
+                    return false;
+                }
+                if (isNetworkError(error)) {
+                    (0, messages_1.printNetworkIssue)('Could not reach the API to list assets.', 'list');
+                    process.exitCode = 1;
+                    return false;
+                }
+                throw error;
+            }
+        }
+        async function listPacks() {
+            if (!activeTypeSelection.includePacks) {
+                return true;
+            }
+            try {
+                const response = resolvedCreatorUsername
+                    ? await client.listAssetPacksForCreator(resolvedCreatorUsername, { limit: activeMax, offset: 0 })
+                    : await client.listAssetPacks({ limit: activeMax, offset: 0 });
+                const rows = Array.isArray(response?.packs) ? response.packs : [];
+                for (const pack of rows) {
+                    const key = `${pack.creatorUsername}/pack/${pack.name}`;
+                    upsertRecord(recordMap, key, pack.displayName || pack.name, pack.description);
+                }
+                return true;
+            }
+            catch (error) {
+                if (error instanceof http_1.CLIUnsupportedClientError) {
+                    return false;
+                }
+                if (error instanceof types_1.UnsupportedClientError) {
+                    (0, http_1.handleUnsupportedError)(error, 'List packs');
+                }
+                if (error instanceof types_1.ApiError) {
+                    (0, messages_1.printErrorWithHelp)(`Request failed (status ${error.status}).`, ['Retry in a moment.'], {
+                        command: 'list',
+                    });
+                    process.exitCode = 1;
+                    return false;
+                }
+                if (isNetworkError(error)) {
+                    (0, messages_1.printNetworkIssue)('Could not reach the API to list packs.', 'list');
+                    process.exitCode = 1;
+                    return false;
+                }
+                throw error;
+            }
+        }
+        if (!(await listApps()))
+            return;
+        if (!(await listAssets()))
+            return;
+        if (!(await listPacks()))
+            return;
+        const keys = Array.from(recordMap.keys()).sort((a, b) => a.localeCompare(b)).slice(0, activeMax);
+        if (keys.length === 0) {
+            console.log('No results found for the selected filters.');
+            return;
+        }
+        for (const key of keys) {
+            const entry = recordMap.get(key);
+            const taxonomySegment = entry.taxonomy ? `, taxonomy=${entry.taxonomy}` : '';
+            console.log(`${key}, ${entry.displayName}, ${entry.description}${taxonomySegment}`);
+        }
+    });
+}

package/dist/commands/login.d.ts

@@ -0,0 +1,10 @@
+import { Writable } from 'node:stream';
+export declare class MaskedStdout extends Writable {
+    private readonly target;
+    muted: boolean;
+    constructor(target?: NodeJS.WriteStream & {
+        fd: 1;
+    });
+    _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+}
+export declare function login(env: string, usernameArg?: string, passwordArg?: string): Promise<void>;