@btc-vision/cli 1.0.0

package/build/commands/CompileCommand.js

@@ -0,0 +1,138 @@
+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 { loadManifest, getManifestPath } from '../lib/manifest.js';
+import { buildOpnetBinary, formatFileSize, computeChecksum } from '../lib/binary.js';
+import { CLIWallet } from '../lib/wallet.js';
+import { loadCredentials, canSign } from '../lib/credentials.js';
+export class CompileCommand extends BaseCommand {
+    constructor() {
+        super('compile', 'Compile plugin to .opnet binary format');
+    }
+    configure() {
+        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) => this.execute(options));
+    }
+    async execute(options) {
+        try {
+            const projectDir = options.dir ? path.resolve(options.dir) : process.cwd();
+            const manifestPath = getManifestPath(projectDir);
+            this.logger.info('Loading plugin manifest...');
+            const manifest = loadManifest(manifestPath);
+            this.logger.success(`Loaded manifest: ${manifest.name}@${manifest.version}`);
+            const srcDir = path.join(projectDir, 'src');
+            const entryPoint = path.join(srcDir, 'index.ts');
+            if (!fs.existsSync(entryPoint)) {
+                this.exitWithError(`Entry point not found: ${entryPoint}`);
+            }
+            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',
+                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');
+            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)})`);
+            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)})`);
+            }
+            let publicKey;
+            let signature;
+            let mldsaLevel;
+            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})`);
+                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)');
+                mldsaLevel = 44;
+                publicKey = Buffer.alloc(1312);
+                signature = Buffer.alloc(2420);
+            }
+            this.logger.info('Assembling .opnet binary...');
+            const binary = buildOpnetBinary({
+                mldsaLevel,
+                publicKey,
+                signature,
+                metadata: manifest,
+                bytecode,
+                proto,
+            });
+            this.logger.success(`Binary assembled (${formatFileSize(binary.length)})`);
+            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);
+            fs.rmSync(bundleDir, { recursive: true, force: true });
+            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/build/commands/ConfigCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command } from 'commander';
+import { BaseCommand } from './BaseCommand.js';
+export declare class ConfigCommand extends BaseCommand {
+    constructor();
+    protected configure(): void;
+    private createGetCommand;
+    private createSetCommand;
+    private createListCommand;
+    private createResetCommand;
+    private createPathCommand;
+    private handleGet;
+    private handleSet;
+    private handleList;
+    private handleReset;
+    private handlePath;
+}
+export declare const configCommand: Command;

package/build/commands/ConfigCommand.js

@@ -0,0 +1,124 @@
+import { Command } from 'commander';
+import * as os from 'os';
+import * as path from 'path';
+import { BaseCommand } from './BaseCommand.js';
+import { saveConfig, getConfigValue, setConfigValue, displayConfig, } from '../lib/config.js';
+export class ConfigCommand extends BaseCommand {
+    constructor() {
+        super('config', 'Manage CLI configuration');
+    }
+    configure() {
+        this.command
+            .addCommand(this.createGetCommand())
+            .addCommand(this.createSetCommand())
+            .addCommand(this.createListCommand())
+            .addCommand(this.createResetCommand())
+            .addCommand(this.createPathCommand());
+    }
+    createGetCommand() {
+        return new Command('get')
+            .description('Get a configuration value')
+            .argument('[key]', 'Configuration key (dot notation, e.g., rpcUrls.mainnet)')
+            .action((key) => {
+            this.handleGet(key);
+        });
+    }
+    createSetCommand() {
+        return new Command('set')
+            .description('Set a configuration value')
+            .argument('<key>', 'Configuration key (dot notation)')
+            .argument('<value>', 'Value to set')
+            .action((key, value) => {
+            this.handleSet(key, value);
+        });
+    }
+    createListCommand() {
+        return new Command('list')
+            .description('List all configuration values')
+            .action(() => {
+            this.handleList();
+        });
+    }
+    createResetCommand() {
+        return new Command('reset')
+            .description('Reset configuration to defaults')
+            .option('-y, --yes', 'Skip confirmation')
+            .action((options) => {
+            this.handleReset(options.yes);
+        });
+    }
+    createPathCommand() {
+        return new Command('path')
+            .description('Show configuration file path')
+            .action(() => {
+            this.handlePath();
+        });
+    }
+    handleGet(key) {
+        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));
+        }
+    }
+    handleSet(key, value) {
+        let parsedValue = value;
+        try {
+            parsedValue = JSON.parse(value);
+        }
+        catch {
+        }
+        setConfigValue(key, parsedValue);
+        this.logger.success(`Set ${key} = ${JSON.stringify(parsedValue)}`);
+    }
+    handleList() {
+        this.logger.log(displayConfig());
+    }
+    handleReset(confirmed) {
+        if (!confirmed) {
+            this.logger.warn('This will reset all configuration to defaults.');
+            this.logger.info('Use --yes to confirm.');
+            return;
+        }
+        const defaultConfig = {
+            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.');
+    }
+    handlePath() {
+        this.logger.log(path.join(os.homedir(), '.opnet', 'config.json'));
+    }
+}
+export const configCommand = new ConfigCommand().getCommand();

package/build/commands/DeprecateCommand.d.ts

@@ -0,0 +1,7 @@
+import { BaseCommand } from './BaseCommand.js';
+export declare class DeprecateCommand extends BaseCommand {
+    constructor();
+    protected configure(): void;
+    private execute;
+}
+export declare const deprecateCommand: import("commander").Command;

package/build/commands/DeprecateCommand.js

@@ -0,0 +1,112 @@
+import { input, confirm } from '@inquirer/prompts';
+import { BaseCommand } from './BaseCommand.js';
+import { getPackage, getVersion, isVersionImmutable } from '../lib/registry.js';
+import { loadCredentials, canSign } from '../lib/credentials.js';
+import { CLIWallet } from '../lib/wallet.js';
+export class DeprecateCommand extends BaseCommand {
+    constructor() {
+        super('deprecate', 'Mark a package version as deprecated');
+    }
+    configure() {
+        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, version, options) => this.execute(packageName, version, options || { network: 'mainnet' }));
+    }
+    async execute(packageName, version, options) {
+        try {
+            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');
+            this.logger.info('Fetching package info...');
+            const network = (options?.network || 'mainnet');
+            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);
+            }
+            const targetVersion = version || packageInfo.latestVersion;
+            if (!targetVersion) {
+                this.logger.fail('No version specified');
+                this.logger.error('Package has no versions.');
+                process.exit(1);
+            }
+            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;
+            }
+            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}`);
+            let message = options?.message;
+            if (!message && !options?.yes) {
+                message = await input({
+                    message: 'Deprecation reason (optional):',
+                    default: '',
+                });
+            }
+            message = message || 'No reason provided';
+            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('');
+            if (!options?.yes) {
+                const confirmed = await confirm({
+                    message: `Deprecate ${packageName}@${targetVersion}?`,
+                    default: false,
+                });
+                if (!confirmed) {
+                    this.logger.warn('Deprecation cancelled.');
+                    return;
+                }
+            }
+            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();

package/build/commands/InfoCommand.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand } from './BaseCommand.js';
+export declare class InfoCommand extends BaseCommand {
+    constructor();
+    protected configure(): void;
+    private execute;
+    private displayBinaryInfo;
+    private displayProjectInfo;
+    private displayPermissions;
+}
+export declare const infoCommand: import("commander").Command;

package/build/commands/InfoCommand.js

@@ -0,0 +1,223 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import { BaseCommand } from './BaseCommand.js';
+import { parseOpnetBinary, formatFileSize, getParsedMldsaLevel } from '../lib/binary.js';
+import { loadManifest, getManifestPath } from '../lib/manifest.js';
+export class InfoCommand extends BaseCommand {
+    constructor() {
+        super('info', 'Display information about a plugin or .opnet file');
+    }
+    configure() {
+        this.command
+            .argument('[path]', 'Path to plugin directory or .opnet file (default: current directory)')
+            .option('--json', 'Output as JSON')
+            .action((inputPath, options) => this.execute(inputPath, options));
+    }
+    execute(inputPath, options) {
+        try {
+            const targetPath = inputPath ? path.resolve(inputPath) : process.cwd();
+            if (!fs.existsSync(targetPath)) {
+                this.exitWithError(`Path not found: ${targetPath}`);
+            }
+            const stat = fs.statSync(targetPath);
+            if (stat.isFile() && targetPath.endsWith('.opnet')) {
+                this.displayBinaryInfo(targetPath, options?.json);
+            }
+            else if (stat.isDirectory()) {
+                this.displayProjectInfo(targetPath, options?.json);
+            }
+            else if (stat.isFile() && targetPath.endsWith('plugin.json')) {
+                this.displayProjectInfo(path.dirname(targetPath), options?.json);
+            }
+            else {
+                this.exitWithError('Invalid path. Provide a plugin directory or .opnet file.');
+            }
+        }
+        catch (error) {
+            this.exitWithError(this.formatError(error));
+        }
+    }
+    displayBinaryInfo(filePath, json) {
+        const data = fs.readFileSync(filePath);
+        const parsed = parseOpnetBinary(data);
+        const mldsaLevel = getParsedMldsaLevel(parsed);
+        const isUnsigned = parsed.publicKey.every((b) => b === 0);
+        const publicKeyHash = crypto.createHash('sha256').update(parsed.publicKey).digest('hex');
+        if (json) {
+            const output = {
+                type: 'binary',
+                file: filePath,
+                fileSize: data.length,
+                formatVersion: parsed.formatVersion,
+                mldsaLevel,
+                signed: !isUnsigned,
+                publicKeyHash: isUnsigned ? null : publicKeyHash,
+                metadata: parsed.metadata,
+                sizes: {
+                    metadata: parsed.rawMetadata.length,
+                    bytecode: parsed.bytecode.length,
+                    proto: parsed.proto?.length ?? 0,
+                    publicKey: parsed.publicKey.length,
+                    signature: parsed.signature.length,
+                },
+            };
+            this.logger.log(JSON.stringify(output, null, 2));
+            return;
+        }
+        const meta = parsed.metadata;
+        this.logger.info('\nOPNet Binary Information\n');
+        this.logger.log('─'.repeat(60));
+        this.logger.log(`File:            ${filePath}`);
+        this.logger.log(`Size:            ${formatFileSize(data.length)}`);
+        this.logger.log(`Format:          v${parsed.formatVersion}`);
+        this.logger.log('');
+        this.logger.log('Plugin:');
+        this.logger.log(`  Name:           ${meta.name}`);
+        this.logger.log(`  Version:        ${meta.version}`);
+        this.logger.log(`  Type:           ${meta.pluginType}`);
+        this.logger.log(`  OPNet:          ${meta.opnetVersion}`);
+        if (meta.description) {
+            this.logger.log(`  Description:    ${meta.description}`);
+        }
+        this.logger.log('');
+        this.logger.log('Author:');
+        this.logger.log(`  Name:           ${meta.author.name}`);
+        if (meta.author.email) {
+            this.logger.log(`  Email:          ${meta.author.email}`);
+        }
+        this.logger.log('');
+        this.logger.log('Cryptography:');
+        this.logger.log(`  MLDSA Level:    MLDSA-${mldsaLevel}`);
+        this.logger.log(`  Signed:         ${isUnsigned ? 'No' : 'Yes'}`);
+        if (!isUnsigned) {
+            this.logger.log(`  Publisher:      ${publicKeyHash.substring(0, 32)}...`);
+        }
+        this.logger.log('');
+        this.logger.log('Sizes:');
+        this.logger.log(`  Bytecode:       ${formatFileSize(parsed.bytecode.length)}`);
+        this.logger.log(`  Metadata:       ${formatFileSize(parsed.rawMetadata.length)}`);
+        this.logger.log(`  Proto:          ${formatFileSize(parsed.proto?.length ?? 0)}`);
+        this.logger.log('');
+        this.logger.log('Permissions:');
+        this.displayPermissions(meta.permissions);
+        this.logger.log('');
+        if (Object.keys(meta.dependencies || {}).length > 0) {
+            this.logger.log('Dependencies:');
+            for (const [name, version] of Object.entries(meta.dependencies || {})) {
+                this.logger.log(`  ${name}: ${version}`);
+            }
+            this.logger.log('');
+        }
+    }
+    displayProjectInfo(projectDir, json) {
+        const manifestPath = getManifestPath(projectDir);
+        if (!fs.existsSync(manifestPath)) {
+            this.logger.fail('No plugin.json found in this directory.');
+            this.logger.info('Run `opnet init` to create a new plugin project.');
+            process.exit(1);
+        }
+        const manifest = loadManifest(manifestPath);
+        const binaryPath = path.join(projectDir, 'build', `${manifest.name.replace(/^@/, '').replace(/\//g, '-')}.opnet`);
+        const hasBinary = fs.existsSync(binaryPath);
+        let binarySize = null;
+        if (hasBinary) {
+            binarySize = fs.statSync(binaryPath).size;
+        }
+        const srcDir = path.join(projectDir, 'src');
+        const hasSrc = fs.existsSync(srcDir);
+        const hasNodeModules = fs.existsSync(path.join(projectDir, 'node_modules'));
+        if (json) {
+            const output = {
+                type: 'project',
+                directory: projectDir,
+                manifest,
+                compiled: hasBinary,
+                binaryPath: hasBinary ? binaryPath : null,
+                binarySize,
+                hasSource: hasSrc,
+                hasNodeModules,
+            };
+            this.logger.log(JSON.stringify(output, null, 2));
+            return;
+        }
+        this.logger.info('\nOPNet Plugin Project\n');
+        this.logger.log('─'.repeat(60));
+        this.logger.log(`Directory:      ${projectDir}`);
+        this.logger.log('');
+        this.logger.log('Plugin:');
+        this.logger.log(`  Name:           ${manifest.name}`);
+        this.logger.log(`  Version:        ${manifest.version}`);
+        this.logger.log(`  Type:           ${manifest.pluginType}`);
+        this.logger.log(`  OPNet:          ${manifest.opnetVersion}`);
+        if (manifest.description) {
+            this.logger.log(`  Description:    ${manifest.description}`);
+        }
+        this.logger.log('');
+        this.logger.log('Author:');
+        this.logger.log(`  Name:           ${manifest.author.name}`);
+        if (manifest.author.email) {
+            this.logger.log(`  Email:          ${manifest.author.email}`);
+        }
+        this.logger.log('');
+        this.logger.log('Status:');
+        this.logger.log(`  Source:         ${hasSrc ? 'Found' : 'Missing'}`);
+        this.logger.log(`  Dependencies:   ${hasNodeModules ? 'Installed' : 'Not installed'}`);
+        this.logger.log(`  Compiled:       ${hasBinary && binarySize !== null ? `Yes (${formatFileSize(binarySize)})` : 'No'}`);
+        this.logger.log('');
+        this.logger.log('Permissions:');
+        this.displayPermissions(manifest.permissions);
+        this.logger.log('');
+        if (manifest.resources) {
+            this.logger.log('Resources:');
+            if (manifest.resources.memory) {
+                this.logger.log(`  Max Heap:       ${manifest.resources.memory.maxHeapMB ?? 'N/A'} MB`);
+            }
+            if (manifest.resources.cpu) {
+                this.logger.log(`  Max Threads:    ${manifest.resources.cpu.maxThreads ?? 'N/A'}`);
+                this.logger.log(`  Priority:       ${manifest.resources.cpu.priority ?? 'normal'}`);
+            }
+            if (manifest.resources.timeout) {
+                this.logger.log(`  Init Timeout:   ${manifest.resources.timeout.initMs ?? 'N/A'} ms`);
+                this.logger.log(`  Hook Timeout:   ${manifest.resources.timeout.hookMs ?? 'N/A'} ms`);
+            }
+            this.logger.log('');
+        }
+        if (Object.keys(manifest.dependencies || {}).length > 0) {
+            this.logger.log('Plugin Dependencies:');
+            for (const [name, version] of Object.entries(manifest.dependencies || {})) {
+                this.logger.log(`  ${name}: ${version}`);
+            }
+            this.logger.log('');
+        }
+        if (manifest.lifecycle) {
+            this.logger.log('Lifecycle:');
+            this.logger.log(`  Load Priority:  ${manifest.lifecycle.loadPriority ?? 100}`);
+            this.logger.log(`  Enabled:        ${manifest.lifecycle.enabledByDefault !== false ? 'Yes' : 'No'}`);
+            this.logger.log(`  Requires Restart: ${manifest.lifecycle.requiresRestart ? 'Yes' : 'No'}`);
+            this.logger.log('');
+        }
+    }
+    displayPermissions(permissions) {
+        if (!permissions) {
+            this.logger.log('  (none configured)');
+            return;
+        }
+        const db = permissions.database?.enabled ?? false;
+        const blocks = permissions.blocks?.preProcess ||
+            permissions.blocks?.postProcess ||
+            permissions.blocks?.onChange ||
+            false;
+        const epochs = permissions.epochs?.onChange || permissions.epochs?.onFinalized || false;
+        const mempool = permissions.mempool?.txFeed ?? false;
+        const api = permissions.api?.addEndpoints || permissions.api?.addWebsocket || false;
+        const fsPerms = permissions.filesystem?.configDir || permissions.filesystem?.tempDir || false;
+        this.logger.log(`  Database:       ${db ? 'Yes' : 'No'}`);
+        this.logger.log(`  Block Hooks:    ${blocks ? 'Yes' : 'No'}`);
+        this.logger.log(`  Epoch Hooks:    ${epochs ? 'Yes' : 'No'}`);
+        this.logger.log(`  Mempool Feed:   ${mempool ? 'Yes' : 'No'}`);
+        this.logger.log(`  API Endpoints:  ${api ? 'Yes' : 'No'}`);
+        this.logger.log(`  Filesystem:     ${fsPerms ? 'Yes' : 'No'}`);
+    }
+}
+export const infoCommand = new InfoCommand().getCommand();

package/build/commands/InitCommand.d.ts

@@ -0,0 +1,16 @@
+import { BaseCommand } from './BaseCommand.js';
+export declare class InitCommand extends BaseCommand {
+    constructor();
+    protected configure(): void;
+    private execute;
+    private gatherConfig;
+    private createProject;
+    private createPluginJson;
+    private createPackageJson;
+    private createTsConfig;
+    private createEntryPoint;
+    private createGitignore;
+    private createReadme;
+    private toPascalCase;
+}
+export declare const initCommand: import("commander").Command;