@btc-vision/cli 1.0.5 → 1.0.7

package/src/commands/BaseCommand.ts

@@ -1,59 +0,0 @@
-/**
- * Base command class for OPNet CLI
- *
- * @module commands/BaseCommand
- */
-
-import { Command } from 'commander';
-import { Logger } from '@btc-vision/logger';
-
-/**
- * Abstract base class for all CLI commands
- */
-export abstract class BaseCommand {
-    protected readonly logger: Logger;
-    protected readonly command: Command;
-
-    constructor(name: string, description: string) {
-        this.logger = new Logger();
-        this.command = new Command(name).description(description);
-        this.configure();
-    }
-
-    /**
-     * Get the configured command instance
-     */
-    public getCommand(): Command {
-        return this.command;
-    }
-
-    /**
-     * Configure the command with options and action
-     */
-    protected abstract configure(): void;
-
-    /**
-     * Format an error message for display
-     */
-    protected formatError(error: unknown): string {
-        if (error instanceof Error) {
-            return error.message;
-        }
-        return String(error);
-    }
-
-    /**
-     * Exit with error
-     */
-    protected exitWithError(message: string, code: number = 1): never {
-        this.logger.error(message);
-        process.exit(code);
-    }
-
-    /**
-     * Check if user cancelled (for inquirer)
-     */
-    protected isUserCancelled(error: unknown): boolean {
-        return error instanceof Error && error.message.includes('User force closed');
-    }
-}

package/src/commands/CompileCommand.ts

@@ -1,195 +0,0 @@
-/**
- * Compile command - Build plugin to .opnet binary
- *
- * @module commands/CompileCommand
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import * as esbuild from 'esbuild';
-import bytenode from 'bytenode';
-import { BaseCommand } from './BaseCommand.js';
-import { getManifestPath, loadManifest } from '../lib/manifest.js';
-import { buildOpnetBinary, formatFileSize } from '../lib/binary.js';
-import { CLIWallet } from '../lib/wallet.js';
-import { canSign, loadCredentials } from '../lib/credentials.js';
-import { CLIMldsaLevel } from '../types/index.js';
-
-interface CompileOptions {
-    output?: string;
-    dir?: string;
-    sign: boolean;
-    minify: boolean;
-    sourcemap: boolean;
-}
-
-export class CompileCommand extends BaseCommand {
-    constructor() {
-        super('compile', 'Compile plugin to .opnet binary format');
-    }
-
-    protected configure(): void {
-        this.command
-            .option('-o, --output <path>', 'Output file path')
-            .option('-d, --dir <path>', 'Plugin directory (default: current)')
-            .option('--no-sign', 'Skip signing (produce unsigned binary)')
-            .option('--minify', 'Minify the bundled code', true)
-            .option('--sourcemap', 'Generate source maps', false)
-            .action((options: CompileOptions) => this.execute(options));
-    }
-
-    private async execute(options: CompileOptions): Promise<void> {
-        try {
-            const projectDir = options.dir ? path.resolve(options.dir) : process.cwd();
-            const manifestPath = getManifestPath(projectDir);
-
-            // Load and validate manifest
-            this.logger.info('Loading plugin manifest...');
-            const manifest = loadManifest(manifestPath);
-            this.logger.success(`Loaded manifest: ${manifest.name}@${manifest.version}`);
-
-            // Check for source files
-            const srcDir = path.join(projectDir, 'src');
-            const entryPoint = path.join(srcDir, 'index.ts');
-
-            if (!fs.existsSync(entryPoint)) {
-                this.exitWithError(`Entry point not found: ${entryPoint}`);
-            }
-
-            // Bundle with esbuild
-            this.logger.info('Bundling TypeScript...');
-            const bundleDir = path.join(projectDir, 'build', '.bundle');
-            fs.mkdirSync(bundleDir, { recursive: true });
-
-            const bundlePath = path.join(bundleDir, 'bundle.js');
-
-            await esbuild.build({
-                entryPoints: [entryPoint],
-                bundle: true,
-                platform: 'node',
-                target: 'es2022',
-                format: 'cjs', // bytenode requires CommonJS
-                outfile: bundlePath,
-                minify: options.minify,
-                sourcemap: options.sourcemap,
-                treeShaking: true,
-                external: [
-                    '@btc-vision/plugin-sdk',
-                    '@btc-vision/transaction',
-                    '@btc-vision/bitcoin',
-                    'opnet',
-                ],
-            });
-            this.logger.success('TypeScript bundled');
-
-            // Compile to V8 bytecode
-            this.logger.info('Compiling to V8 bytecode...');
-            const bytecodePath = path.join(bundleDir, 'bundle.jsc');
-
-            await bytenode.compileFile({
-                filename: bundlePath,
-                output: bytecodePath,
-                electron: false,
-            });
-
-            const bytecode = fs.readFileSync(bytecodePath);
-            this.logger.success(`V8 bytecode generated (${formatFileSize(bytecode.length)})`);
-
-            // Check for proto file
-            let proto = Buffer.alloc(0);
-            const protoPath = path.join(projectDir, 'plugin.proto');
-            if (fs.existsSync(protoPath)) {
-                proto = fs.readFileSync(protoPath);
-                this.logger.info(`Found proto file (${formatFileSize(proto.length)})`);
-            }
-
-            // Prepare signing
-            let publicKey: Buffer;
-            let mldsaLevel: CLIMldsaLevel;
-            let signFn: ((checksum: Buffer) => Buffer) | undefined;
-
-            if (options.sign) {
-                this.logger.info('Loading wallet for signing...');
-                const credentials = loadCredentials();
-
-                if (!credentials || !canSign(credentials)) {
-                    this.logger.fail('No credentials configured');
-                    this.logger.warn('To sign plugins, run: opnet login');
-                    this.logger.warn('Or use --no-sign to skip signing.');
-                    process.exit(1);
-                }
-
-                const wallet = CLIWallet.fromCredentials(credentials);
-                mldsaLevel = wallet.securityLevel;
-                publicKey = wallet.mldsaPublicKey;
-
-                this.logger.success(`Wallet loaded (MLDSA-${mldsaLevel})`);
-
-                // Create signing function that will be called with the final checksum
-                signFn = (checksum: Buffer) => wallet.signMLDSA(checksum);
-            } else {
-                this.logger.warn('Skipping signing (--no-sign)');
-                // Use dummy values for unsigned binary
-                mldsaLevel = 44;
-                publicKey = Buffer.alloc(1312); // MLDSA-44 public key size
-            }
-
-            // Build .opnet binary
-            this.logger.info('Assembling .opnet binary...');
-            const { binary, checksum } = buildOpnetBinary({
-                mldsaLevel,
-                publicKey,
-                metadata: manifest,
-                bytecode,
-                proto,
-                signFn,
-            });
-
-            if (options.sign) {
-                this.logger.success(
-                    `Plugin signed (checksum: sha256:${checksum.toString('hex').substring(0, 16)}...)`,
-                );
-            }
-            this.logger.success(`Binary assembled (${formatFileSize(binary.length)})`);
-
-            // Write output
-            const outputPath =
-                options.output ||
-                path.join(
-                    projectDir,
-                    'build',
-                    `${manifest.name.replace(/^@/, '').replace(/\//g, '-')}.opnet`,
-                );
-            const outputDir = path.dirname(outputPath);
-            fs.mkdirSync(outputDir, { recursive: true });
-            fs.writeFileSync(outputPath, binary);
-
-            // Clean up bundle directory
-            fs.rmSync(bundleDir, { recursive: true, force: true });
-
-            // Summary
-            this.logger.log('');
-            this.logger.success('Compilation successful!');
-            this.logger.log('');
-            this.logger.log(`Output:       ${outputPath}`);
-            this.logger.log(`Size:         ${formatFileSize(binary.length)}`);
-            this.logger.log(`Plugin:       ${manifest.name}@${manifest.version}`);
-            this.logger.log(`Type:         ${manifest.pluginType}`);
-            this.logger.log(`MLDSA Level:  ${mldsaLevel}`);
-            this.logger.log(`Checksum:     sha256:${checksum.toString('hex')}`);
-            this.logger.log(`Signed:       ${options.sign ? 'Yes' : 'No'}`);
-            this.logger.log('');
-
-            if (!options.sign) {
-                this.logger.warn('Note: This binary is unsigned and cannot be published.');
-                this.logger.warn('Use `opnet sign` to sign it, or compile with signing enabled.');
-                this.logger.log('');
-            }
-        } catch (error) {
-            this.logger.fail('Compilation failed');
-            this.exitWithError(this.formatError(error));
-        }
-    }
-}
-
-export const compileCommand = new CompileCommand().getCommand();

package/src/commands/ConfigCommand.ts

@@ -1,117 +0,0 @@
-/**
- * Config command - Manage CLI configuration
- *
- * @module commands/ConfigCommand
- */
-
-import { Command } from 'commander';
-import * as os from 'os';
-import * as path from 'path';
-import { BaseCommand } from './BaseCommand.js';
-import { DEFAULT_CONFIG, displayConfig, getConfigValue, saveConfig, setConfigValue, } from '../lib/config.js';
-
-export class ConfigCommand extends BaseCommand {
-    constructor() {
-        super('config', 'Manage CLI configuration');
-    }
-
-    protected configure(): void {
-        this.command
-            .addCommand(this.createGetCommand())
-            .addCommand(this.createSetCommand())
-            .addCommand(this.createListCommand())
-            .addCommand(this.createResetCommand())
-            .addCommand(this.createPathCommand());
-    }
-
-    private createGetCommand(): Command {
-        return new Command('get')
-            .description('Get a configuration value')
-            .argument('[key]', 'Configuration key (dot notation, e.g., rpcUrls.mainnet)')
-            .action((key?: string) => {
-                this.handleGet(key);
-            });
-    }
-
-    private createSetCommand(): Command {
-        return new Command('set')
-            .description('Set a configuration value')
-            .argument('<key>', 'Configuration key (dot notation)')
-            .argument('<value>', 'Value to set')
-            .action((key: string, value: string) => {
-                this.handleSet(key, value);
-            });
-    }
-
-    private createListCommand(): Command {
-        return new Command('list').description('List all configuration values').action(() => {
-            this.handleList();
-        });
-    }
-
-    private createResetCommand(): Command {
-        return new Command('reset')
-            .description('Reset configuration to defaults')
-            .option('-y, --yes', 'Skip confirmation')
-            .action((options: { yes?: boolean }) => {
-                this.handleReset(options.yes);
-            });
-    }
-
-    private createPathCommand(): Command {
-        return new Command('path').description('Show configuration file path').action(() => {
-            this.handlePath();
-        });
-    }
-
-    private handleGet(key?: string): void {
-        if (!key) {
-            this.logger.log(displayConfig());
-            return;
-        }
-
-        const value = getConfigValue(key);
-        if (value === undefined) {
-            this.exitWithError(`Configuration key not found: ${key}`);
-        }
-
-        if (typeof value === 'object') {
-            this.logger.log(JSON.stringify(value, null, 2));
-        } else {
-            this.logger.log(String(value));
-        }
-    }
-
-    private handleSet(key: string, value: string): void {
-        let parsedValue: unknown = value;
-        try {
-            parsedValue = JSON.parse(value);
-        } catch {
-            // Keep as string if not valid JSON
-        }
-
-        setConfigValue(key, parsedValue);
-        this.logger.success(`Set ${key} = ${JSON.stringify(parsedValue)}`);
-    }
-
-    private handleList(): void {
-        this.logger.log(displayConfig());
-    }
-
-    private handleReset(confirmed?: boolean): void {
-        if (!confirmed) {
-            this.logger.warn('This will reset all configuration to defaults.');
-            this.logger.info('Use --yes to confirm.');
-            return;
-        }
-
-        saveConfig(DEFAULT_CONFIG);
-        this.logger.success('Configuration reset to defaults.');
-    }
-
-    private handlePath(): void {
-        this.logger.log(path.join(os.homedir(), '.opnet', 'config.json'));
-    }
-}
-
-export const configCommand = new ConfigCommand().getCommand();

package/src/commands/DeprecateCommand.ts

@@ -1,193 +0,0 @@
-/**
- * Deprecate command - Mark a package version as deprecated
- *
- * @module commands/DeprecateCommand
- */
-
-import { confirm, input } from '@inquirer/prompts';
-import { BaseCommand } from './BaseCommand.js';
-import { getPackage, getRegistryContract, getVersion, isVersionImmutable } from '../lib/registry.js';
-import { canSign, loadCredentials } from '../lib/credentials.js';
-import { CLIWallet } from '../lib/wallet.js';
-import {
-    buildTransactionParams,
-    checkBalance,
-    formatSats,
-    getWalletAddress,
-} from '../lib/transaction.js';
-import { NetworkName } from '../types/index.js';
-
-interface DeprecateOptions {
-    message?: string;
-    network: string;
-    yes?: boolean;
-}
-
-export class DeprecateCommand extends BaseCommand {
-    constructor() {
-        super('deprecate', 'Mark a package version as deprecated');
-    }
-
-    protected configure(): void {
-        this.command
-            .argument('<package>', 'Package name (e.g., @scope/name or name)')
-            .argument('[version]', 'Version to deprecate (default: latest)')
-            .option('-m, --message <message>', 'Deprecation reason/message')
-            .option('-n, --network <network>', 'Network', 'mainnet')
-            .option('-y, --yes', 'Skip confirmation')
-            .action((packageName: string, version?: string, options?: DeprecateOptions) =>
-                this.execute(packageName, version, options || { network: 'mainnet' }),
-            );
-    }
-
-    private async execute(
-        packageName: string,
-        version?: string,
-        options?: DeprecateOptions,
-    ): Promise<void> {
-        try {
-            // Load credentials
-            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);
-            this.logger.success('Wallet loaded');
-
-            // Get package info
-            this.logger.info('Fetching package info...');
-            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);
-            }
-
-            // Determine version
-            const targetVersion = version || packageInfo.latestVersion;
-            if (!targetVersion) {
-                this.logger.fail('No version specified');
-                this.logger.error('Package has no versions.');
-                process.exit(1);
-            }
-
-            // Get version info
-            const versionInfo = await getVersion(packageName, targetVersion, network);
-            if (!versionInfo) {
-                this.logger.fail('Version not found');
-                this.logger.error(`Version "${targetVersion}" does not exist.`);
-                process.exit(1);
-            }
-
-            if (versionInfo.deprecated) {
-                this.logger.warn('Already deprecated');
-                this.logger.log(`Version ${targetVersion} is already deprecated.`);
-                return;
-            }
-
-            // Check if immutable
-            const immutable = await isVersionImmutable(packageName, targetVersion, network);
-            if (immutable) {
-                this.logger.fail('Version is immutable');
-                this.logger.error('This version is past the 72-hour mutability window.');
-                this.logger.error('Immutable versions cannot be deprecated.');
-                process.exit(1);
-            }
-
-            this.logger.success(`Found: ${packageName}@${targetVersion}`);
-
-            // Get deprecation message
-            let message = options?.message;
-            if (!message && !options?.yes) {
-                message = await input({
-                    message: 'Deprecation reason (optional):',
-                    default: '',
-                });
-            }
-            message = message || 'No reason provided';
-
-            // Display summary
-            this.logger.log('');
-            this.logger.info('Deprecation Summary');
-            this.logger.log('─'.repeat(50));
-            this.logger.log(`Package:  ${packageName}`);
-            this.logger.log(`Version:  ${targetVersion}`);
-            this.logger.log(`Reason:   ${message}`);
-            this.logger.log(`Network:  ${options?.network}`);
-            this.logger.log('');
-
-            // Confirmation
-            if (!options?.yes) {
-                const confirmed = await confirm({
-                    message: `Deprecate ${packageName}@${targetVersion}?`,
-                    default: false,
-                });
-
-                if (!confirmed) {
-                    this.logger.warn('Deprecation cancelled.');
-                    return;
-                }
-            }
-
-            // Check wallet balance
-            this.logger.info('Checking wallet balance...');
-            const { sufficient, balance } = await checkBalance(wallet, network);
-            if (!sufficient) {
-                this.logger.fail('Insufficient balance');
-                this.logger.error(`Wallet balance: ${formatSats(balance)}`);
-                this.logger.error('Please fund your wallet before deprecating.');
-                process.exit(1);
-            }
-            this.logger.success(`Wallet balance: ${formatSats(balance)}`);
-
-            // Execute deprecation
-            this.logger.info('Deprecating version...');
-
-            const sender = getWalletAddress(wallet);
-            const contract = getRegistryContract(network, sender);
-            const txParams = buildTransactionParams(wallet, network);
-
-            const deprecateResult = await contract.deprecateVersion(
-                packageName,
-                targetVersion,
-                message,
-            );
-
-            if (deprecateResult.revert) {
-                this.logger.fail('Deprecation would fail');
-                this.logger.error(`Reason: ${deprecateResult.revert}`);
-                process.exit(1);
-            }
-
-            if (deprecateResult.estimatedGas) {
-                this.logger.info(`Estimated gas: ${deprecateResult.estimatedGas} sats`);
-            }
-
-            const receipt = await deprecateResult.sendTransaction(txParams);
-
-            this.logger.log('');
-            this.logger.success('Version deprecated successfully!');
-            this.logger.log('');
-            this.logger.log(`Package:        ${packageName}`);
-            this.logger.log(`Version:        ${targetVersion}`);
-            this.logger.log(`Reason:         ${message}`);
-            this.logger.log(`Transaction ID: ${receipt.transactionId}`);
-            this.logger.log(`Fees paid:      ${formatSats(receipt.estimatedFees)}`);
-            this.logger.log('');
-        } catch (error) {
-            this.logger.fail('Deprecation failed');
-            if (this.isUserCancelled(error)) {
-                this.logger.warn('Deprecation cancelled.');
-                process.exit(0);
-            }
-            this.exitWithError(this.formatError(error));
-        }
-    }
-}
-
-export const deprecateCommand = new DeprecateCommand().getCommand();