@fnndsc/chili 3.2.5

package/dist/commands/plugins/add.js

@@ -0,0 +1,374 @@
+/**
+ * @file Implements the logic for adding (registering) new ChRIS plugins.
+ *
+ * This module orchestrates a three-phase plugin registration strategy:
+ * 1. Check if plugin exists in current CUBE → assign to compute resources
+ * 2. Search peer stores → import from store if found
+ * 3. Docker extraction → pull image, extract JSON, register
+ *
+ * @module
+ */
+import { docker_checkAvailability, shellCommand_runWithDetails, docker_pullImage, docker_getImageCmd, } from '../../utils/docker.js';
+import { plugin_registerWithAdmin, plugin_checkExists, plugins_searchPeers, plugin_importFromStore, } from '@fnndsc/salsa';
+import { computeResources_validate, computeResourceNames_parse, computeResources_getAll, errorStack, } from '@fnndsc/cumin';
+import path from 'path';
+import { input_detectFormat, PluginInputFormat, } from '../../utils/input_format.js';
+import { adminCredentials_prompt, } from '../../utils/admin_prompt.js';
+async function computeResources_resolve(options) {
+    if (options.compute) {
+        const names = computeResourceNames_parse(options.compute);
+        const validationResult = await computeResources_validate(names);
+        if (!validationResult.ok) {
+            const errors = errorStack.allOfType_get('error');
+            errors.forEach((err) => console.error(err));
+            return { ok: false };
+        }
+        return { ok: true, value: names };
+    }
+    const allResult = await computeResources_getAll();
+    if (allResult.ok && allResult.value.length > 0) {
+        const names = allResult.value.map((r) => r.name);
+        console.log(`Using compute resources: ${names.join(', ')}`);
+        return { ok: true, value: names };
+    }
+    return { ok: true, value: ['host'] };
+}
+/**
+ * Adds a plugin to the ChRIS store from the given input.
+ *
+ * @param input - Plugin source (image, URL, or path).
+ * @param options - Plugin add options.
+ * @returns The add outcome.
+ */
+export async function plugin_add(input, options) {
+    const detected = input_detectFormat(input);
+    console.log(`Detected input format: ${detected.format}`);
+    const resourcesResult = await computeResources_resolve(options);
+    if (!resourcesResult.ok)
+        return 'failed';
+    const computeResources = resourcesResult.value;
+    // Phase 1: Check if plugin exists in current CUBE
+    console.log('\n=== Phase 1: Checking current CUBE ===');
+    const searchTerm = detected.format === PluginInputFormat.DOCKER_IMAGE
+        ? detected.pluginName || detected.value
+        : detected.value;
+    const existingPlugin = await plugin_checkExists(searchTerm);
+    if (existingPlugin) {
+        return 'already_exists';
+    }
+    console.log('Plugin not found in current CUBE.');
+    // Phase 2: Search peer stores (skip if input is store URL)
+    if (detected.format !== PluginInputFormat.STORE_URL) {
+        console.log('\n=== Phase 2: Searching peer stores ===');
+        const peerStoreUrls = options.store
+            ? [options.store]
+            : ['https://cube.chrisproject.org/api/v1/'];
+        const searchName = detected.format === PluginInputFormat.DOCKER_IMAGE
+            ? detected.pluginName // Should be present for docker images
+            : detected.value;
+        const searchVersion = detected.format === PluginInputFormat.DOCKER_IMAGE
+            ? detected.version
+            : undefined;
+        const peerResult = await plugins_searchPeers(searchName, searchVersion, peerStoreUrls);
+        if (peerResult) {
+            console.log(`Found plugin in peer store: ${peerResult.storeName}`);
+            const ok = await pluginFromStore_register(peerResult.plugin, computeResources, options);
+            return ok ? 'installed' : 'failed';
+        }
+        console.log('Plugin not found in peer stores.');
+    }
+    // Phase 3: Docker extraction (only for Docker images or plugin names)
+    if (detected.format !== PluginInputFormat.STORE_URL) {
+        console.log('\n=== Phase 3: Docker extraction ===');
+        const dockerImage = detected.format === PluginInputFormat.DOCKER_IMAGE
+            ? detected.value
+            : `${detected.value}:latest`; // Assume latest tag for plugin names
+        const ok = await pluginFromDocker_register(dockerImage, computeResources, options);
+        return ok ? 'installed' : 'failed';
+    }
+    // If we get here with a store URL, we couldn't process it
+    console.error('Store URL import not yet fully supported.');
+    return 'failed';
+}
+/**
+ * Registers a plugin from peer store data.
+ *
+ * Handles admin authentication with retry logic (up to 3 attempts).
+ *
+ * @param pluginData - Plugin data from peer store.
+ * @param computeResources - Compute resources to assign plugin to.
+ * @param options - CLI options including admin credentials.
+ * @returns Promise resolving to success boolean.
+ */
+async function pluginFromStore_register(pluginData, computeResources, options) {
+    console.log('Importing plugin from peer store...');
+    const initialCreds = options.adminUser && options.adminPassword
+        ? { username: options.adminUser, password: options.adminPassword }
+        : undefined;
+    // Try with provided credentials (or current user)
+    const result = await plugin_importFromStore('', // Store URL not needed when we have plugin data
+    pluginData, computeResources, initialCreds);
+    if (result.success) {
+        console.log(`Plugin '${result.plugin?.name}' registered successfully.`);
+        return true;
+    }
+    if (!result.requiresAuth) {
+        console.error(result.errorMessage || 'Failed to import plugin from store.');
+        return false;
+    }
+    // Admin auth required - try with interactive credentials
+    const retrySuccess = await registrationWithAuth_retry(async (creds) => {
+        const retryResult = await plugin_importFromStore('', pluginData, computeResources, creds);
+        return retryResult.success;
+    }, options);
+    if (!retrySuccess) {
+        console.error('Failed to import plugin from store (authentication failed or rejected).');
+        const errors = errorStack.allOfType_get('error');
+        if (errors.length > 0) {
+            console.error('Errors:');
+            errors.forEach((e) => console.error(`- ${e}`));
+        }
+        const warnings = errorStack.allOfType_get('warning');
+        if (warnings.length > 0) {
+            console.error('Warnings:');
+            warnings.forEach((e) => console.error(`- ${e}`));
+        }
+    }
+    return retrySuccess;
+}
+/**
+ * Registers a plugin from Docker image.
+ *
+ * Pulls image (or uses local), extracts JSON descriptor, and registers with admin API.
+ *
+ * @param image - Docker image name/tag.
+ * @param computeResources - Compute resources to assign plugin to.
+ * @param options - CLI options including admin credentials.
+ * @returns Promise resolving to success boolean.
+ */
+async function pluginFromDocker_register(image, computeResources, options) {
+    if (!await docker_checkAvailability()) {
+        return false;
+    }
+    // Pull Docker image (checks local first)
+    const pulled = await docker_pullImage(image);
+    if (!pulled) {
+        return false;
+    }
+    console.log('Extracting plugin descriptor from image...');
+    const pluginData = await pluginJSON_extractFromImage(image, options);
+    if (!pluginData) {
+        const msg = 'Failed to extract plugin descriptor from image.';
+        console.error(msg);
+        errorStack.stack_push('error', msg);
+        return false;
+    }
+    // Infer missing fields
+    pluginData_inferMissingFields(pluginData, image, options);
+    const initialCreds = options.adminUser && options.adminPassword
+        ? { username: options.adminUser, password: options.adminPassword }
+        : undefined;
+    // Register with admin API
+    console.log('Registering plugin with ChRIS CUBE...');
+    const registered = await plugin_registerWithAdmin(pluginData, computeResources, initialCreds);
+    if (registered) {
+        console.log(`Plugin '${registered.name}' registered successfully.`);
+        return true;
+    }
+    // Check if failure was due to admin auth
+    const errors = errorStack.allOfType_get('error');
+    const authError = errors.some((e) => {
+        const lowerE = e.toLowerCase();
+        return lowerE.includes('unauthorized') ||
+            lowerE.includes('forbidden') ||
+            lowerE.includes('permission denied') ||
+            lowerE.includes('401') ||
+            lowerE.includes('403') ||
+            lowerE.includes('admin credentials required');
+    });
+    if (!authError) {
+        console.error('Failed to register plugin.');
+        return false;
+    }
+    // Retry with admin credentials
+    return await registrationWithAuth_retry(async (creds) => {
+        const retryResult = await plugin_registerWithAdmin(pluginData, computeResources, creds);
+        return retryResult !== null;
+    }, options);
+}
+/**
+ * Extracts plugin JSON descriptor from a Docker image.
+ *
+ * Tries three methods in order (matching chrisomatic behavior):
+ * 1. chris_plugin_info with arguments (post 0.3.0)
+ * 2. chris_plugin_info without arguments (pre 0.3.0)
+ * 3. <CMD> --json where CMD is extracted from image (old chrisapp)
+ *
+ * @param image - Docker image name/tag.
+ * @param options - Plugin add options (for inferring name/repo).
+ * @returns Promise resolving to plugin data or null.
+ */
+async function pluginJSON_extractFromImage(image, options) {
+    const methods = [
+        {
+            name: 'chris_plugin_info (post v0.3.0)',
+            fn: async () => await pluginJSON_tryChrisPluginInfoWithArgs(image, options),
+        },
+        {
+            name: 'chris_plugin_info (pre v0.3.0)',
+            fn: async () => await pluginJSON_tryChrisPluginInfo(image),
+        },
+        {
+            name: 'CMD --json (old chrisapp)',
+            fn: async () => await pluginJSON_tryOldChrisapp(image),
+        },
+    ];
+    for (const method of methods) {
+        console.log(`Trying ${method.name}...`);
+        const jsonString = await method.fn();
+        if (jsonString && jsonString.trim() !== '') {
+            try {
+                const parsed = JSON.parse(jsonString);
+                console.log(`Successfully extracted plugin descriptor using ${method.name}`);
+                return parsed;
+            }
+            catch (e) {
+                const msg = `Failed to parse JSON from ${method.name}`;
+                console.error(msg);
+                errorStack.stack_push('error', msg);
+            }
+        }
+    }
+    const msg = 'All plugin descriptor extraction methods failed';
+    errorStack.stack_push('error', msg);
+    errorStack.stack_push('error', 'This plugin may not be a ChRIS plugin, or uses an unsupported format');
+    return null;
+}
+/**
+ * Tries chris_plugin_info with arguments (post 0.3.0 format).
+ *
+ * @param image - Docker image name/tag.
+ * @param options - Plugin options for inferring name/repo.
+ * @returns Promise resolving to JSON string or null.
+ */
+async function pluginJSON_tryChrisPluginInfoWithArgs(image, options) {
+    const args = ['chris_plugin_info', '--dock-image', image];
+    if (options.public_repo) {
+        args.push('--public-repo', options.public_repo);
+    }
+    const command = `docker run --rm ${image} ${args.join(' ')}`;
+    const result = await shellCommand_runWithDetails(command);
+    if (!result.success || !result.stdout || result.stdout.trim() === '') {
+        if (result.error || result.stderr) {
+            errorStack.stack_push('warning', `chris_plugin_info (with args) failed: ${result.error || result.stderr}`);
+        }
+        return null;
+    }
+    return result.stdout;
+}
+/**
+ * Tries chris_plugin_info without arguments (pre 0.3.0 format).
+ *
+ * @param image - Docker image name/tag.
+ * @returns Promise resolving to JSON string or null.
+ */
+async function pluginJSON_tryChrisPluginInfo(image) {
+    const command = `docker run --rm ${image} chris_plugin_info`;
+    const result = await shellCommand_runWithDetails(command);
+    if (!result.success || !result.stdout || result.stdout.trim() === '') {
+        if (result.error || result.stderr) {
+            errorStack.stack_push('warning', `chris_plugin_info failed: ${result.error || result.stderr}`);
+        }
+        return null;
+    }
+    return result.stdout;
+}
+/**
+ * Tries old chrisapp format by extracting CMD and running with --json.
+ *
+ * @param image - Docker image name/tag.
+ * @returns Promise resolving to JSON string or null.
+ */
+async function pluginJSON_tryOldChrisapp(image) {
+    const cmd = await docker_getImageCmd(image);
+    if (cmd.length === 0) {
+        errorStack.stack_push('warning', 'Could not extract CMD from Docker image');
+        return null;
+    }
+    const command = `docker run --rm ${image} ${cmd[0]} --json`;
+    console.log(`  Running: ${cmd[0]} --json`);
+    const result = await shellCommand_runWithDetails(command);
+    if (!result.success || !result.stdout || result.stdout.trim() === '') {
+        if (result.error || result.stderr) {
+            errorStack.stack_push('warning', `${cmd[0]} --json failed: ${result.error || result.stderr}`);
+        }
+        return null;
+    }
+    return result.stdout;
+}
+/**
+ * Infers missing fields in plugin data from image name and options.
+ *
+ * Modifies pluginData in place.
+ *
+ * @param pluginData - Plugin data object to modify.
+ * @param image - Docker image name/tag.
+ * @param options - CLI options.
+ */
+function pluginData_inferMissingFields(pluginData, image, options) {
+    if (!pluginData.name) {
+        const imageNameWithoutTag = image.split(':')[0];
+        pluginData.name = path.basename(imageNameWithoutTag);
+        console.log(`Inferred plugin name: ${pluginData.name}`);
+    }
+    if (!pluginData.dock_image) {
+        pluginData.dock_image = image;
+        console.log(`Inferred dock_image: ${pluginData.dock_image}`);
+    }
+    if (!pluginData.public_repo && options.public_repo) {
+        pluginData.public_repo = options.public_repo;
+        console.log(`Using provided public_repo: ${pluginData.public_repo}`);
+    }
+    else if (!pluginData.public_repo && image.includes('/')) {
+        const repoGuess = image.split('/')[0] + '/' + path.basename(image.split(':')[0]);
+        pluginData.public_repo = `https://github.com/${repoGuess}`;
+        console.log(`Inferred public_repo: ${pluginData.public_repo}`);
+    }
+}
+/**
+ * Retries a registration operation with admin credential prompting.
+ *
+ * Allows up to 3 attempts. Uses provided credentials or prompts interactively.
+ *
+ * @param registrationFn - Function that attempts registration with credentials.
+ * @param options - CLI options including admin credentials.
+ * @returns Promise resolving to success boolean.
+ */
+async function registrationWithAuth_retry(registrationFn, options) {
+    const MAX_ATTEMPTS = 3;
+    // If credentials provided via flags, try once
+    if (options.adminUser && options.adminPassword) {
+        const creds = {
+            username: options.adminUser,
+            password: options.adminPassword,
+        };
+        return await registrationFn(creds);
+    }
+    // Interactive prompting with retry
+    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+        const creds = await adminCredentials_prompt(attempt, MAX_ATTEMPTS);
+        if (!creds) {
+            console.log('Authentication cancelled.');
+            return false;
+        }
+        const success = await registrationFn(creds);
+        if (success) {
+            return true;
+        }
+        if (attempt < MAX_ATTEMPTS) {
+            console.log('Authentication failed.');
+        }
+    }
+    console.error(`Authentication failed after ${MAX_ATTEMPTS} attempts.`);
+    return false;
+}

package/dist/commands/plugins/delete.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Resolves search terms to a list of plugin items.
+ *
+ * @param searchable - The search string.
+ * @returns A Promise resolving to an array of plugin items (table data).
+ */
+export declare function plugins_searchByTerm(searchable: string): Promise<Record<string, unknown>[]>;
+/**
+ * Deletes a plugin by its ID.
+ *
+ * @param id - The plugin ID.
+ * @returns A Promise resolving to `true` on success, `false` otherwise.
+ */
+export declare function plugin_deleteById(id: number): Promise<boolean>;

package/dist/commands/plugins/delete.js

@@ -0,0 +1,34 @@
+/**
+ * @file Implements the logic for searching and deleting ChRIS plugins.
+ *
+ * This module provides functionality to search for plugins by name/term
+ * and delete them by ID using the `@fnndsc/salsa` library.
+ *
+ * @module
+ */
+import { plugins_list as salsaPlugins_list, plugin_delete as salsaPlugin_delete } from "@fnndsc/salsa";
+import { options_toParams } from "../../utils/cli.js";
+/**
+ * Resolves search terms to a list of plugin items.
+ *
+ * @param searchable - The search string.
+ * @returns A Promise resolving to an array of plugin items (table data).
+ */
+export async function plugins_searchByTerm(searchable) {
+    const options = { search: searchable };
+    const params = options_toParams(options);
+    const results = await salsaPlugins_list(params);
+    if (!results || !results.tableData) {
+        return [];
+    }
+    return results.tableData;
+}
+/**
+ * Deletes a plugin by its ID.
+ *
+ * @param id - The plugin ID.
+ * @returns A Promise resolving to `true` on success, `false` otherwise.
+ */
+export async function plugin_deleteById(id) {
+    return await salsaPlugin_delete(id);
+}

package/dist/commands/plugins/fields.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Fetches the list of available fields for plugins.
+ *
+ * @returns A Promise resolving to an array of field names, or `null` if retrieval fails.
+ */
+export declare function pluginFields_fetch(): Promise<string[] | null>;

package/dist/commands/plugins/fields.js

@@ -0,0 +1,17 @@
+/**
+ * @file Implements the logic for retrieving available fields for ChRIS plugins.
+ *
+ * This module provides functionality to fetch the list of valid fields
+ * that can be displayed or queried for registered plugins.
+ *
+ * @module
+ */
+import { pluginFields_get as salsaPluginFields_get } from "@fnndsc/salsa";
+/**
+ * Fetches the list of available fields for plugins.
+ *
+ * @returns A Promise resolving to an array of field names, or `null` if retrieval fails.
+ */
+export async function pluginFields_fetch() {
+    return await salsaPluginFields_get();
+}

package/dist/commands/plugins/list.d.ts

@@ -0,0 +1,17 @@
+import { CLIoptions } from "../../utils/cli.js";
+import { Plugin } from "../../models/plugin.js";
+/**
+ * Result structure for plugin listing.
+ */
+export interface PluginListResult {
+    plugins: Plugin[];
+    selectedFields: string[];
+    totalCount?: number;
+}
+/**
+ * Fetches a list of ChRIS plugins based on options.
+ *
+ * @param options - CLI options containing filtering/pagination parameters.
+ * @returns A Promise resolving to a `PluginListResult` object.
+ */
+export declare function plugins_fetchList(options: CLIoptions): Promise<PluginListResult>;

package/dist/commands/plugins/list.js

@@ -0,0 +1,40 @@
+/**
+ * @file Implements the logic for listing ChRIS plugin resources.
+ *
+ * This module provides functionality to fetch lists of plugins
+ * from ChRIS using the `@fnndsc/salsa` library.
+ *
+ * @module
+ */
+import { plugins_list as salsaPlugins_list, plugins_listAll as salsaPlugins_listAll } from "@fnndsc/salsa";
+import { options_toParams } from "../../utils/cli.js";
+import { list_applySort } from "../../utils/sort.js";
+/**
+ * Fetches a list of ChRIS plugins based on options.
+ *
+ * @param options - CLI options containing filtering/pagination parameters.
+ * @returns A Promise resolving to a `PluginListResult` object.
+ */
+export async function plugins_fetchList(options) {
+    const params = options_toParams(options);
+    let result;
+    if (options.all) {
+        result = await salsaPlugins_listAll(params);
+    }
+    else {
+        result = await salsaPlugins_list(params);
+    }
+    if (result && result.tableData) {
+        let plugins = result.tableData;
+        // Apply sorting if specified
+        if (options.sort) {
+            plugins = list_applySort(plugins, options.sort, options.reverse);
+        }
+        return {
+            plugins,
+            selectedFields: result.selectedFields || [],
+            totalCount: result.totalCount,
+        };
+    }
+    return { plugins: [], selectedFields: [] };
+}

package/dist/commands/plugins/overview.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Displays an overview of registered plugins.
+ *
+ * @returns A Promise resolving to `void`.
+ */
+export declare function pluginsOverview_display(): Promise<void>;

package/dist/commands/plugins/overview.js

@@ -0,0 +1,17 @@
+/**
+ * @file Implements the logic for displaying a system overview of ChRIS plugins.
+ *
+ * This module provides functionality to print a summary or overview
+ * of the plugins available in the ChRIS system.
+ *
+ * @module
+ */
+import { plugins_overview as salsaPlugins_overview } from "@fnndsc/salsa";
+/**
+ * Displays an overview of registered plugins.
+ *
+ * @returns A Promise resolving to `void`.
+ */
+export async function pluginsOverview_display() {
+    return await salsaPlugins_overview();
+}

package/dist/commands/store/list.d.ts

@@ -0,0 +1,23 @@
+import { ListingItem } from '../../models/listing.js';
+import { CLIoptions } from '../../utils/cli.js';
+/**
+ * Options for listing store plugins.
+ */
+export interface StoreOptions extends CLIoptions {
+    store?: string;
+}
+/**
+ * Lists plugins from the store.
+ *
+ * @param options - CLI options.
+ * @returns Promise resolving to ListingItem array.
+ */
+export declare function store_listPlugins(options: StoreOptions): Promise<ListingItem[]>;
+/**
+ * Searches plugins in the store.
+ *
+ * @param query - Search query.
+ * @param options - CLI options.
+ * @returns Promise resolving to ListingItem array.
+ */
+export declare function store_searchPlugins(query: string, options: StoreOptions): Promise<ListingItem[]>;

package/dist/commands/store/list.js

@@ -0,0 +1,48 @@
+/**
+ * @file Store commands.
+ *
+ * Commands for interacting with the peer ChRIS store.
+ *
+ * @module
+ */
+import { store_list, store_search } from '@fnndsc/salsa';
+/**
+ * Maps raw store plugin data to ListingItem model.
+ */
+function storeItem_map(plugin) {
+    const name = plugin.name || 'unknown';
+    const version = plugin.version || '';
+    // Format name as name-vVersion to match chell's ls /bin style
+    // This ensures consistent colorization (green name, dim green version)
+    const displayName = version ? `${name}-v${version}` : name;
+    return {
+        name: displayName,
+        type: 'plugin', // This ensures green color
+        size: 0,
+        owner: plugin.authors || 'store',
+        date: plugin.creation_date || '',
+        // Set version to undefined to prevent grid_render from appending " (version)"
+        version: undefined
+    };
+}
+/**
+ * Lists plugins from the store.
+ *
+ * @param options - CLI options.
+ * @returns Promise resolving to ListingItem array.
+ */
+export async function store_listPlugins(options) {
+    const plugins = await store_list(options.store);
+    return plugins.map(storeItem_map);
+}
+/**
+ * Searches plugins in the store.
+ *
+ * @param query - Search query.
+ * @param options - CLI options.
+ * @returns Promise resolving to ListingItem array.
+ */
+export async function store_searchPlugins(query, options) {
+    const plugins = await store_search(query, options.store);
+    return plugins.map(storeItem_map);
+}

package/dist/commands/tags/fields.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Fetches the available tag field names.
+ *
+ * @returns The tag field names, or null on failure.
+ */
+export declare function tagFields_fetch(): Promise<string[] | null>;

package/dist/commands/tags/fields.js

@@ -0,0 +1,13 @@
+/**
+ * @file Fetches available fields for tag resources.
+ * @module
+ */
+import { tagFields_get } from '@fnndsc/salsa';
+/**
+ * Fetches the available tag field names.
+ *
+ * @returns The tag field names, or null on failure.
+ */
+export async function tagFields_fetch() {
+    return await tagFields_get();
+}

package/dist/commands/tags/list.d.ts

@@ -0,0 +1,16 @@
+import { CLIoptions } from '../../utils/cli.js';
+/**
+ * Result of listing tags (table data plus selected fields).
+ */
+export interface TagListResult {
+    tags: Record<string, unknown>[];
+    selectedFields: string[];
+    totalCount?: number;
+}
+/**
+ * Fetches a list of tags.
+ *
+ * @param options - List and filter options.
+ * @returns The tags list result.
+ */
+export declare function tags_fetchList(options: CLIoptions): Promise<TagListResult>;

package/dist/commands/tags/list.js

@@ -0,0 +1,26 @@
+/**
+ * @file Implements listing ChRIS tags.
+ * @module
+ */
+import { tags_list as salsaTags_list, tags_listAll as salsaTags_listAll } from '@fnndsc/salsa';
+import { options_toParams } from '../../utils/cli.js';
+import { list_applySort } from '../../utils/sort.js';
+/**
+ * Fetches a list of tags.
+ *
+ * @param options - List and filter options.
+ * @returns The tags list result.
+ */
+export async function tags_fetchList(options) {
+    const params = options_toParams(options);
+    const result = options.all
+        ? await salsaTags_listAll(params)
+        : await salsaTags_list(params);
+    if (result && result.tableData) {
+        let tags = result.tableData;
+        if (options.sort)
+            tags = list_applySort(tags, options.sort, options.reverse);
+        return { tags, selectedFields: result.selectedFields || [], totalCount: result.totalCount };
+    }
+    return { tags: [], selectedFields: [] };
+}

package/dist/commands/workflows/fields.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Fetches the available workflow field names.
+ *
+ * @returns The workflow field names, or null on failure.
+ */
+export declare function workflowFields_fetch(): Promise<string[] | null>;