@btc-vision/cli 1.0.0

package/src/commands/PublishCommand.ts

@@ -0,0 +1,230 @@
+/**
+ * Publish command - Publish plugin to the OPNet registry
+ *
+ * @module commands/PublishCommand
+ */
+
+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 { formatFileSize, parseOpnetBinary, verifyChecksum } from '../lib/binary.js';
+import { CLIWallet } from '../lib/wallet.js';
+import { canSign, loadCredentials } from '../lib/credentials.js';
+import { uploadPlugin } from '../lib/ipfs.js';
+import {
+    computePermissionsHash,
+    encodeDependencies,
+    getPackage,
+    getScope,
+    mldsaLevelToRegistry,
+    parsePackageName,
+    pluginTypeToRegistry,
+} from '../lib/registry.js';
+import { CLIMldsaLevel, NetworkName } from '../types/index.js';
+
+interface PublishOptions {
+    network: string;
+    dryRun?: boolean;
+    yes?: boolean;
+}
+
+export class PublishCommand extends BaseCommand {
+    constructor() {
+        super('publish', 'Publish a plugin to the OPNet registry');
+    }
+
+    protected configure(): void {
+        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?: string, options?: PublishOptions) =>
+                this.execute(file, options || { network: 'mainnet' }),
+            );
+    }
+
+    private async execute(file?: string, options?: PublishOptions): Promise<void> {
+        try {
+            // Find the .opnet file
+            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')) as {
+                        name: string;
+                    };
+                    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);
+            }
+
+            // Parse and validate binary
+            this.logger.info('Parsing plugin binary...');
+            const data = fs.readFileSync(binaryPath);
+            const parsed = parseOpnetBinary(data);
+
+            // Verify checksum
+            if (!verifyChecksum(parsed)) {
+                this.logger.fail('Checksum verification failed');
+                this.logger.error('The binary appears to be corrupted.');
+                process.exit(1);
+            }
+
+            // Check if signed
+            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] as const)[parsed.mldsaLevel] as CLIMldsaLevel;
+            this.logger.success(`Parsed: ${meta.name}@${meta.version}`);
+
+            // Load wallet and verify ownership
+            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');
+
+            // Check registry status
+            this.logger.info('Checking registry status...');
+            const { scope, name } = parsePackageName(meta.name);
+            const network = (options?.network || 'mainnet') as NetworkName;
+
+            // Check if scoped package
+            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)`,
+            );
+
+            // Display summary
+            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;
+            }
+
+            // Confirmation
+            if (!options?.yes) {
+                const confirmed = await confirm({
+                    message: 'Publish this plugin?',
+                    default: true,
+                });
+
+                if (!confirmed) {
+                    this.logger.warn('Publishing cancelled.');
+                    return;
+                }
+            }
+
+            // Upload to IPFS
+            this.logger.info('Uploading to IPFS...');
+            const pinResult = await uploadPlugin(binaryPath);
+            this.logger.success(`Uploaded to IPFS: ${pinResult.cid}`);
+
+            // Prepare registry data
+            const permissionsHash = computePermissionsHash(meta.permissions);
+            const dependencies = encodeDependencies(meta.dependencies || {});
+
+            // Register package if new
+            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)');
+            }
+
+            // Publish version
+            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/src/commands/SearchCommand.ts

@@ -0,0 +1,141 @@
+/**
+ * Search command - Search for plugins in the registry
+ *
+ * @module commands/SearchCommand
+ */
+
+import { BaseCommand } from './BaseCommand.js';
+import {
+    getPackage,
+    getVersion,
+    registryToMldsaLevel,
+    registryToPluginType,
+    VersionInfo,
+} from '../lib/registry.js';
+import { NetworkName } from '../types/index.js';
+
+interface SearchOptions {
+    network: string;
+    json?: boolean;
+}
+
+export class SearchCommand extends BaseCommand {
+    constructor() {
+        super('search', 'Search for plugins in the registry');
+    }
+
+    protected configure(): void {
+        this.command
+            .argument('<query>', 'Package name or search query')
+            .option('-n, --network <network>', 'Network', 'mainnet')
+            .option('--json', 'Output as JSON')
+            .action((query: string, options?: SearchOptions) =>
+                this.execute(query, options || { network: 'mainnet' }),
+            );
+    }
+
+    private async execute(query: string, options?: SearchOptions): Promise<void> {
+        try {
+            const network = (options?.network || 'mainnet') as NetworkName;
+
+            // Direct package lookup
+            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;
+            }
+
+            // Get latest version details
+            let latestVersionInfo: VersionInfo | null = 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;
+            }
+
+            // Display results
+            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/src/commands/SignCommand.ts

@@ -0,0 +1,122 @@
+/**
+ * Sign command - Sign or re-sign a .opnet binary
+ *
+ * @module commands/SignCommand
+ */
+
+import * as fs from 'fs';
+import * as crypto from 'crypto';
+import { BaseCommand } from './BaseCommand.js';
+import {
+    buildOpnetBinary,
+    computeChecksum,
+    formatFileSize,
+    parseOpnetBinary,
+} from '../lib/binary.js';
+import { CLIWallet } from '../lib/wallet.js';
+import { canSign, loadCredentials } from '../lib/credentials.js';
+
+interface SignOptions {
+    output?: string;
+    force?: boolean;
+}
+
+export class SignCommand extends BaseCommand {
+    constructor() {
+        super('sign', 'Sign or re-sign a .opnet binary with your MLDSA key');
+    }
+
+    protected configure(): void {
+        this.command
+            .argument('<file>', 'Path to .opnet file')
+            .option('-o, --output <path>', 'Output file path (default: overwrites input)')
+            .option('--force', 'Force re-signing even if already signed by different key')
+            .action((file: string, options: SignOptions) => this.execute(file, options));
+    }
+
+    private execute(file: string, options: SignOptions): void {
+        try {
+            if (!fs.existsSync(file)) {
+                this.exitWithError(`File not found: ${file}`);
+            }
+
+            // Load credentials
+            this.logger.info('Loading wallet...');
+            const credentials = loadCredentials();
+
+            if (!credentials || !canSign(credentials)) {
+                this.logger.fail('No credentials configured');
+                this.logger.warn('To sign plugins, run: opnet login');
+                process.exit(1);
+            }
+
+            const wallet = CLIWallet.fromCredentials(credentials);
+            this.logger.success(`Wallet loaded (MLDSA-${wallet.securityLevel})`);
+
+            // Parse existing binary
+            this.logger.info('Parsing binary...');
+            const data = fs.readFileSync(file);
+            const parsed = parseOpnetBinary(data);
+            this.logger.success(`Parsed: ${parsed.metadata.name}@${parsed.metadata.version}`);
+
+            // Check if already signed by a different key
+            const isUnsigned = parsed.publicKey.every((b) => b === 0);
+            const currentPkHash = crypto
+                .createHash('sha256')
+                .update(parsed.publicKey)
+                .digest('hex');
+            const newPkHash = wallet.mldsaPublicKeyHash;
+
+            if (!isUnsigned && currentPkHash !== newPkHash && !options.force) {
+                this.logger.log('');
+                this.logger.warn('Warning: This binary is already signed by a different key.');
+                this.logger.log(`  Current signer: ${currentPkHash.substring(0, 32)}...`);
+                this.logger.log(`  Your key:       ${newPkHash.substring(0, 32)}...`);
+                this.logger.log('');
+                this.logger.log('Use --force to re-sign with your key.');
+                process.exit(1);
+            }
+
+            // Compute new signature
+            this.logger.info('Signing...');
+            const metadataBytes = Buffer.from(parsed.rawMetadata, 'utf-8');
+            const checksum = computeChecksum(
+                metadataBytes,
+                parsed.bytecode,
+                parsed.proto ?? Buffer.alloc(0),
+            );
+            const signature = wallet.signMLDSA(checksum);
+            this.logger.success(`Signed (${formatFileSize(signature.length)} signature)`);
+
+            // Rebuild binary
+            this.logger.info('Rebuilding binary...');
+            const newBinary = buildOpnetBinary({
+                mldsaLevel: wallet.securityLevel,
+                publicKey: wallet.mldsaPublicKey,
+                signature,
+                metadata: parsed.metadata,
+                bytecode: parsed.bytecode,
+                proto: parsed.proto ?? Buffer.alloc(0),
+            });
+            this.logger.success(`Binary rebuilt (${formatFileSize(newBinary.length)})`);
+
+            // Write output
+            const outputPath = options.output || file;
+            fs.writeFileSync(outputPath, newBinary);
+
+            this.logger.log('');
+            this.logger.success('Plugin signed successfully!');
+            this.logger.log('');
+            this.logger.log(`Output:       ${outputPath}`);
+            this.logger.log(`Plugin:       ${parsed.metadata.name}@${parsed.metadata.version}`);
+            this.logger.log(`MLDSA Level:  ${wallet.securityLevel}`);
+            this.logger.log(`Publisher:    ${newPkHash.substring(0, 32)}...`);
+            this.logger.log('');
+        } catch (error) {
+            this.logger.fail('Signing failed');
+            this.exitWithError(this.formatError(error));
+        }
+    }
+}
+
+export const signCommand = new SignCommand().getCommand();