@btc-vision/cli 1.0.0

package/build/commands/ListCommand.js

@@ -0,0 +1,117 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { BaseCommand } from './BaseCommand.js';
+import { parseOpnetBinary, formatFileSize } from '../lib/binary.js';
+export class ListCommand extends BaseCommand {
+    constructor() {
+        super('list', 'List installed plugins');
+    }
+    configure() {
+        this.command
+            .alias('ls')
+            .option('-d, --dir <path>', 'Plugins directory (default: ./plugins/)')
+            .option('--json', 'Output as JSON')
+            .option('-v, --verbose', 'Show detailed information')
+            .action((options) => this.execute(options));
+    }
+    execute(options) {
+        try {
+            const pluginsDir = options?.dir || path.join(process.cwd(), 'plugins');
+            if (!fs.existsSync(pluginsDir)) {
+                if (options?.json) {
+                    this.logger.log(JSON.stringify({ plugins: [], directory: pluginsDir }));
+                }
+                else {
+                    this.logger.warn('No plugins directory found.');
+                    this.logger.info(`Expected: ${pluginsDir}`);
+                }
+                return;
+            }
+            const files = fs.readdirSync(pluginsDir).filter((f) => f.endsWith('.opnet'));
+            if (files.length === 0) {
+                if (options?.json) {
+                    this.logger.log(JSON.stringify({ plugins: [], directory: pluginsDir }));
+                }
+                else {
+                    this.logger.warn('No plugins installed.');
+                }
+                return;
+            }
+            const plugins = [];
+            for (const file of files) {
+                const filePath = path.join(pluginsDir, file);
+                try {
+                    const data = fs.readFileSync(filePath);
+                    const parsed = parseOpnetBinary(data);
+                    const isUnsigned = parsed.publicKey.every((b) => b === 0);
+                    const mldsaLevel = [44, 65, 87][parsed.mldsaLevel];
+                    plugins.push({
+                        file,
+                        name: parsed.metadata.name,
+                        version: parsed.metadata.version,
+                        type: parsed.metadata.pluginType,
+                        size: data.length,
+                        signed: !isUnsigned,
+                        mldsaLevel,
+                        author: parsed.metadata.author.name,
+                        description: parsed.metadata.description,
+                    });
+                }
+                catch {
+                    plugins.push({
+                        file,
+                        name: '(invalid)',
+                        version: '-',
+                        type: '-',
+                        size: fs.statSync(filePath).size,
+                        signed: false,
+                        mldsaLevel: 44,
+                        author: '-',
+                    });
+                }
+            }
+            plugins.sort((a, b) => a.name.localeCompare(b.name));
+            if (options?.json) {
+                this.logger.log(JSON.stringify({ plugins, directory: pluginsDir }, null, 2));
+                return;
+            }
+            this.logger.info('\nInstalled Plugins\n');
+            this.logger.info(`Directory: ${pluginsDir}`);
+            this.logger.log('');
+            if (options?.verbose) {
+                for (const plugin of plugins) {
+                    this.logger.info('─'.repeat(60));
+                    this.logger.info(`${plugin.name} @ ${plugin.version}`);
+                    this.logger.info(`  Type:      ${plugin.type}`);
+                    this.logger.info(`  Size:      ${formatFileSize(plugin.size)}`);
+                    this.logger.info(`  Signed:    ${plugin.signed ? 'Yes' : 'No'}`);
+                    this.logger.info(`  MLDSA:     ${plugin.mldsaLevel}`);
+                    this.logger.info(`  Author:    ${plugin.author}`);
+                    if (plugin.description) {
+                        this.logger.info(`  Desc:      ${plugin.description}`);
+                    }
+                    this.logger.info(`  File:      ${plugin.file}`);
+                }
+            }
+            else {
+                const nameWidth = Math.max(20, ...plugins.map((p) => p.name.length)) + 2;
+                const versionWidth = 12;
+                const typeWidth = 12;
+                const sizeWidth = 10;
+                this.logger.info('Name'.padEnd(nameWidth) + 'Version'.padEnd(versionWidth) + 'Type'.padEnd(typeWidth) + 'Size'.padEnd(sizeWidth) + 'Signed');
+                this.logger.info('─'.repeat(nameWidth + versionWidth + typeWidth + sizeWidth + 8));
+                for (const plugin of plugins) {
+                    const signedText = plugin.signed ? 'Yes' : 'No';
+                    this.logger.info(`${plugin.name.padEnd(nameWidth)}${plugin.version.padEnd(versionWidth)}${plugin.type.padEnd(typeWidth)}${formatFileSize(plugin.size).padEnd(sizeWidth)}${signedText}`);
+                }
+            }
+            this.logger.log('');
+            this.logger.info(`Total: ${plugins.length} plugin${plugins.length === 1 ? '' : 's'}`);
+            this.logger.log('');
+        }
+        catch (error) {
+            this.exitWithError(this.formatError(error));
+        }
+    }
+}
+export const listCommand = new ListCommand().getCommand();

package/build/commands/LoginCommand.d.ts

@@ -0,0 +1,9 @@
+import { BaseCommand } from './BaseCommand.js';
+export declare class LoginCommand extends BaseCommand {
+    constructor();
+    protected configure(): void;
+    private execute;
+    private buildCredentials;
+    private interactiveLogin;
+}
+export declare const loginCommand: import("commander").Command;

package/build/commands/LoginCommand.js

@@ -0,0 +1,139 @@
+import { select, confirm, password } from '@inquirer/prompts';
+import { BaseCommand } from './BaseCommand.js';
+import { saveCredentials, isValidMldsaLevel, isValidNetwork } from '../lib/credentials.js';
+import { validateMnemonic, CLIWallet } from '../lib/wallet.js';
+export class LoginCommand extends BaseCommand {
+    constructor() {
+        super('login', 'Configure wallet credentials for signing and publishing');
+    }
+    configure() {
+        this.command
+            .option('-m, --mnemonic <phrase>', 'BIP-39 mnemonic phrase (12 or 24 words)')
+            .option('--wif <key>', 'Bitcoin WIF private key (advanced)')
+            .option('--mldsa <key>', 'MLDSA private key hex (advanced, requires --wif)')
+            .option('-l, --mldsa-level <level>', 'MLDSA security level (44, 65, 87)', '44')
+            .option('-n, --network <network>', 'Network (mainnet, testnet, regtest)', 'mainnet')
+            .action((options) => this.execute(options));
+    }
+    async execute(options) {
+        try {
+            const credentials = await this.buildCredentials(options);
+            this.logger.info('Deriving wallet...');
+            const wallet = CLIWallet.fromCredentials(credentials);
+            this.logger.log('');
+            this.logger.info('Wallet Identity');
+            this.logger.log('─'.repeat(50));
+            this.logger.log(`Network:           ${credentials.network}`);
+            this.logger.log(`MLDSA Level:       MLDSA-${credentials.mldsaLevel}`);
+            this.logger.log(`P2TR Address:      ${wallet.p2trAddress}`);
+            this.logger.log(`MLDSA PubKey Hash: ${wallet.mldsaPublicKeyHash.substring(0, 32)}...`);
+            this.logger.log('─'.repeat(50));
+            this.logger.log('');
+            this.logger.warn('Credentials will be stored at ~/.opnet/credentials.json');
+            this.logger.warn('with restricted permissions (owner read/write only).');
+            this.logger.log('');
+            const confirmed = await confirm({
+                message: 'Is this the correct wallet? Save credentials?',
+                default: true,
+            });
+            if (!confirmed) {
+                this.logger.warn('Login cancelled.');
+                return;
+            }
+            saveCredentials(credentials);
+            this.logger.log('');
+            this.logger.success('Credentials saved successfully!');
+        }
+        catch (error) {
+            if (this.isUserCancelled(error)) {
+                this.logger.warn('Login cancelled.');
+                process.exit(0);
+            }
+            this.exitWithError(this.formatError(error));
+        }
+    }
+    async buildCredentials(options) {
+        if (!isValidNetwork(options.network)) {
+            this.exitWithError(`Invalid network: ${options.network}. Valid: mainnet, testnet, regtest`);
+            throw new Error('Unreachable');
+        }
+        const mldsaLevelNum = parseInt(options.mldsaLevel, 10);
+        if (!isValidMldsaLevel(mldsaLevelNum)) {
+            this.exitWithError(`Invalid MLDSA level: ${options.mldsaLevel}. Valid: 44, 65, 87`);
+        }
+        const mldsaLevel = mldsaLevelNum;
+        if (options.mnemonic) {
+            if (!validateMnemonic(options.mnemonic)) {
+                this.exitWithError('Invalid mnemonic phrase');
+            }
+            return { mnemonic: options.mnemonic, mldsaLevel, network: options.network };
+        }
+        if (options.wif && options.mldsa) {
+            return {
+                wif: options.wif,
+                mldsaPrivateKey: options.mldsa,
+                mldsaLevel,
+                network: options.network,
+            };
+        }
+        return this.interactiveLogin(options.network, mldsaLevel);
+    }
+    async interactiveLogin(defaultNetwork, defaultLevel) {
+        this.logger.info('OPNet Wallet Configuration\n');
+        const loginMethod = await select({
+            message: 'How would you like to authenticate?',
+            choices: [
+                {
+                    name: 'Mnemonic phrase (recommended)',
+                    value: 'mnemonic',
+                    description: '12 or 24-word BIP-39 phrase for full key derivation',
+                },
+                {
+                    name: 'WIF + MLDSA keys (advanced)',
+                    value: 'advanced',
+                    description: 'Separate Bitcoin WIF and MLDSA private keys',
+                },
+            ],
+        });
+        const selectedNetwork = await select({
+            message: 'Select network:',
+            choices: [
+                { name: 'Mainnet', value: 'mainnet' },
+                { name: 'Testnet', value: 'testnet' },
+                { name: 'Regtest', value: 'regtest' },
+            ],
+            default: defaultNetwork,
+        });
+        const selectedLevel = await select({
+            message: 'Select MLDSA security level:',
+            choices: [
+                { name: 'MLDSA-44 (Level 2, fastest)', value: 44, description: '1312 byte public key' },
+                { name: 'MLDSA-65 (Level 3, balanced)', value: 65, description: '1952 byte public key' },
+                { name: 'MLDSA-87 (Level 5, most secure)', value: 87, description: '2592 byte public key' },
+            ],
+            default: defaultLevel,
+        });
+        if (loginMethod === 'mnemonic') {
+            const mnemonic = await password({
+                message: 'Enter your mnemonic phrase (12 or 24 words):',
+                mask: '*',
+                validate: (value) => {
+                    if (!validateMnemonic(value)) {
+                        return 'Invalid mnemonic phrase. Please enter a valid 12 or 24-word BIP-39 phrase.';
+                    }
+                    return true;
+                },
+            });
+            return { mnemonic, mldsaLevel: selectedLevel, network: selectedNetwork };
+        }
+        const wif = await password({ message: 'Enter Bitcoin WIF private key:', mask: '*' });
+        const mldsaKey = await password({ message: 'Enter MLDSA private key (hex):', mask: '*' });
+        return {
+            wif,
+            mldsaPrivateKey: mldsaKey,
+            mldsaLevel: selectedLevel,
+            network: selectedNetwork,
+        };
+    }
+}
+export const loginCommand = new LoginCommand().getCommand();

package/build/commands/LogoutCommand.d.ts

@@ -0,0 +1,7 @@
+import { BaseCommand } from './BaseCommand.js';
+export declare class LogoutCommand extends BaseCommand {
+    constructor();
+    protected configure(): void;
+    private execute;
+}
+export declare const logoutCommand: import("commander").Command;

package/build/commands/LogoutCommand.js

@@ -0,0 +1,57 @@
+import { confirm } from '@inquirer/prompts';
+import { BaseCommand } from './BaseCommand.js';
+import { deleteCredentials, hasCredentials, getCredentialSource } from '../lib/credentials.js';
+export class LogoutCommand extends BaseCommand {
+    constructor() {
+        super('logout', 'Remove stored wallet credentials');
+    }
+    configure() {
+        this.command
+            .option('-y, --yes', 'Skip confirmation prompt')
+            .action((options) => this.execute(options));
+    }
+    async execute(options) {
+        try {
+            if (!hasCredentials()) {
+                this.logger.warn('No credentials found.');
+                return;
+            }
+            const source = getCredentialSource();
+            if (source.startsWith('environment')) {
+                this.logger.warn(`Credentials are set via ${source}.`);
+                this.logger.info('To remove them, unset the environment variables:');
+                this.logger.info('  unset OPNET_MNEMONIC');
+                this.logger.info('  unset OPNET_PRIVATE_KEY');
+                this.logger.info('  unset OPNET_MLDSA_KEY');
+                return;
+            }
+            if (!options.yes) {
+                this.logger.warn('This will remove your stored credentials from:');
+                this.logger.info(`  ${source}`);
+                const confirmed = await confirm({
+                    message: 'Are you sure you want to logout?',
+                    default: false,
+                });
+                if (!confirmed) {
+                    this.logger.warn('Logout cancelled.');
+                    return;
+                }
+            }
+            const deleted = deleteCredentials();
+            if (deleted) {
+                this.logger.success('Credentials removed successfully.');
+            }
+            else {
+                this.logger.warn('No credentials file found to remove.');
+            }
+        }
+        catch (error) {
+            if (this.isUserCancelled(error)) {
+                this.logger.warn('Logout cancelled.');
+                process.exit(0);
+            }
+            this.exitWithError(this.formatError(error));
+        }
+    }
+}
+export const logoutCommand = new LogoutCommand().getCommand();

package/build/commands/PublishCommand.d.ts

@@ -0,0 +1,7 @@
+import { BaseCommand } from './BaseCommand.js';
+export declare class PublishCommand extends BaseCommand {
+    constructor();
+    protected configure(): void;
+    private execute;
+}
+export declare const publishCommand: import("commander").Command;

package/build/commands/PublishCommand.js

@@ -0,0 +1,163 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import { confirm } from '@inquirer/prompts';
+import { BaseCommand } from './BaseCommand.js';
+import { parseOpnetBinary, formatFileSize, verifyChecksum } from '../lib/binary.js';
+import { CLIWallet } from '../lib/wallet.js';
+import { loadCredentials, canSign } from '../lib/credentials.js';
+import { uploadPlugin } from '../lib/ipfs.js';
+import { getPackage, getScope, parsePackageName, computePermissionsHash, encodeDependencies, pluginTypeToRegistry, mldsaLevelToRegistry, } from '../lib/registry.js';
+export class PublishCommand extends BaseCommand {
+    constructor() {
+        super('publish', 'Publish a plugin to the OPNet registry');
+    }
+    configure() {
+        this.command
+            .argument('[file]', 'Path to .opnet file (default: ./build/<name>.opnet)')
+            .option('-n, --network <network>', 'Network to publish to', 'mainnet')
+            .option('--dry-run', 'Show what would be published without publishing')
+            .option('-y, --yes', 'Skip confirmation prompts')
+            .action((file, options) => this.execute(file, options || { network: 'mainnet' }));
+    }
+    async execute(file, options) {
+        try {
+            let binaryPath = file;
+            if (!binaryPath) {
+                const manifestPath = path.join(process.cwd(), 'plugin.json');
+                if (fs.existsSync(manifestPath)) {
+                    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+                    const name = manifest.name.replace(/^@/, '').replace(/\//g, '-');
+                    binaryPath = path.join(process.cwd(), 'build', `${name}.opnet`);
+                }
+            }
+            if (!binaryPath || !fs.existsSync(binaryPath)) {
+                this.logger.fail('No .opnet file found.');
+                this.logger.info('Run `opnet compile` first or specify the file path.');
+                process.exit(1);
+            }
+            this.logger.info('Parsing plugin binary...');
+            const data = fs.readFileSync(binaryPath);
+            const parsed = parseOpnetBinary(data);
+            if (!verifyChecksum(parsed)) {
+                this.logger.fail('Checksum verification failed');
+                this.logger.error('The binary appears to be corrupted.');
+                process.exit(1);
+            }
+            const isUnsigned = parsed.publicKey.every((b) => b === 0);
+            if (isUnsigned) {
+                this.logger.fail('Binary is unsigned');
+                this.logger.error('Cannot publish unsigned binaries.');
+                this.logger.info('Run `opnet sign` to sign the binary.');
+                process.exit(1);
+            }
+            const meta = parsed.metadata;
+            const mldsaLevel = [44, 65, 87][parsed.mldsaLevel];
+            this.logger.success(`Parsed: ${meta.name}@${meta.version}`);
+            this.logger.info('Loading wallet...');
+            const credentials = loadCredentials();
+            if (!credentials || !canSign(credentials)) {
+                this.logger.fail('No credentials configured');
+                this.logger.warn('Run `opnet login` to configure your wallet.');
+                process.exit(1);
+            }
+            const wallet = CLIWallet.fromCredentials(credentials);
+            const walletPkHash = wallet.mldsaPublicKeyHash;
+            const binaryPkHash = crypto.createHash('sha256').update(parsed.publicKey).digest('hex');
+            if (walletPkHash !== binaryPkHash) {
+                this.logger.fail('Wallet mismatch');
+                this.logger.error('The binary was signed with a different key.');
+                this.logger.log(`Binary signer: ${binaryPkHash.substring(0, 32)}...`);
+                this.logger.log(`Your key:      ${walletPkHash.substring(0, 32)}...`);
+                process.exit(1);
+            }
+            this.logger.success('Wallet verified');
+            this.logger.info('Checking registry status...');
+            const { scope, name } = parsePackageName(meta.name);
+            const network = (options?.network || 'mainnet');
+            if (scope) {
+                const scopeInfo = await getScope(scope, network);
+                if (!scopeInfo) {
+                    this.logger.fail(`Scope @${scope} is not registered`);
+                    this.logger.warn(`Register the scope first with: opnet scope register ${scope}`);
+                    process.exit(1);
+                }
+            }
+            const packageInfo = await getPackage(meta.name, network);
+            const isNewPackage = !packageInfo;
+            this.logger.success(isNewPackage
+                ? 'New package registration'
+                : `Existing package (${packageInfo.versionCount} versions)`);
+            this.logger.log('');
+            this.logger.info('Publishing Summary');
+            this.logger.log('─'.repeat(50));
+            this.logger.log(`Package:      ${meta.name}`);
+            this.logger.log(`Version:      ${meta.version}`);
+            this.logger.log(`Type:         ${meta.pluginType}`);
+            this.logger.log(`OPNet:        ${meta.opnetVersion}`);
+            this.logger.log(`Size:         ${formatFileSize(data.length)}`);
+            this.logger.log(`MLDSA Level:  ${mldsaLevel}`);
+            this.logger.log(`Network:      ${options?.network}`);
+            this.logger.log(`Status:       ${isNewPackage ? 'New package' : 'New version'}`);
+            this.logger.log('');
+            if (options?.dryRun) {
+                this.logger.warn('Dry run - no changes made.');
+                return;
+            }
+            if (!options?.yes) {
+                const confirmed = await confirm({
+                    message: 'Publish this plugin?',
+                    default: true,
+                });
+                if (!confirmed) {
+                    this.logger.warn('Publishing cancelled.');
+                    return;
+                }
+            }
+            this.logger.info('Uploading to IPFS...');
+            const pinResult = await uploadPlugin(binaryPath);
+            this.logger.success(`Uploaded to IPFS: ${pinResult.cid}`);
+            const permissionsHash = computePermissionsHash(meta.permissions);
+            const dependencies = encodeDependencies(meta.dependencies || {});
+            if (isNewPackage) {
+                this.logger.info('Registering package...');
+                this.logger.warn('Package registration required.');
+                this.logger.log(`Transaction would call: registerPackage("${meta.name}")`);
+                this.logger.info('Package registration (transaction pending)');
+            }
+            this.logger.info('Publishing version...');
+            this.logger.warn('Version publishing required.');
+            this.logger.log('Transaction would call: publishVersion(');
+            this.logger.log(`  packageName: "${meta.name}",`);
+            this.logger.log(`  version: "${meta.version}",`);
+            this.logger.log(`  ipfsCid: "${pinResult.cid}",`);
+            this.logger.log(`  checksum: <32 bytes>,`);
+            this.logger.log(`  signature: <${parsed.signature.length} bytes>,`);
+            this.logger.log(`  mldsaLevel: ${mldsaLevelToRegistry(mldsaLevel)},`);
+            this.logger.log(`  opnetVersionRange: "${meta.opnetVersion}",`);
+            this.logger.log(`  pluginType: ${pluginTypeToRegistry(meta.pluginType)},`);
+            this.logger.log(`  permissionsHash: <32 bytes>,`);
+            this.logger.log(`  dependencies: <${dependencies.length} bytes>`);
+            this.logger.log(')');
+            this.logger.info('Version publishing (transaction pending)');
+            this.logger.log('');
+            this.logger.success('Plugin uploaded successfully!');
+            this.logger.log('');
+            this.logger.log(`IPFS CID:  ${pinResult.cid}`);
+            this.logger.log(`Gateway:   https://ipfs.opnet.org/ipfs/${pinResult.cid}`);
+            this.logger.log('');
+            this.logger.warn('Note: Registry transaction support is coming soon.');
+            this.logger.warn('The binary has been uploaded to IPFS and is ready for registry submission.');
+            this.logger.log('');
+        }
+        catch (error) {
+            this.logger.fail('Publishing failed');
+            if (this.isUserCancelled(error)) {
+                this.logger.warn('Publishing cancelled.');
+                process.exit(0);
+            }
+            this.exitWithError(this.formatError(error));
+        }
+    }
+}
+export const publishCommand = new PublishCommand().getCommand();

package/build/commands/SearchCommand.d.ts

@@ -0,0 +1,7 @@
+import { BaseCommand } from './BaseCommand.js';
+export declare class SearchCommand extends BaseCommand {
+    constructor();
+    protected configure(): void;
+    private execute;
+}
+export declare const searchCommand: import("commander").Command;

package/build/commands/SearchCommand.js

@@ -0,0 +1,97 @@
+import { BaseCommand } from './BaseCommand.js';
+import { getPackage, getVersion, registryToMldsaLevel, registryToPluginType } from '../lib/registry.js';
+export class SearchCommand extends BaseCommand {
+    constructor() {
+        super('search', 'Search for plugins in the registry');
+    }
+    configure() {
+        this.command
+            .argument('<query>', 'Package name or search query')
+            .option('-n, --network <network>', 'Network', 'mainnet')
+            .option('--json', 'Output as JSON')
+            .action((query, options) => this.execute(query, options || { network: 'mainnet' }));
+    }
+    async execute(query, options) {
+        try {
+            const network = (options?.network || 'mainnet');
+            this.logger.info(`Searching for "${query}"...`);
+            const packageInfo = await getPackage(query, network);
+            if (!packageInfo) {
+                this.logger.fail('No results');
+                if (options?.json) {
+                    this.logger.log(JSON.stringify({ results: [], query }));
+                }
+                else {
+                    this.logger.log('');
+                    this.logger.warn(`No package found matching "${query}".`);
+                    this.logger.log('');
+                    this.logger.info('Tips:');
+                    this.logger.info('  - For scoped packages, use @scope/name');
+                    this.logger.info('  - Package names are case-sensitive');
+                    this.logger.info('  - Try searching without the version');
+                }
+                return;
+            }
+            let latestVersionInfo = null;
+            if (packageInfo.latestVersion) {
+                latestVersionInfo = await getVersion(query, packageInfo.latestVersion, network);
+            }
+            this.logger.success('Package found');
+            if (options?.json) {
+                const output = {
+                    results: [
+                        {
+                            name: query,
+                            latestVersion: packageInfo.latestVersion,
+                            versionCount: Number(packageInfo.versionCount),
+                            createdAt: Number(packageInfo.createdAt),
+                            owner: packageInfo.owner.toString(),
+                            details: latestVersionInfo
+                                ? {
+                                    ipfsCid: latestVersionInfo.ipfsCid,
+                                    mldsaLevel: registryToMldsaLevel(latestVersionInfo.mldsaLevel),
+                                    pluginType: registryToPluginType(latestVersionInfo.pluginType),
+                                    opnetVersion: latestVersionInfo.opnetVersionRange,
+                                    deprecated: latestVersionInfo.deprecated,
+                                    publishedAt: Number(latestVersionInfo.publishedAt),
+                                }
+                                : null,
+                        },
+                    ],
+                    query,
+                };
+                this.logger.log(JSON.stringify(output, null, 2));
+                return;
+            }
+            this.logger.log('');
+            this.logger.info('Package Information');
+            this.logger.info('─'.repeat(60));
+            this.logger.log('');
+            this.logger.info(`Name:         ${query}`);
+            this.logger.info(`Latest:       ${packageInfo.latestVersion || 'N/A'}`);
+            this.logger.info(`Versions:     ${packageInfo.versionCount}`);
+            this.logger.info(`Owner:        ${packageInfo.owner}`);
+            if (latestVersionInfo) {
+                this.logger.log('');
+                this.logger.info('Latest Version Details:');
+                this.logger.info(`  Type:          ${registryToPluginType(latestVersionInfo.pluginType)}`);
+                this.logger.info(`  MLDSA Level:   ${registryToMldsaLevel(latestVersionInfo.mldsaLevel)}`);
+                this.logger.info(`  OPNet Range:   ${latestVersionInfo.opnetVersionRange}`);
+                this.logger.info(`  IPFS CID:      ${latestVersionInfo.ipfsCid}`);
+                this.logger.info(`  Deprecated:    ${latestVersionInfo.deprecated ? 'Yes' : 'No'}`);
+                const publishDate = new Date(Number(latestVersionInfo.publishedAt) * 1000);
+                this.logger.info(`  Published:     ${publishDate.toISOString().split('T')[0]}`);
+            }
+            this.logger.log('');
+            this.logger.info('Install with:');
+            this.logger.info(`  opnet install ${query}`);
+            this.logger.info(`  opnet install ${query}@${packageInfo.latestVersion}`);
+            this.logger.log('');
+        }
+        catch (error) {
+            this.logger.fail('Search failed');
+            this.exitWithError(this.formatError(error));
+        }
+    }
+}
+export const searchCommand = new SearchCommand().getCommand();

package/build/commands/SignCommand.d.ts

@@ -0,0 +1,7 @@
+import { BaseCommand } from './BaseCommand.js';
+export declare class SignCommand extends BaseCommand {
+    constructor();
+    protected configure(): void;
+    private execute;
+}
+export declare const signCommand: import("commander").Command;