@btc-vision/cli 1.0.5 → 1.0.7

package/src/commands/InstallCommand.ts

@@ -1,179 +0,0 @@
-/**
- * Install command - Download and verify plugins from registry
- *
- * @module commands/InstallCommand
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import { BaseCommand } from './BaseCommand.js';
-import { getPackage, getVersion, registryToMldsaLevel } from '../lib/registry.js';
-import { fetchFromIPFS, isValidCid } from '../lib/ipfs.js';
-import { formatFileSize, parseOpnetBinary, verifyChecksum } from '../lib/binary.js';
-import { CLIWallet } from '../lib/wallet.js';
-import { NetworkName } from '../types/index.js';
-
-interface InstallOptions {
-    output?: string;
-    network: string;
-    skipVerify?: boolean;
-}
-
-export class InstallCommand extends BaseCommand {
-    constructor() {
-        super('install', 'Download and verify a plugin from the registry');
-    }
-
-    protected configure(): void {
-        this.command
-            .argument('<package>', 'Package name[@version] or IPFS CID')
-            .option('-o, --output <path>', 'Output directory (default: ./plugins/)')
-            .option('-n, --network <network>', 'Network', 'mainnet')
-            .option('--skip-verify', 'Skip signature verification')
-            .action((packageInput: string, options?: InstallOptions) =>
-                this.execute(packageInput, options || { network: 'mainnet' }),
-            );
-    }
-
-    private async execute(packageInput: string, options?: InstallOptions): Promise<void> {
-        try {
-            let cid: string;
-            let packageName: string;
-            let version: string;
-
-            // Check if input is a CID
-            if (isValidCid(packageInput)) {
-                cid = packageInput;
-                packageName = 'unknown';
-                version = 'unknown';
-                this.logger.info(`Installing from CID: ${cid}`);
-            } else {
-                // Parse package name and version
-                const atIndex = packageInput.lastIndexOf('@');
-                if (atIndex > 0 && !packageInput.startsWith('@')) {
-                    packageName = packageInput.substring(0, atIndex);
-                    version = packageInput.substring(atIndex + 1);
-                } else if (packageInput.startsWith('@') && packageInput.indexOf('@', 1) > 0) {
-                    const secondAt = packageInput.indexOf('@', 1);
-                    packageName = packageInput.substring(0, secondAt);
-                    version = packageInput.substring(secondAt + 1);
-                } else {
-                    packageName = packageInput;
-                    version = 'latest';
-                }
-
-                // Fetch from registry
-                this.logger.info(`Fetching ${packageName}...`);
-                const network = (options?.network || 'mainnet') as NetworkName;
-
-                const packageInfo = await getPackage(packageName, network);
-                if (!packageInfo) {
-                    this.logger.fail('Package not found');
-                    this.logger.error(`Package "${packageName}" does not exist.`);
-                    process.exit(1);
-                }
-
-                // Resolve version
-                if (version === 'latest') {
-                    version = packageInfo.latestVersion;
-                }
-
-                const versionInfo = await getVersion(packageName, version, network);
-                if (!versionInfo) {
-                    this.logger.fail('Version not found');
-                    this.logger.error(`Version "${version}" does not exist.`);
-                    process.exit(1);
-                }
-
-                if (versionInfo.deprecated) {
-                    this.logger.warn(`Version ${version} is deprecated`);
-                }
-
-                cid = versionInfo.ipfsCid;
-                this.logger.success(`Found: ${packageName}@${version}`);
-
-                // Display info
-                this.logger.log('');
-                this.logger.log(`IPFS CID:    ${cid}`);
-                this.logger.log(`MLDSA Level: ${registryToMldsaLevel(versionInfo.mldsaLevel)}`);
-                this.logger.log(`Publisher:   ${versionInfo.publisher}`);
-                this.logger.log('');
-            }
-
-            // Download from IPFS
-            this.logger.info('Downloading from IPFS...');
-            const result = await fetchFromIPFS(cid);
-            this.logger.success(`Downloaded (${formatFileSize(result.size)})`);
-
-            // Parse and verify
-            this.logger.info('Verifying binary...');
-            const parsed = parseOpnetBinary(result.data);
-
-            // Verify checksum
-            if (!verifyChecksum(parsed)) {
-                this.logger.fail('Checksum verification failed');
-                this.logger.error('The binary appears to be corrupted.');
-                process.exit(1);
-            }
-
-            // Verify signature
-            if (!options?.skipVerify) {
-                const isUnsigned = parsed.publicKey.every((b) => b === 0);
-                if (isUnsigned) {
-                    this.logger.warn('Binary is unsigned');
-                } else {
-                    const actualMldsaLevel = ([44, 65, 87] as const)[parsed.mldsaLevel];
-                    const signatureValid = CLIWallet.verifyMLDSA(
-                        parsed.checksum,
-                        parsed.signature,
-                        parsed.publicKey,
-                        actualMldsaLevel,
-                    );
-
-                    if (!signatureValid) {
-                        this.logger.fail('Signature verification failed');
-                        this.logger.error('The binary signature is invalid.');
-                        process.exit(1);
-                    }
-                    this.logger.success('Signature verified');
-                }
-            } else {
-                this.logger.warn('Skipping signature verification');
-            }
-
-            // Update package name from metadata
-            if (packageName === 'unknown') {
-                packageName = parsed.metadata.name;
-                version = parsed.metadata.version;
-            }
-
-            // Determine output path
-            const outputDir = options?.output || path.join(process.cwd(), 'plugins');
-            fs.mkdirSync(outputDir, { recursive: true });
-
-            const fileName = `${packageName.replace(/^@/, '').replace(/\//g, '-')}-${version}.opnet`;
-            const outputPath = path.join(outputDir, fileName);
-
-            // Save file
-            this.logger.info('Saving plugin...');
-            fs.writeFileSync(outputPath, result.data);
-            this.logger.success('Plugin installed');
-
-            // Summary
-            this.logger.log('');
-            this.logger.success('Plugin installed successfully!');
-            this.logger.log('');
-            this.logger.log(`Package:  ${parsed.metadata.name}`);
-            this.logger.log(`Version:  ${parsed.metadata.version}`);
-            this.logger.log(`Type:     ${parsed.metadata.pluginType}`);
-            this.logger.log(`Size:     ${formatFileSize(result.size)}`);
-            this.logger.log(`Output:   ${outputPath}`);
-            this.logger.log('');
-        } catch (error) {
-            this.logger.fail('Installation failed');
-            this.exitWithError(this.formatError(error));
-        }
-    }
-}
-
-export const installCommand = new InstallCommand().getCommand();

package/src/commands/KeygenCommand.ts

@@ -1,157 +0,0 @@
-/**
- * Keygen command - Generate MLDSA keypairs and mnemonics
- *
- * @module commands/KeygenCommand
- */
-
-import { Command } from 'commander';
-import * as fs from 'fs';
-import { BaseCommand } from './BaseCommand.js';
-import { computePublicKeyHash, generateMLDSAKeypair, generateMnemonic } from '../lib/wallet.js';
-import { isValidMldsaLevel } from '../lib/credentials.js';
-
-export class KeygenCommand extends BaseCommand {
-    constructor() {
-        super('keygen', 'Generate cryptographic keys');
-    }
-
-    protected configure(): void {
-        this.command
-            .addCommand(this.createMnemonicCommand())
-            .addCommand(this.createMldsaCommand())
-            .addCommand(this.createInfoCommand());
-    }
-
-    private createMnemonicCommand(): Command {
-        return new Command('mnemonic')
-            .description('Generate a new BIP-39 mnemonic phrase')
-            .option('-o, --output <file>', 'Write mnemonic to file (secure permissions)')
-            .action((options: { output?: string }) => this.handleMnemonic(options));
-    }
-
-    private createMldsaCommand(): Command {
-        return new Command('mldsa')
-            .description('Generate a standalone MLDSA keypair')
-            .option('-l, --level <level>', 'MLDSA security level (44, 65, 87)', '44')
-            .option('-o, --output <prefix>', 'Write keys to files with prefix')
-            .option('--json', 'Output as JSON')
-            .action((options: { level: string; output?: string; json?: boolean }) => {
-                this.handleMldsa(options);
-            });
-    }
-
-    private createInfoCommand(): Command {
-        return new Command('info')
-            .description('Show information about MLDSA key sizes')
-            .action(() => this.handleInfo());
-    }
-
-    private handleMnemonic(options: { output?: string }): void {
-        try {
-            const mnemonic = generateMnemonic();
-
-            if (options.output) {
-                fs.writeFileSync(options.output, mnemonic + '\n', { mode: 0o600 });
-                this.logger.success(`Mnemonic saved to: ${options.output}`);
-                this.logger.warn('Keep this file secure and backed up!');
-            } else {
-                this.logger.info('\nNew BIP-39 Mnemonic Phrase:\n');
-                this.logger.log(mnemonic);
-                this.logger.log('');
-                this.logger.warn('IMPORTANT: Write down these words and store them securely.');
-                this.logger.warn('Anyone with this phrase can access your wallet.');
-                this.logger.warn('Never share this phrase with anyone.');
-            }
-        } catch (error) {
-            this.exitWithError(this.formatError(error));
-        }
-    }
-
-    private handleMldsa(options: { level: string; output?: string; json?: boolean }): void {
-        try {
-            const levelNum = parseInt(options.level, 10);
-            if (!isValidMldsaLevel(levelNum)) {
-                this.exitWithError(`Invalid MLDSA level: ${options.level}. Valid: 44, 65, 87`);
-                return; // Unreachable, but helps TypeScript
-            }
-
-            this.logger.info(`Generating MLDSA-${levelNum} keypair...`);
-
-            const keypair = generateMLDSAKeypair(levelNum);
-            const publicKeyHash = computePublicKeyHash(keypair.publicKey);
-
-            if (options.output) {
-                const privateKeyPath = `${options.output}.private.key`;
-                const publicKeyPath = `${options.output}.public.key`;
-
-                fs.writeFileSync(privateKeyPath, keypair.privateKey.toString('hex') + '\n', {
-                    mode: 0o600,
-                });
-                fs.writeFileSync(publicKeyPath, keypair.publicKey.toString('hex') + '\n', {
-                    mode: 0o644,
-                });
-
-                this.logger.success('Keys generated successfully!');
-                this.logger.info(`  Private key: ${privateKeyPath}`);
-                this.logger.info(`  Public key:  ${publicKeyPath}`);
-                this.logger.log('');
-                this.logger.log(`Public Key Hash: ${publicKeyHash}`);
-                this.logger.log('');
-                this.logger.warn('IMPORTANT: Keep the private key secure!');
-            } else if (options.json) {
-                const output = {
-                    level: levelNum,
-                    privateKey: keypair.privateKey.toString('hex'),
-                    publicKey: keypair.publicKey.toString('hex'),
-                    publicKeyHash,
-                    privateKeySize: keypair.privateKey.length,
-                    publicKeySize: keypair.publicKey.length,
-                };
-                this.logger.log(JSON.stringify(output, null, 2));
-            } else {
-                this.logger.info(`\nMLDSA-${levelNum} Keypair:\n`);
-                this.logger.log(`Public Key Hash: ${publicKeyHash}`);
-                this.logger.log(`Public Key Size: ${keypair.publicKey.length} bytes`);
-                this.logger.log(`Private Key Size: ${keypair.privateKey.length} bytes`);
-                this.logger.log('');
-                this.logger.log('Public Key (hex):');
-                this.logger.log(keypair.publicKey.toString('hex'));
-                this.logger.log('');
-                this.logger.log('Private Key (hex):');
-                this.logger.log(keypair.privateKey.toString('hex'));
-                this.logger.log('');
-                this.logger.warn('IMPORTANT: Store the private key securely!');
-                this.logger.warn('Use --output <prefix> to save to files.');
-            }
-        } catch (error) {
-            this.exitWithError(this.formatError(error));
-        }
-    }
-
-    private handleInfo(): void {
-        this.logger.info('\nMLDSA Key Sizes:\n');
-        this.logger.log('─'.repeat(60));
-        this.logger.log(
-            `${'Level'.padEnd(12)}${'Public Key'.padEnd(15)}${'Private Key'.padEnd(15)}${'Signature'.padEnd(15)}`,
-        );
-        this.logger.log('─'.repeat(60));
-        this.logger.log(
-            `${'MLDSA-44'.padEnd(12)}${'1,312 bytes'.padEnd(15)}${'2,560 bytes'.padEnd(15)}${'2,420 bytes'.padEnd(15)}`,
-        );
-        this.logger.log(
-            `${'MLDSA-65'.padEnd(12)}${'1,952 bytes'.padEnd(15)}${'4,032 bytes'.padEnd(15)}${'3,309 bytes'.padEnd(15)}`,
-        );
-        this.logger.log(
-            `${'MLDSA-87'.padEnd(12)}${'2,592 bytes'.padEnd(15)}${'4,896 bytes'.padEnd(15)}${'4,627 bytes'.padEnd(15)}`,
-        );
-        this.logger.log('─'.repeat(60));
-        this.logger.log('');
-        this.logger.log('Security levels:');
-        this.logger.log('  MLDSA-44: ~128-bit security (fastest, smallest)');
-        this.logger.log('  MLDSA-65: ~192-bit security (balanced)');
-        this.logger.log('  MLDSA-87: ~256-bit security (highest security)');
-        this.logger.log('');
-    }
-}
-
-export const keygenCommand = new KeygenCommand().getCommand();

package/src/commands/ListCommand.ts

@@ -1,169 +0,0 @@
-/**
- * List command - List installed plugins
- *
- * @module commands/ListCommand
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import { BaseCommand } from './BaseCommand.js';
-import { formatFileSize, parseOpnetBinary } from '../lib/binary.js';
-import { CLIMldsaLevel } from '../types/index.js';
-
-interface ListOptions {
-    dir?: string;
-    json?: boolean;
-    verbose?: boolean;
-}
-
-interface PluginInfo {
-    file: string;
-    name: string;
-    version: string;
-    type: string;
-    size: number;
-    signed: boolean;
-    mldsaLevel: CLIMldsaLevel;
-    author: string;
-    description?: string;
-}
-
-export class ListCommand extends BaseCommand {
-    constructor() {
-        super('list', 'List installed plugins');
-    }
-
-    protected configure(): void {
-        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?: ListOptions) => this.execute(options));
-    }
-
-    private execute(options?: ListOptions): void {
-        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;
-            }
-
-            // Find all .opnet files
-            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: PluginInfo[] = [];
-
-            // Parse each plugin
-            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] as const)[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: '-',
-                    });
-                }
-            }
-
-            // Sort by name
-            plugins.sort((a, b) => a.name.localeCompare(b.name));
-
-            if (options?.json) {
-                this.logger.log(JSON.stringify({ plugins, directory: pluginsDir }, null, 2));
-                return;
-            }
-
-            // Display
-            this.logger.info('\nInstalled Plugins\n');
-            this.logger.info(`Directory: ${pluginsDir}`);
-            this.logger.log('');
-
-            if (options?.verbose) {
-                // Detailed list
-                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 {
-                // Simple table
-                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();