@btc-vision/cli 1.0.9 → 1.0.10

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) {
@@ -68,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) {
@@ -156,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,
@@ -219,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);
@@ -272,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.9",
+    "version": "1.0.10",
     "type": "module",
     "description": "CLI for the OPNet plugin ecosystem - scaffolding, compilation, signing, and registry interaction",
     "author": "OP_NET",