@btc-vision/cli 1.0.0

package/src/commands/CompileCommand.ts

@@ -0,0 +1,196 @@
+/**
+ * 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, computeChecksum, 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 signature: Buffer;
+            let mldsaLevel: CLIMldsaLevel;
+
+            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})`);
+
+                // Compute checksum and sign
+                this.logger.info('Signing plugin...');
+                const metadataBytes = Buffer.from(JSON.stringify(manifest), 'utf-8');
+                const checksum = computeChecksum(metadataBytes, bytecode, proto);
+
+                signature = wallet.signMLDSA(checksum);
+                this.logger.success(
+                    `Plugin signed (${formatFileSize(signature.length)} signature)`,
+                );
+            } 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
+                signature = Buffer.alloc(2420); // MLDSA-44 signature size
+            }
+
+            // Build .opnet binary
+            this.logger.info('Assembling .opnet binary...');
+            const binary = buildOpnetBinary({
+                mldsaLevel,
+                publicKey,
+                signature,
+                metadata: manifest,
+                bytecode,
+                proto,
+            });
+            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(`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

@@ -0,0 +1,144 @@
+/**
+ * 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 { displayConfig, getConfigValue, saveConfig, setConfigValue } from '../lib/config.js';
+import { CLIConfig } from '../types/index.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;
+        }
+
+        const defaultConfig: CLIConfig = {
+            defaultNetwork: 'mainnet',
+            rpcUrls: {
+                mainnet: 'https://api.opnet.org',
+                testnet: 'https://testnet.opnet.org',
+                regtest: 'http://localhost:9001',
+            },
+            ipfsGateway: 'https://ipfs.opnet.org/ipfs/',
+            ipfsGateways: [
+                'https://ipfs.opnet.org/ipfs/',
+                'https://ipfs.io/ipfs/',
+                'https://cloudflare-ipfs.com/ipfs/',
+                'https://dweb.link/ipfs/',
+            ],
+            ipfsPinningEndpoint: 'https://ipfs.opnet.org/api/v0/add',
+            ipfsPinningApiKey: '',
+            ipfsPinningAuthHeader: 'Authorization',
+            registryAddresses: {
+                mainnet: '',
+                testnet: '',
+                regtest: '',
+            },
+            defaultMldsaLevel: 44,
+            indexerUrl: 'https://indexer.opnet.org',
+        };
+
+        saveConfig(defaultConfig);
+        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

@@ -0,0 +1,156 @@
+/**
+ * Deprecate command - Mark a package version as deprecated
+ *
+ * @module commands/DeprecateCommand
+ */
+
+import { confirm, input } from '@inquirer/prompts';
+import { BaseCommand } from './BaseCommand.js';
+import { getPackage, getVersion, isVersionImmutable } from '../lib/registry.js';
+import { canSign, loadCredentials } from '../lib/credentials.js';
+import { CLIWallet } from '../lib/wallet.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);
+            }
+            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;
+                }
+            }
+
+            // Execute deprecation
+            this.logger.info('Deprecating version...');
+            this.logger.warn('Deprecation transaction required.');
+            this.logger.log('Transaction would call: deprecateVersion(');
+            this.logger.log(`  packageName: "${packageName}",`);
+            this.logger.log(`  version: "${targetVersion}",`);
+            this.logger.log(`  reason: "${message}"`);
+            this.logger.log(')');
+            this.logger.info('Deprecation (transaction pending)');
+
+            this.logger.log('');
+            this.logger.success('Deprecation submitted!');
+            this.logger.warn('Note: Registry transaction support is coming soon.');
+            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();