@visionfi/server-cli/dist/commands/package.js

Command-line interface for VisionFI Server SDK

/**
 * Package management commands for VisionFI CLI
 * Copyright (c) 2024-2025 VisionFI. All Rights Reserved.
 */
import { Display } from '../utils/display.js';
import { createClient } from '../utils/config.js';
/**
 * Create a new package
 */
export async function createPackage(options) {
    const spinner = Display.spinner('Creating package...');
    try {
        const client = createClient();
        const packageOptions = {
            productType: options.productType,
            description: options.description,
            externalReferenceIds: options.externalRef || [],
            // New individual reference fields
            externalReference1: options.ref1,
            externalReference2: options.ref2,
            externalReference3: options.ref3,
            externalReference4: options.ref4,
            externalReference5: options.ref5,
            // Semantic fields
            externalCategory: options.category,
            externalOwner: options.owner
        };
        // Remove undefined fields
        Object.keys(packageOptions).forEach(key => {
            if (packageOptions[key] === undefined) {
                delete packageOptions[key];
            }
        });
        const result = await client.packages.create(packageOptions);
        spinner.succeed('Package created');
        Display.success(`Package created with ID: ${result.packageId}`);
        Display.json(result);
    }
    catch (error) {
        spinner.fail('Failed to create package');
        Display.error(error.message);
        process.exit(1);
    }
}
/**
 * List packages
 */
export async function listPackages(options) {
    const spinner = Display.spinner('Fetching packages...');
    try {
        const client = createClient();
        const listOptions = {};
        // Legacy parameter
        if (options.externalRef)
            listOptions.externalReferences = options.externalRef;
        // New parameters
        if (options.tags)
            listOptions.tags = options.tags;
        if (options.ref1)
            listOptions.ref1 = options.ref1;
        if (options.ref2)
            listOptions.ref2 = options.ref2;
        if (options.ref3)
            listOptions.ref3 = options.ref3;
        if (options.ref4)
            listOptions.ref4 = options.ref4;
        if (options.ref5)
            listOptions.ref5 = options.ref5;
        if (options.category)
            listOptions.category = options.category;
        if (options.owner)
            listOptions.owner = options.owner;
        // Existing parameters
        if (options.productType)
            listOptions.productTypes = options.productType;
        if (options.createdAfter)
            listOptions.createdAfter = options.createdAfter;
        const result = await client.packages.list(listOptions);
        spinner.succeed(`Found ${result.total} packages`);
        if (result.packages.length === 0) {
            Display.info('No packages found');
            return;
        }
        // Display as table
        const tableData = result.packages.map((pkg) => ({
            ID: pkg.packageId,
            Description: pkg.description || '-',
            'Product Type': pkg.productType,
            Status: pkg.status,
            Files: pkg.totalFiles,
            Created: new Date(pkg.createdAt).toLocaleDateString()
        }));
        Display.table(tableData);
    }
    catch (error) {
        spinner.fail('Failed to list packages');
        Display.error(error.message);
        process.exit(1);
    }
}
/**
 * Get package details
 */
export async function getPackage(packageId) {
    const spinner = Display.spinner('Fetching package details...');
    try {
        const client = createClient();
        const result = await client.packages.get(packageId);
        spinner.succeed('Package details retrieved');
        Display.header('Package Information');
        Display.keyValue('Package ID', result.packageId);
        Display.keyValue('Description', result.description || '-');
        Display.keyValue('Product Type', result.productType);
        Display.keyValue('Status', result.status);
        Display.keyValue('Total Files', result.totalFiles);
        Display.keyValue('Created', new Date(result.createdAt).toLocaleString());
        Display.keyValue('Updated', new Date(result.updatedAt).toLocaleString());
        if (result.externalReferenceIds && result.externalReferenceIds.length > 0) {
            Display.header('External References (Array)');
            Display.list(result.externalReferenceIds);
        }
        // Display individual reference fields if present
        const refFields = [];
        if (result.externalReference1)
            refFields.push(`Ref1: ${result.externalReference1}`);
        if (result.externalReference2)
            refFields.push(`Ref2: ${result.externalReference2}`);
        if (result.externalReference3)
            refFields.push(`Ref3: ${result.externalReference3}`);
        if (result.externalReference4)
            refFields.push(`Ref4: ${result.externalReference4}`);
        if (result.externalReference5)
            refFields.push(`Ref5: ${result.externalReference5}`);
        if (result.externalCategory)
            refFields.push(`Category: ${result.externalCategory}`);
        if (result.externalOwner)
            refFields.push(`Owner: ${result.externalOwner}`);
        if (refFields.length > 0) {
            Display.header('External Reference Fields');
            Display.list(refFields);
        }
        if (result.documentList.length > 0) {
            Display.header('Documents');
            const docs = result.documentList.map((doc) => `${doc.fileName} (${doc.fileType}) - ${doc.fileStatus}`);
            Display.list(docs);
        }
        if (result.availableProcessingOptions.length > 0) {
            Display.header('Available Processing Options');
            result.availableProcessingOptions.forEach((opt) => {
                Display.keyValue(opt.configId, opt.description);
            });
        }
    }
    catch (error) {
        spinner.fail('Failed to get package');
        Display.error(error.message);
        process.exit(1);
    }
}
/**
 * Get package audit history
 */
export async function getPackageAudit(packageId, options) {
    const spinner = Display.spinner('Fetching audit history...');
    try {
        const client = createClient();
        const limit = options.limit ? parseInt(options.limit) : undefined;
        const result = await client.packages.getAuditHistory(packageId, limit);
        spinner.succeed('Audit history retrieved');
        if (result.auditEntries && result.auditEntries.length > 0) {
            Display.table(result.auditEntries.map((entry) => ({
                'Timestamp': new Date(entry.timestamp).toLocaleString(),
                'Action': entry.action,
                'User': entry.userId || 'System',
                'Details': entry.details || '-'
            })));
        }
        else {
            Display.info('No audit history found');
        }
    }
    catch (error) {
        spinner.fail('Failed to get audit history');
        Display.error(error.message);
        process.exit(1);
    }
}
/**
 * Add external references to a package
 */
export async function addExternalReferences(packageId, options) {
    const spinner = Display.spinner('Adding external references...');
    try {
        const client = createClient();
        const result = await client.packages.addExternalReferences(packageId, {
            externalReferences: options.refs
        });
        spinner.succeed('External references added');
        Display.success(`Total external references: ${result.externalReferenceIds?.length || 0}`);
        if (result.externalReferenceIds) {
            Display.list(result.externalReferenceIds);
        }
    }
    catch (error) {
        spinner.fail('Failed to add external references');
        Display.error(error.message);
        process.exit(1);
    }
}
/**
 * Remove external references from a package
 */
export async function removeExternalReferences(packageId, options) {
    const spinner = Display.spinner('Removing external references...');
    try {
        const client = createClient();
        const result = await client.packages.removeExternalReferences(packageId, {
            externalReferences: options.refs
        });
        spinner.succeed('External references removed');
        Display.success(`Remaining external references: ${result.externalReferenceIds?.length || 0}`);
        if (result.externalReferenceIds && result.externalReferenceIds.length > 0) {
            Display.list(result.externalReferenceIds);
        }
    }
    catch (error) {
        spinner.fail('Failed to remove external references');
        Display.error(error.message);
        process.exit(1);
    }
}