@btc-vision/cli 1.0.0

package/src/commands/TransferCommand.ts

@@ -0,0 +1,235 @@
+/**
+ * Transfer command - Initiate ownership transfer
+ *
+ * @module commands/TransferCommand
+ */
+
+import { confirm, input } from '@inquirer/prompts';
+import { BaseCommand } from './BaseCommand.js';
+import {
+    getPackage,
+    getPendingScopeTransfer,
+    getPendingTransfer,
+    getScope,
+} from '../lib/registry.js';
+import { canSign, loadCredentials } from '../lib/credentials.js';
+import { CLIWallet } from '../lib/wallet.js';
+import { NetworkName } from '../types/index.js';
+
+interface TransferOptions {
+    network: string;
+    yes?: boolean;
+    cancel?: boolean;
+}
+
+export class TransferCommand extends BaseCommand {
+    constructor() {
+        super('transfer', 'Initiate ownership transfer of a package or scope');
+    }
+
+    protected configure(): void {
+        this.command
+            .argument('<name>', 'Package name or @scope')
+            .argument('[newOwner]', 'New owner address')
+            .option('-n, --network <network>', 'Network', 'mainnet')
+            .option('-y, --yes', 'Skip confirmation')
+            .option('--cancel', 'Cancel pending transfer')
+            .action((name: string, newOwner?: string, options?: TransferOptions) =>
+                this.execute(name, newOwner, options || { network: 'mainnet' }),
+            );
+    }
+
+    private async execute(
+        name: string,
+        newOwner?: string,
+        options?: TransferOptions,
+    ): 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');
+
+            const network = (options?.network || 'mainnet') as NetworkName;
+            const isScope = name.startsWith('@') && !name.includes('/');
+            const displayName = isScope ? name : `package ${name}`;
+
+            if (options?.cancel) {
+                await this.handleCancel(name, isScope, network, options);
+                return;
+            }
+
+            // Initiate transfer
+            let targetOwner = newOwner;
+            if (!targetOwner) {
+                targetOwner = await input({
+                    message: 'New owner address:',
+                    validate: (value) => {
+                        if (!value || value.length < 20) {
+                            return 'Please enter a valid address';
+                        }
+                        return true;
+                    },
+                });
+            }
+
+            // Verify target exists
+            this.logger.info(`Checking ${displayName}...`);
+
+            if (isScope) {
+                const scopeName = name.substring(1);
+                const scopeInfo = await getScope(scopeName, network);
+                if (!scopeInfo) {
+                    this.logger.fail('Scope not found');
+                    this.logger.error(`Scope "${name}" does not exist.`);
+                    process.exit(1);
+                }
+                this.logger.success(`Found scope ${name}`);
+            } else {
+                const packageInfo = await getPackage(name, network);
+                if (!packageInfo) {
+                    this.logger.fail('Package not found');
+                    this.logger.error(`Package "${name}" does not exist.`);
+                    process.exit(1);
+                }
+                this.logger.success(`Found package ${name}`);
+            }
+
+            // Display summary
+            this.logger.log('');
+            this.logger.info('Transfer Summary');
+            this.logger.log('─'.repeat(50));
+            this.logger.log(`Type:       ${isScope ? 'Scope' : 'Package'}`);
+            this.logger.log(`Name:       ${name}`);
+            this.logger.log(`New Owner: ${targetOwner}`);
+            this.logger.log(`Network:    ${options?.network}`);
+            this.logger.log('');
+
+            this.logger.warn(
+                'Note: The new owner must call `opnet accept` to complete the transfer.',
+            );
+            this.logger.log('');
+
+            // Confirmation
+            if (!options?.yes) {
+                const confirmed = await confirm({
+                    message: `Initiate transfer of ${displayName}?`,
+                    default: false,
+                });
+
+                if (!confirmed) {
+                    this.logger.warn('Transfer cancelled.');
+                    return;
+                }
+            }
+
+            // Execute transfer
+            this.logger.info('Initiating transfer...');
+
+            if (isScope) {
+                const scopeName = name.substring(1);
+                this.logger.warn('Transfer transaction required.');
+                this.logger.log('Transaction would call: initiateScopeTransfer(');
+                this.logger.log(`  scopeName: "${scopeName}",`);
+                this.logger.log(`  newOwner: "${targetOwner}"`);
+                this.logger.log(')');
+            } else {
+                this.logger.warn('Transfer transaction required.');
+                this.logger.log('Transaction would call: initiateTransfer(');
+                this.logger.log(`  packageName: "${name}",`);
+                this.logger.log(`  newOwner: "${targetOwner}"`);
+                this.logger.log(')');
+            }
+            this.logger.info('Transfer (transaction pending)');
+
+            this.logger.log('');
+            this.logger.success('Transfer initiated!');
+            this.logger.warn('Note: Registry transaction support is coming soon.');
+            this.logger.log('');
+        } catch (error) {
+            this.logger.fail('Transfer failed');
+            if (this.isUserCancelled(error)) {
+                this.logger.warn('Transfer cancelled.');
+                process.exit(0);
+            }
+            this.exitWithError(this.formatError(error));
+        }
+    }
+
+    private async handleCancel(
+        name: string,
+        isScope: boolean,
+        network: NetworkName,
+        options: TransferOptions,
+    ): Promise<void> {
+        this.logger.info('Checking pending transfer...');
+
+        if (isScope) {
+            const scopeName = name.substring(1);
+            const pending = await getPendingScopeTransfer(scopeName, network);
+            if (!pending) {
+                this.logger.warn('No pending transfer');
+                this.logger.log(`No pending transfer for ${name}.`);
+                return;
+            }
+            this.logger.success(`Found pending transfer to ${pending.pendingOwner}`);
+
+            if (!options?.yes) {
+                const confirmed = await confirm({
+                    message: `Cancel ownership transfer of ${name}?`,
+                    default: true,
+                });
+                if (!confirmed) {
+                    this.logger.warn('Cancelled.');
+                    return;
+                }
+            }
+
+            this.logger.info('Cancelling transfer...');
+            this.logger.warn('Cancellation transaction required.');
+            this.logger.log('Transaction would call: cancelScopeTransfer(');
+            this.logger.log(`  scopeName: "${scopeName}"`);
+            this.logger.log(')');
+            this.logger.info('Cancellation (transaction pending)');
+        } else {
+            const pending = await getPendingTransfer(name, network);
+            if (!pending) {
+                this.logger.warn('No pending transfer');
+                this.logger.log(`No pending transfer for ${name}.`);
+                return;
+            }
+            this.logger.success(`Found pending transfer to ${pending.pendingOwner}`);
+
+            if (!options?.yes) {
+                const confirmed = await confirm({
+                    message: `Cancel ownership transfer of ${name}?`,
+                    default: true,
+                });
+                if (!confirmed) {
+                    this.logger.warn('Cancelled.');
+                    return;
+                }
+            }
+
+            this.logger.info('Cancelling transfer...');
+            this.logger.warn('Cancellation transaction required.');
+            this.logger.log('Transaction would call: cancelTransfer(');
+            this.logger.log(`  packageName: "${name}"`);
+            this.logger.log(')');
+            this.logger.info('Cancellation (transaction pending)');
+        }
+
+        this.logger.log('');
+        this.logger.success('Transfer cancellation submitted!');
+        this.logger.warn('Note: Registry transaction support is coming soon.');
+        this.logger.log('');
+    }
+}
+
+export const transferCommand = new TransferCommand().getCommand();

package/src/commands/UndeprecateCommand.ts

@@ -0,0 +1,134 @@
+/**
+ * Undeprecate command - Remove deprecation from a package version
+ *
+ * @module commands/UndeprecateCommand
+ */
+
+import { confirm } 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 UndeprecateOptions {
+    network: string;
+    yes?: boolean;
+}
+
+export class UndeprecateCommand extends BaseCommand {
+    constructor() {
+        super('undeprecate', 'Remove deprecation from a package version');
+    }
+
+    protected configure(): void {
+        this.command
+            .argument('<package>', 'Package name (e.g., @scope/name or name)')
+            .argument('<version>', 'Version to undeprecate')
+            .option('-n, --network <network>', 'Network', 'mainnet')
+            .option('-y, --yes', 'Skip confirmation')
+            .action((packageName: string, version: string, options?: UndeprecateOptions) =>
+                this.execute(packageName, version, options || { network: 'mainnet' }),
+            );
+    }
+
+    private async execute(
+        packageName: string,
+        version: string,
+        options?: UndeprecateOptions,
+    ): 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);
+            }
+
+            // Get version info
+            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('Not deprecated');
+                this.logger.log(`Version ${version} is not deprecated.`);
+                return;
+            }
+
+            // Check if immutable
+            const immutable = await isVersionImmutable(packageName, version, 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 undeprecated.');
+                process.exit(1);
+            }
+
+            this.logger.success(`Found: ${packageName}@${version} (deprecated)`);
+
+            // Display summary
+            this.logger.log('');
+            this.logger.info('Undeprecation Summary');
+            this.logger.log('─'.repeat(50));
+            this.logger.log(`Package:  ${packageName}`);
+            this.logger.log(`Version:  ${version}`);
+            this.logger.log(`Network:  ${options?.network}`);
+            this.logger.log('');
+
+            // Confirmation
+            if (!options?.yes) {
+                const confirmed = await confirm({
+                    message: `Remove deprecation from ${packageName}@${version}?`,
+                    default: true,
+                });
+
+                if (!confirmed) {
+                    this.logger.warn('Undeprecation cancelled.');
+                    return;
+                }
+            }
+
+            // Execute undeprecation
+            this.logger.info('Removing deprecation...');
+            this.logger.warn('Undeprecation transaction required.');
+            this.logger.log('Transaction would call: undeprecateVersion(');
+            this.logger.log(`  packageName: "${packageName}",`);
+            this.logger.log(`  version: "${version}"`);
+            this.logger.log(')');
+            this.logger.info('Undeprecation (transaction pending)');
+
+            this.logger.log('');
+            this.logger.success('Undeprecation submitted!');
+            this.logger.warn('Note: Registry transaction support is coming soon.');
+            this.logger.log('');
+        } catch (error) {
+            this.logger.fail('Undeprecation failed');
+            if (this.isUserCancelled(error)) {
+                this.logger.warn('Undeprecation cancelled.');
+                process.exit(0);
+            }
+            this.exitWithError(this.formatError(error));
+        }
+    }
+}
+
+export const undeprecateCommand = new UndeprecateCommand().getCommand();

package/src/commands/UpdateCommand.ts

@@ -0,0 +1,200 @@
+/**
+ * Update command - Update installed plugins
+ *
+ * @module commands/UpdateCommand
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { BaseCommand } from './BaseCommand.js';
+import { parseOpnetBinary, verifyChecksum } from '../lib/binary.js';
+import { getPackage, getVersion } from '../lib/registry.js';
+import { fetchFromIPFS } from '../lib/ipfs.js';
+import { CLIWallet } from '../lib/wallet.js';
+import { NetworkName } from '../types/index.js';
+
+interface UpdateOptions {
+    dir?: string;
+    network: string;
+    skipVerify?: boolean;
+}
+
+interface UpdateInfo {
+    file: string;
+    name: string;
+    currentVersion: string;
+    latestVersion: string;
+    cid: string;
+}
+
+export class UpdateCommand extends BaseCommand {
+    constructor() {
+        super('update', 'Update installed plugins to latest versions');
+    }
+
+    protected configure(): void {
+        this.command
+            .argument('[package]', 'Specific package to update (default: all)')
+            .option('-d, --dir <path>', 'Plugins directory (default: ./plugins/)')
+            .option('-n, --network <network>', 'Network', 'mainnet')
+            .option('--skip-verify', 'Skip signature verification')
+            .action((packageName?: string, options?: UpdateOptions) =>
+                this.execute(packageName, options || { network: 'mainnet' }),
+            );
+    }
+
+    private async execute(packageName?: string, options?: UpdateOptions): Promise<void> {
+        try {
+            const pluginsDir = options?.dir || path.join(process.cwd(), 'plugins');
+
+            if (!fs.existsSync(pluginsDir)) {
+                this.logger.warn('No plugins directory found.');
+                this.logger.log(`Expected: ${pluginsDir}`);
+                return;
+            }
+
+            // Find all .opnet files
+            const files = fs.readdirSync(pluginsDir).filter((f) => f.endsWith('.opnet'));
+
+            if (files.length === 0) {
+                this.logger.warn('No plugins installed.');
+                return;
+            }
+
+            const network = (options?.network || 'mainnet') as NetworkName;
+            const updates: UpdateInfo[] = [];
+
+            // Check for updates
+            this.logger.info('\nChecking for updates...\n');
+
+            for (const file of files) {
+                const filePath = path.join(pluginsDir, file);
+
+                try {
+                    const data = fs.readFileSync(filePath);
+                    const parsed = parseOpnetBinary(data);
+                    const name = parsed.metadata.name;
+
+                    // Filter by package name if specified
+                    if (packageName && name !== packageName) {
+                        continue;
+                    }
+
+                    this.logger.info(`Checking ${name}...`);
+
+                    const packageInfo = await getPackage(name, network);
+                    if (!packageInfo) {
+                        this.logger.info(`${name}: not found in registry`);
+                        continue;
+                    }
+
+                    const currentVersion = parsed.metadata.version;
+                    const latestVersion = packageInfo.latestVersion;
+
+                    if (currentVersion === latestVersion) {
+                        this.logger.success(`${name}@${currentVersion}: up to date`);
+                        continue;
+                    }
+
+                    // Get latest version info
+                    const versionInfo = await getVersion(name, latestVersion, network);
+                    if (!versionInfo) {
+                        this.logger.warn(`${name}: latest version info unavailable`);
+                        continue;
+                    }
+
+                    this.logger.info(`${name}: ${currentVersion} -> ${latestVersion}`);
+                    updates.push({
+                        file,
+                        name,
+                        currentVersion,
+                        latestVersion,
+                        cid: versionInfo.ipfsCid,
+                    });
+                } catch {
+                    this.logger.warn(`${file}: failed to parse`);
+                }
+            }
+
+            if (updates.length === 0) {
+                this.logger.log('');
+                this.logger.success('All plugins are up to date!');
+                return;
+            }
+
+            // Display updates
+            this.logger.log('');
+            this.logger.info('Available Updates:');
+            this.logger.log('─'.repeat(60));
+            for (const update of updates) {
+                this.logger.log(
+                    `  ${update.name}: ${update.currentVersion} -> ${update.latestVersion}`,
+                );
+            }
+            this.logger.log('');
+
+            // Perform updates
+            for (const update of updates) {
+                this.logger.info(`Updating ${update.name}...`);
+
+                try {
+                    // Download from IPFS
+                    const result = await fetchFromIPFS(update.cid);
+
+                    // Verify
+                    const parsed = parseOpnetBinary(result.data);
+
+                    if (!verifyChecksum(parsed)) {
+                        this.logger.fail(`${update.name}: checksum failed`);
+                        continue;
+                    }
+
+                    if (!options?.skipVerify) {
+                        const isUnsigned = parsed.publicKey.every((b) => b === 0);
+                        if (!isUnsigned) {
+                            const mldsaLevel = ([44, 65, 87] as const)[parsed.mldsaLevel];
+                            const signatureValid = CLIWallet.verifyMLDSA(
+                                parsed.checksum,
+                                parsed.signature,
+                                parsed.publicKey,
+                                mldsaLevel,
+                            );
+
+                            if (!signatureValid) {
+                                this.logger.fail(`${update.name}: signature invalid`);
+                                continue;
+                            }
+                        }
+                    }
+
+                    // Save updated plugin
+                    const newFileName = `${update.name.replace(/^@/, '').replace(/\//g, '-')}-${update.latestVersion}.opnet`;
+                    const newFilePath = path.join(pluginsDir, newFileName);
+
+                    fs.writeFileSync(newFilePath, result.data);
+
+                    // Remove old file if different
+                    const oldFilePath = path.join(pluginsDir, update.file);
+                    if (oldFilePath !== newFilePath && fs.existsSync(oldFilePath)) {
+                        fs.unlinkSync(oldFilePath);
+                    }
+
+                    this.logger.success(`${update.name}: updated to ${update.latestVersion}`);
+                } catch (error) {
+                    this.logger.fail(
+                        `${update.name}: ${error instanceof Error ? error.message : String(error)}`,
+                    );
+                }
+            }
+
+            this.logger.log('');
+            this.logger.success('Update complete!');
+            this.logger.log('');
+        } catch (error) {
+            this.logger.fail('Update failed');
+            this.exitWithError(this.formatError(error));
+        }
+    }
+}
+
+export const updateCommand = new UpdateCommand().getCommand();