@btc-vision/cli 1.0.8 → 1.0.10

package/build/commands/DeprecateCommand.js

@@ -1,6 +1,6 @@
 import { confirm, input } from '@inquirer/prompts';
 import { BaseCommand } from './BaseCommand.js';
-import { getPackage, getRegistryContract, getVersion, isVersionImmutable, } from '../lib/registry.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';

package/build/commands/DomainCommand.js

@@ -3,7 +3,7 @@ import { confirm } from '@inquirer/prompts';
 import { Logger } from '@btc-vision/logger';
 import { CLIWallet } from '../lib/wallet.js';
 import { canSign, loadCredentials } from '../lib/credentials.js';
-import { getContenthash, getContenthashTypeName, getDomain, getDomainPrice, getResolverContract, getTreasuryAddress, parseDomainName, validateDomainName, } from '../lib/resolver.js';
+import { getResolverContract, getDomain, getContenthash, getContenthashTypeName, validateDomainName, getTreasuryAddress, getDomainPrice, parseDomainName, } from '../lib/resolver.js';
 import { buildTransactionParams, checkBalance, DEFAULT_FEE_RATE, DEFAULT_MAX_SAT_TO_SPEND, formatSats, getWalletAddress, waitForTransactionConfirmation, } from '../lib/transaction.js';
 import { TransactionOutputFlags } from 'opnet';
 const logger = new Logger();
@@ -67,7 +67,6 @@ async function registerDomain(domain, options) {
         logger.log(`Treasury:     ${treasuryAddr}`);
         logger.log(`Network:      ${network}`);
         logger.log(`Your wallet:  ${wallet.p2trAddress}`);
-        logger.log(`MLDSA Public Key Hash:  ${wallet.address.toHex()}`);
         logger.log('');
         if (options.dryRun) {
             logger.warn('Dry run - no changes made.');
@@ -223,7 +222,8 @@ async function domainInfo(domain, options) {
         process.exit(1);
     }
 }
-const domainCommand = new Command('domain').description('Manage .btc domains');
+const domainCommand = new Command('domain')
+    .description('Manage .btc domains');
 domainCommand
     .command('register')
     .description('Register a new .btc domain')

package/build/commands/InstallCommand.d.ts

@@ -3,5 +3,7 @@ export declare class InstallCommand extends BaseCommand {
     constructor();
     protected configure(): void;
     private execute;
+    private removeOldVersions;
+    private escapeRegex;
 }
 export declare const installCommand: import("commander").Command;

package/build/commands/InstallCommand.js

@@ -106,8 +106,10 @@ export class InstallCommand extends BaseCommand {
             }
             const outputDir = options?.output || path.join(process.cwd(), 'plugins');
             fs.mkdirSync(outputDir, { recursive: true });
-            const fileName = `${packageName.replace(/^@/, '').replace(/\//g, '-')}-${version}.opnet`;
+            const packageBaseName = packageName.replace(/^@/, '').replace(/\//g, '-');
+            const fileName = `${packageBaseName}-${version}.opnet`;
             const outputPath = path.join(outputDir, fileName);
+            this.removeOldVersions(outputDir, packageBaseName, version);
             this.logger.info('Saving plugin...');
             fs.writeFileSync(outputPath, result.data);
             this.logger.success('Plugin installed');
@@ -126,5 +128,31 @@ export class InstallCommand extends BaseCommand {
             this.exitWithError(this.formatError(error));
         }
     }
+    removeOldVersions(outputDir, packageBaseName, newVersion) {
+        try {
+            const entries = fs.readdirSync(outputDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isFile() || !entry.name.endsWith('.opnet')) {
+                    continue;
+                }
+                const pattern = new RegExp(`^${this.escapeRegex(packageBaseName)}-(.+)\\.opnet$`);
+                const match = entry.name.match(pattern);
+                if (match) {
+                    const oldVersion = match[1];
+                    if (oldVersion !== newVersion) {
+                        const oldFilePath = path.join(outputDir, entry.name);
+                        this.logger.info(`Removing old version: ${entry.name}`);
+                        fs.unlinkSync(oldFilePath);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            this.logger.warn(`Could not clean up old versions: ${this.formatError(error)}`);
+        }
+    }
+    escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
 }
 export const installCommand = new InstallCommand().getCommand();

package/build/commands/LoginCommand.js

@@ -76,9 +76,9 @@ export class LoginCommand extends BaseCommand {
                 network: options.network,
             };
         }
-        return this.interactiveLogin(options.network, mldsaLevel);
+        return this.interactiveLogin(options.network);
     }
-    async interactiveLogin(defaultNetwork, defaultLevel) {
+    async interactiveLogin(defaultNetwork) {
         this.logger.info('OPNet Wallet Configuration\n');
         const loginMethod = await select({
             message: 'How would you like to authenticate?',
@@ -104,27 +104,8 @@ export class LoginCommand extends BaseCommand {
             ],
             default: defaultNetwork,
         }));
-        const selectedLevel = (await select({
-            message: 'Select MLDSA security level:',
-            choices: [
-                {
-                    name: 'MLDSA-44 (Level 2, fastest)',
-                    value: 44,
-                    description: '1312 byte public key',
-                },
-                {
-                    name: 'MLDSA-65 (Level 3, balanced)',
-                    value: 65,
-                    description: '1952 byte public key',
-                },
-                {
-                    name: 'MLDSA-87 (Level 5, most secure)',
-                    value: 87,
-                    description: '2592 byte public key',
-                },
-            ],
-            default: defaultLevel,
-        }));
+        const selectedLevel = 44;
+        this.logger.info('Using MLDSA-44 (only supported level on OPNet)');
         if (loginMethod === 'mnemonic') {
             const mnemonic = await password({
                 message: 'Enter your mnemonic phrase (12 or 24 words):',

package/build/commands/UndeprecateCommand.js

@@ -1,6 +1,6 @@
 import { confirm } from '@inquirer/prompts';
 import { BaseCommand } from './BaseCommand.js';
-import { getPackage, getRegistryContract, getVersion, isVersionImmutable, } from '../lib/registry.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';

package/build/commands/WebsiteDeployCommand.js

@@ -6,7 +6,7 @@ import { CLIWallet } from '../lib/wallet.js';
 import { canSign, loadCredentials } from '../lib/credentials.js';
 import { uploadDirectory, uploadFile } from '../lib/ipfs.js';
 import { formatFileSize } from '../lib/binary.js';
-import { getContenthash, getContenthashTypeName, getDomain, getResolverContract, getSubdomain, isSubdomain, parseDomainName, } from '../lib/resolver.js';
+import { getResolverContract, getDomain, getSubdomain, getContenthash, getContenthashTypeName, isSubdomain, parseDomainName, } from '../lib/resolver.js';
 import { buildTransactionParams, checkBalance, DEFAULT_FEE_RATE, DEFAULT_MAX_SAT_TO_SPEND, formatSats, getWalletAddress, waitForTransactionConfirmation, } from '../lib/transaction.js';
 export class WebsiteDeployCommand extends BaseCommand {
     constructor() {
@@ -17,7 +17,7 @@ export class WebsiteDeployCommand extends BaseCommand {
             .argument('<domain>', 'Domain name (e.g., mysite or mysite.btc)')
             .argument('<path>', 'Path to website directory or HTML file')
             .option('-n, --network <network>', 'Network to use', 'mainnet')
-            .option('--dry-run', "Upload to IPFS but don't update on-chain")
+            .option('--dry-run', 'Upload to IPFS but don\'t update on-chain')
             .option('-y, --yes', 'Skip confirmation prompts')
             .action((domain, websitePath, options) => this.execute(domain, websitePath, options || { network: 'mainnet' }));
     }
@@ -84,7 +84,7 @@ export class WebsiteDeployCommand extends BaseCommand {
             if (wallet.address.toHex() !== ownerAddress) {
                 this.logger.fail('You are not the owner of this domain');
                 this.logger.log(`Domain owner: ${ownerAddress}`);
-                this.logger.log(`Your address: ${wallet.p2trAddress}`);
+                this.logger.log(`Your address: ${wallet.address.toHex()}`);
                 process.exit(1);
             }
             this.logger.success('Ownership verified');

package/build/commands/WebsitePublishCommand.js

@@ -2,7 +2,7 @@ import { confirm } from '@inquirer/prompts';
 import { BaseCommand } from './BaseCommand.js';
 import { CLIWallet } from '../lib/wallet.js';
 import { canSign, loadCredentials } from '../lib/credentials.js';
-import { detectContenthashType, getContenthash, getContenthashTypeName, getDomain, getResolverContract, getSubdomain, isSubdomain, parseDomainName, validateCIDv0, validateCIDv1, validateIPNS, } from '../lib/resolver.js';
+import { getResolverContract, getDomain, getSubdomain, getContenthash, detectContenthashType, validateCIDv0, validateCIDv1, validateIPNS, getContenthashTypeName, isSubdomain, parseDomainName, } from '../lib/resolver.js';
 import { buildTransactionParams, checkBalance, DEFAULT_FEE_RATE, DEFAULT_MAX_SAT_TO_SPEND, formatSats, getWalletAddress, waitForTransactionConfirmation, } from '../lib/transaction.js';
 import { CONTENTHASH_TYPE_CIDv0, CONTENTHASH_TYPE_CIDv1, CONTENTHASH_TYPE_IPNS, CONTENTHASH_TYPE_SHA256, } from '../types/BtcResolver.js';
 export class WebsitePublishCommand extends BaseCommand {
@@ -110,8 +110,7 @@ export class WebsitePublishCommand extends BaseCommand {
             if (wallet.address.toHex() !== ownerAddress) {
                 this.logger.fail('You are not the owner of this domain');
                 this.logger.log(`Domain owner: ${ownerAddress}`);
-                this.logger.log(`Your address: ${wallet.p2trAddress}`);
-                this.logger.log(`MLDSA Public Key Hash:  ${wallet.address.toHex()}`);
+                this.logger.log(`Your address: ${wallet.address.toHex()}`);
                 process.exit(1);
             }
             this.logger.success('Ownership verified');

package/build/lib/ipfs.d.ts

@@ -10,6 +10,9 @@ export declare function pinToIPFS(data: Buffer, name?: string): Promise<PinResul
 export declare function fetchFromIPFS(cid: string): Promise<FetchResult>;
 export declare function buildGatewayUrl(gateway: string, cid: string): string;
 export declare function isValidCid(cid: string): boolean;
+export declare function isCIDv0(cid: string): boolean;
+export declare function isCIDv1(cid: string): boolean;
+export declare function cidV0toV1(cidv0: string): string;
 export declare function downloadPlugin(cid: string, outputPath: string): Promise<number>;
 export declare function uploadPlugin(filePath: string): Promise<PinResult>;
 export interface DirectoryPinResult {
@@ -17,5 +20,5 @@ export interface DirectoryPinResult {
     files: number;
     totalSize: number;
 }
-export declare function uploadDirectory(dirPath: string, wrapWithDirectory?: boolean): Promise<DirectoryPinResult>;
+export declare function uploadDirectory(dirPath: string, _wrapWithDirectory?: boolean): Promise<DirectoryPinResult>;
 export declare function uploadFile(filePath: string): Promise<PinResult>;

package/build/lib/ipfs.js

@@ -1,6 +1,7 @@
 import * as https from 'https';
 import * as http from 'http';
 import * as fs from 'fs';
+import ora from 'ora';
 import { loadConfig } from './config.js';
 const DEFAULT_MAX_REDIRECTS = 10;
 async function httpRequest(url, options, redirectCount = 0) {
@@ -23,13 +24,17 @@ async function httpRequest(url, options, redirectCount = 0) {
         };
         const req = lib.request(reqOptions, (res) => {
             const statusCode = res.statusCode ?? 0;
-            if (followRedirect && statusCode >= 300 && statusCode < 400 && res.headers.location) {
-                const redirectUrl = new URL(res.headers.location, url).href;
-                res.resume();
-                httpRequest(redirectUrl, options, redirectCount + 1)
-                    .then(resolve)
-                    .catch(reject);
-                return;
+            if (followRedirect && statusCode >= 300 && statusCode < 400) {
+                const locationHeader = res.headers.location || res.headers['Location'];
+                const location = Array.isArray(locationHeader) ? locationHeader[0] : locationHeader;
+                if (location) {
+                    const redirectUrl = new URL(location, url).href;
+                    res.resume();
+                    httpRequest(redirectUrl, options, redirectCount + 1)
+                        .then(resolve)
+                        .catch(reject);
+                    return;
+                }
             }
             const chunks = [];
             res.on('data', (chunk) => {
@@ -37,6 +42,17 @@ async function httpRequest(url, options, redirectCount = 0) {
             });
             res.on('end', () => {
                 const body = Buffer.concat(chunks);
+                if (followRedirect && statusCode >= 300 && statusCode < 400) {
+                    const bodyStr = body.toString();
+                    const hrefMatch = bodyStr.match(/href="([^"]+)"/);
+                    if (hrefMatch && hrefMatch[1]) {
+                        const redirectUrl = new URL(hrefMatch[1], url).href;
+                        httpRequest(redirectUrl, options, redirectCount + 1)
+                            .then(resolve)
+                            .catch(reject);
+                        return;
+                    }
+                }
                 if (statusCode >= 200 && statusCode < 300) {
                     resolve(body);
                 }
@@ -53,9 +69,37 @@ async function httpRequest(url, options, redirectCount = 0) {
             reject(new Error('Request timeout'));
         });
         if (options.body) {
-            req.write(options.body);
+            const bodyBuffer = Buffer.isBuffer(options.body) ? options.body : Buffer.from(options.body);
+            const totalBytes = bodyBuffer.length;
+            const chunkSize = 64 * 1024;
+            let bytesSent = 0;
+            const writeChunk = () => {
+                while (bytesSent < totalBytes) {
+                    const end = Math.min(bytesSent + chunkSize, totalBytes);
+                    const chunk = bodyBuffer.subarray(bytesSent, end);
+                    const canContinue = req.write(chunk);
+                    bytesSent += chunk.length;
+                    if (options.onProgress) {
+                        options.onProgress(bytesSent, totalBytes);
+                    }
+                    if (!canContinue) {
+                        req.once('drain', writeChunk);
+                        return;
+                    }
+                }
+                if (options.onUploadComplete) {
+                    options.onUploadComplete();
+                }
+                req.end();
+            };
+            writeChunk();
+        }
+        else {
+            if (options.onUploadComplete) {
+                options.onUploadComplete();
+            }
+            req.end();
         }
-        req.end();
     });
 }
 export async function pinToIPFS(data, name) {
@@ -141,6 +185,9 @@ export async function pinToIPFS(data, name) {
         if (!cid) {
             throw new Error(`Failed to extract CID from pinning response: ${JSON.stringify(result)}`);
         }
+        if (isCIDv0(cid)) {
+            cid = cidV0toV1(cid);
+        }
         return {
             cid,
             size: data.length,
@@ -204,6 +251,73 @@ export function isValidCid(cid) {
     }
     return false;
 }
+export function isCIDv0(cid) {
+    return cid.startsWith('Qm') && cid.length === 46;
+}
+export function isCIDv1(cid) {
+    return cid.startsWith('baf') && cid.length >= 50;
+}
+const BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+const BASE32_ALPHABET = 'abcdefghijklmnopqrstuvwxyz234567';
+function decodeBase58(str) {
+    const bytes = [];
+    for (const char of str) {
+        const value = BASE58_ALPHABET.indexOf(char);
+        if (value === -1) {
+            throw new Error(`Invalid base58 character: ${char}`);
+        }
+        let carry = value;
+        for (let i = 0; i < bytes.length; i++) {
+            carry += bytes[i] * 58;
+            bytes[i] = carry & 0xff;
+            carry >>= 8;
+        }
+        while (carry > 0) {
+            bytes.push(carry & 0xff);
+            carry >>= 8;
+        }
+    }
+    for (const char of str) {
+        if (char === '1') {
+            bytes.push(0);
+        }
+        else {
+            break;
+        }
+    }
+    return new Uint8Array(bytes.reverse());
+}
+function encodeBase32(bytes) {
+    let result = '';
+    let bits = 0;
+    let value = 0;
+    for (const byte of bytes) {
+        value = (value << 8) | byte;
+        bits += 8;
+        while (bits >= 5) {
+            bits -= 5;
+            result += BASE32_ALPHABET[(value >> bits) & 0x1f];
+        }
+    }
+    if (bits > 0) {
+        result += BASE32_ALPHABET[(value << (5 - bits)) & 0x1f];
+    }
+    return result;
+}
+export function cidV0toV1(cidv0) {
+    if (!isCIDv0(cidv0)) {
+        return cidv0;
+    }
+    const multihash = decodeBase58(cidv0);
+    if (multihash[0] !== 0x12 || multihash[1] !== 0x20 || multihash.length !== 34) {
+        throw new Error('Invalid CIDv0: not a valid sha2-256 multihash');
+    }
+    const cidv1Bytes = new Uint8Array(2 + multihash.length);
+    cidv1Bytes[0] = 0x01;
+    cidv1Bytes[1] = 0x70;
+    cidv1Bytes.set(multihash, 2);
+    return 'b' + encodeBase32(cidv1Bytes);
+}
 export async function downloadPlugin(cid, outputPath) {
     const result = await fetchFromIPFS(cid);
     fs.writeFileSync(outputPath, result.data);
@@ -257,74 +371,176 @@ function getMimeType(filePath) {
     };
     return mimeTypes[ext] || 'application/octet-stream';
 }
-export async function uploadDirectory(dirPath, wrapWithDirectory = true) {
-    try {
-        const config = loadConfig();
-        const endpoint = config.ipfsPinningEndpoint;
-        if (!endpoint) {
-            throw new Error('IPFS pinning endpoint not configured. Run `opnet config set ipfsPinningEndpoint <url>`');
-        }
-        const files = getAllFiles(dirPath);
-        if (files.length === 0) {
-            throw new Error('Directory is empty');
-        }
+function generateSessionId() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+async function mfsCall(endpoint, apiPath, params, body, headers, maxRetries = 3) {
+    const url = new URL(endpoint);
+    url.pathname = apiPath;
+    for (const [key, value] of Object.entries(params)) {
+        url.searchParams.set(key, value);
+    }
+    const reqHeaders = {
+        ...headers,
+    };
+    let formBody;
+    if (body) {
         const boundary = '----FormBoundary' + Math.random().toString(36).substring(2);
         const formParts = [];
-        let totalSize = 0;
-        for (const file of files) {
-            const data = fs.readFileSync(file.fullPath);
-            totalSize += data.length;
-            const mimeType = getMimeType(file.path);
-            formParts.push(Buffer.from(`--${boundary}\r\n` +
-                `Content-Disposition: form-data; name="file"; filename="${file.path}"\r\n` +
-                `Content-Type: ${mimeType}\r\n\r\n`));
-            formParts.push(data);
-            formParts.push(Buffer.from('\r\n'));
-        }
-        formParts.push(Buffer.from(`--${boundary}--\r\n`));
-        const body = Buffer.concat(formParts);
-        const headers = {
-            'Content-Type': `multipart/form-data; boundary=${boundary}`,
-            'Content-Length': body.length.toString(),
-        };
-        if (config.ipfsPinningApiKey) {
-            headers['Authorization'] = `Bearer ${config.ipfsPinningApiKey}`;
-        }
-        const url = new URL(endpoint);
-        if (wrapWithDirectory) {
-            url.searchParams.set('wrap-with-directory', 'true');
+        formParts.push(Buffer.from(`--${boundary}\r\n` +
+            `Content-Disposition: form-data; name="file"\r\n` +
+            `Content-Type: application/octet-stream\r\n\r\n`));
+        formParts.push(body);
+        formParts.push(Buffer.from(`\r\n--${boundary}--\r\n`));
+        formBody = Buffer.concat(formParts);
+        reqHeaders['Content-Type'] = `multipart/form-data; boundary=${boundary}`;
+        reqHeaders['Content-Length'] = formBody.length.toString();
+    }
+    let lastError;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            return await httpRequest(url.toString(), {
+                method: 'POST',
+                headers: reqHeaders,
+                body: formBody,
+                timeout: body ? 120000 : 60000,
+                followRedirect: true,
+            });
         }
-        url.searchParams.set('cid-version', '1');
-        const response = await httpRequest(url.toString(), {
-            method: 'POST',
-            headers,
-            body,
-            timeout: 300000,
-            followRedirect: true,
-        });
-        const lines = response.toString().trim().split('\n');
-        let rootCid;
-        for (const line of lines) {
-            if (!line.trim())
+        catch (e) {
+            lastError = e instanceof Error ? e : new Error(String(e));
+            if (lastError.message.includes('429')) {
+                const backoffMs = Math.pow(2, attempt) * 1000;
+                await sleep(backoffMs);
                 continue;
-            const result = JSON.parse(line);
-            if (result.Hash && (result.Name === '' || !result.Name)) {
-                rootCid = result.Hash;
             }
-            else if (result.Hash && !rootCid) {
-                rootCid = result.Hash;
+            throw lastError;
+        }
+    }
+    throw lastError || new Error('Max retries exceeded');
+}
+export async function uploadDirectory(dirPath, _wrapWithDirectory = true) {
+    const config = loadConfig();
+    const endpoint = config.ipfsPinningEndpoint;
+    if (!endpoint) {
+        throw new Error('IPFS pinning endpoint not configured. Run `opnet config set ipfsPinningEndpoint <url>`');
+    }
+    const baseUrl = endpoint.replace(/\/api\/v0\/add\/?$/, '');
+    const files = getAllFiles(dirPath);
+    if (files.length === 0) {
+        throw new Error('Directory is empty');
+    }
+    let totalSize = 0;
+    for (const file of files) {
+        const stat = fs.statSync(file.fullPath);
+        totalSize += stat.size;
+    }
+    const sessionId = generateSessionId();
+    const mfsPath = `/uploads/${sessionId}`;
+    const headers = {};
+    if (config.ipfsPinningApiKey) {
+        headers['Authorization'] = `Bearer ${config.ipfsPinningApiKey}`;
+    }
+    const formatBytes = (bytes) => {
+        if (bytes < 1024)
+            return `${bytes} B`;
+        if (bytes < 1024 * 1024)
+            return `${(bytes / 1024).toFixed(1)} KB`;
+        return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+    };
+    let uploadedBytes = 0;
+    let spinner = null;
+    try {
+        await mfsCall(baseUrl, '/api/v0/files/mkdir', {
+            arg: mfsPath,
+            parents: 'true',
+        }, undefined, headers);
+        for (let i = 0; i < files.length; i++) {
+            const file = files[i];
+            const data = fs.readFileSync(file.fullPath);
+            const fileMfsPath = `${mfsPath}/${file.path}`;
+            const parentDir = fileMfsPath.substring(0, fileMfsPath.lastIndexOf('/'));
+            if (parentDir !== mfsPath) {
+                await mfsCall(baseUrl, '/api/v0/files/mkdir', {
+                    arg: parentDir,
+                    parents: 'true',
+                }, undefined, headers);
             }
+            await mfsCall(baseUrl, '/api/v0/files/write', {
+                arg: fileMfsPath,
+                create: 'true',
+                parents: 'true',
+                truncate: 'true',
+            }, data, headers);
+            uploadedBytes += data.length;
+            const percent = Math.round((uploadedBytes / totalSize) * 100);
+            const barWidth = 30;
+            const filled = Math.round((percent / 100) * barWidth);
+            const empty = barWidth - filled;
+            const bar = '█'.repeat(filled) + '░'.repeat(empty);
+            process.stdout.write(`\r  Uploading: [${bar}] ${percent}% - ${i + 1}/${files.length} files (${formatBytes(uploadedBytes)}/${formatBytes(totalSize)})`);
         }
-        if (!rootCid) {
-            throw new Error(`Failed to extract root CID from response`);
+        process.stdout.write('\n');
+        spinner = ora({
+            text: 'Getting directory CID...',
+            spinner: 'dots',
+        }).start();
+        const statResponse = await mfsCall(baseUrl, '/api/v0/files/stat', {
+            arg: mfsPath,
+            hash: 'true',
+            'cid-base': 'base32',
+        }, undefined, headers);
+        const statResult = JSON.parse(statResponse.toString());
+        let cid = statResult.Hash;
+        if (!cid) {
+            spinner.fail('Failed to get directory CID');
+            throw new Error('MFS stat did not return a Hash');
+        }
+        if (isCIDv0(cid)) {
+            cid = cidV0toV1(cid);
+        }
+        spinner.text = 'Pinning content...';
+        try {
+            await mfsCall(baseUrl, '/api/v0/pin/add', {
+                arg: cid,
+            }, undefined, headers);
+        }
+        catch {
+        }
+        spinner.succeed(`Upload complete: ${cid}`);
+        try {
+            await mfsCall(baseUrl, '/api/v0/files/rm', {
+                arg: mfsPath,
+                recursive: 'true',
+            }, undefined, headers);
+        }
+        catch {
         }
         return {
-            cid: rootCid,
+            cid,
             files: files.length,
             totalSize,
         };
     }
     catch (e) {
+        if (spinner) {
+            spinner.fail('Upload failed');
+        }
+        try {
+            await mfsCall(baseUrl, '/api/v0/files/rm', {
+                arg: mfsPath,
+                recursive: 'true',
+            }, undefined, headers);
+        }
+        catch {
+        }
         throw new Error(`IPFS directory upload failed: ${e instanceof Error ? e.message : String(e)}`);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@btc-vision/cli",
-    "version": "1.0.8",
+    "version": "1.0.10",
     "type": "module",
     "description": "CLI for the OPNet plugin ecosystem - scaffolding, compilation, signing, and registry interaction",
     "author": "OP_NET",