kynjal-cli 3.1.3 → 4.0.0

package/dist/src/transfer/ipfs/upload.js

@@ -5,6 +5,42 @@
  * @module @claude-flow/cli/transfer/ipfs/upload
  * @version 3.0.0
  */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 import * as crypto from 'crypto';
 /**
  * Get web3.storage token from environment or config
@@ -19,15 +55,15 @@ function getWeb3StorageToken() {
  * Uses CIDv1 with dag-pb codec and sha2-256 multihash
  */
 function generateDemoCID(content) {
-    const hash = crypto.createHash('sha256').update(content).digest();
+    var hash = crypto.createHash('sha256').update(content).digest();
     // CIDv1 with dag-pb codec and sha2-256 multihash
-    const prefix = Buffer.from([0x01, 0x70, 0x12, 0x20]);
-    const cidBytes = Buffer.concat([prefix, hash]);
+    var prefix = Buffer.from([0x01, 0x70, 0x12, 0x20]);
+    var cidBytes = Buffer.concat([prefix, hash]);
     // Base32 encode
-    const base32Chars = 'abcdefghijklmnopqrstuvwxyz234567';
-    let result = 'bafybei';
-    for (let i = 0; i < 44; i++) {
-        const byte = cidBytes[i % cidBytes.length] || 0;
+    var base32Chars = 'abcdefghijklmnopqrstuvwxyz234567';
+    var result = 'bafybei';
+    for (var i = 0; i < 44; i++) {
+        var byte = cidBytes[i % cidBytes.length] || 0;
         result += base32Chars[byte % 32];
     }
     return result;
@@ -35,98 +71,123 @@ function generateDemoCID(content) {
 /**
  * Upload to web3.storage (real IPFS)
  */
-async function uploadToWeb3Storage(content, options) {
-    const token = options.apiKey || getWeb3StorageToken();
-    if (!token) {
-        throw new Error('Web3.storage token not found. Set WEB3_STORAGE_TOKEN environment variable.\n' +
-            'Get a free token at: https://web3.storage');
-    }
-    const endpoint = options.endpoint || 'https://api.web3.storage';
-    const name = options.name || 'pattern.cfp.json';
-    console.log(`[IPFS] Uploading ${content.length} bytes to web3.storage...`);
-    // Create FormData-like body for upload
-    const boundary = '----WebKitFormBoundary' + crypto.randomBytes(16).toString('hex');
-    const body = Buffer.concat([
-        Buffer.from(`--${boundary}\r\n`),
-        Buffer.from(`Content-Disposition: form-data; name="file"; filename="${name}"\r\n`),
-        Buffer.from(`Content-Type: application/json\r\n\r\n`),
-        content,
-        Buffer.from(`\r\n--${boundary}--\r\n`),
-    ]);
-    const response = await fetch(`${endpoint}/upload`, {
-        method: 'POST',
-        headers: {
-            'Authorization': `Bearer ${token}`,
-            'Content-Type': `multipart/form-data; boundary=${boundary}`,
-        },
-        body,
+function uploadToWeb3Storage(content, options) {
+    return __awaiter(this, void 0, Promise, function () {
+        var token, endpoint, name, boundary, body, response, error, result, cid, gateway;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    token = options.apiKey || getWeb3StorageToken();
+                    if (!token) {
+                        throw new Error('Web3.storage token not found. Set WEB3_STORAGE_TOKEN environment variable.\n' +
+                            'Get a free token at: https://web3.storage');
+                    }
+                    endpoint = options.endpoint || 'https://api.web3.storage';
+                    name = options.name || 'pattern.cfp.json';
+                    console.log("[IPFS] Uploading " + content.length + " bytes to web3.storage...");
+                    boundary = '----WebKitFormBoundary' + crypto.randomBytes(16).toString('hex');
+                    body = Buffer.concat([
+                        Buffer.from("--" + boundary + "\r\n"),
+                        Buffer.from("Content-Disposition: form-data; name=\"file\"; filename=\"" + name + "\"\r\n"),
+                        Buffer.from("Content-Type: application/json\r\n\r\n"),
+                        content,
+                        Buffer.from("\r\n--" + boundary + "--\r\n"),
+                    ]);
+                    return [4 /*yield*/, fetch(endpoint + "/upload", {
+                            method: 'POST',
+                            headers: {
+                                'Authorization': "Bearer " + token,
+                                'Content-Type': "multipart/form-data; boundary=" + boundary
+                            },
+                            body: body
+                        })];
+                case 1:
+                    response = _a.sent();
+                    if (!!response.ok) return [3 /*break*/, 3];
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    error = _a.sent();
+                    throw new Error("Web3.storage upload failed: " + response.status + " " + error);
+                case 3: return [4 /*yield*/, response.json()];
+                case 4:
+                    result = _a.sent();
+                    cid = result.cid;
+                    gateway = options.gateway || 'https://w3s.link';
+                    console.log("[IPFS] Upload complete!");
+                    console.log("[IPFS] CID: " + cid);
+                    return [2 /*return*/, {
+                            cid: cid,
+                            size: content.length,
+                            gateway: gateway,
+                            pinnedAt: new Date().toISOString(),
+                            url: gateway + "/ipfs/" + cid
+                        }];
+            }
+        });
     });
-    if (!response.ok) {
-        const error = await response.text();
-        throw new Error(`Web3.storage upload failed: ${response.status} ${error}`);
-    }
-    const result = await response.json();
-    const cid = result.cid;
-    const gateway = options.gateway || 'https://w3s.link';
-    console.log(`[IPFS] Upload complete!`);
-    console.log(`[IPFS] CID: ${cid}`);
-    return {
-        cid,
-        size: content.length,
-        gateway,
-        pinnedAt: new Date().toISOString(),
-        url: `${gateway}/ipfs/${cid}`,
-    };
 }
 /**
  * Upload to Pinata
  */
-async function uploadToPinata(content, options) {
-    const apiKey = options.apiKey || process.env.PINATA_API_KEY;
-    const apiSecret = options.apiSecret || process.env.PINATA_API_SECRET;
-    if (!apiKey || !apiSecret) {
-        throw new Error('Pinata API credentials not found. Set PINATA_API_KEY and PINATA_API_SECRET.\n' +
-            'Get credentials at: https://pinata.cloud');
-    }
-    const name = options.name || 'pattern.cfp.json';
-    console.log(`[IPFS] Uploading ${content.length} bytes to Pinata...`);
-    const boundary = '----WebKitFormBoundary' + crypto.randomBytes(16).toString('hex');
-    const metadata = JSON.stringify({ name });
-    const body = Buffer.concat([
-        Buffer.from(`--${boundary}\r\n`),
-        Buffer.from(`Content-Disposition: form-data; name="pinataMetadata"\r\n\r\n`),
-        Buffer.from(`${metadata}\r\n`),
-        Buffer.from(`--${boundary}\r\n`),
-        Buffer.from(`Content-Disposition: form-data; name="file"; filename="${name}"\r\n`),
-        Buffer.from(`Content-Type: application/json\r\n\r\n`),
-        content,
-        Buffer.from(`\r\n--${boundary}--\r\n`),
-    ]);
-    const response = await fetch('https://api.pinata.cloud/pinning/pinFileToIPFS', {
-        method: 'POST',
-        headers: {
-            'pinata_api_key': apiKey,
-            'pinata_secret_api_key': apiSecret,
-            'Content-Type': `multipart/form-data; boundary=${boundary}`,
-        },
-        body,
+function uploadToPinata(content, options) {
+    return __awaiter(this, void 0, Promise, function () {
+        var apiKey, apiSecret, name, boundary, metadata, body, response, error, result, cid, gateway;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    apiKey = options.apiKey || process.env.PINATA_API_KEY;
+                    apiSecret = options.apiSecret || process.env.PINATA_API_SECRET;
+                    if (!apiKey || !apiSecret) {
+                        throw new Error('Pinata API credentials not found. Set PINATA_API_KEY and PINATA_API_SECRET.\n' +
+                            'Get credentials at: https://pinata.cloud');
+                    }
+                    name = options.name || 'pattern.cfp.json';
+                    console.log("[IPFS] Uploading " + content.length + " bytes to Pinata...");
+                    boundary = '----WebKitFormBoundary' + crypto.randomBytes(16).toString('hex');
+                    metadata = JSON.stringify({ name: name });
+                    body = Buffer.concat([
+                        Buffer.from("--" + boundary + "\r\n"),
+                        Buffer.from("Content-Disposition: form-data; name=\"pinataMetadata\"\r\n\r\n"),
+                        Buffer.from(metadata + "\r\n"),
+                        Buffer.from("--" + boundary + "\r\n"),
+                        Buffer.from("Content-Disposition: form-data; name=\"file\"; filename=\"" + name + "\"\r\n"),
+                        Buffer.from("Content-Type: application/json\r\n\r\n"),
+                        content,
+                        Buffer.from("\r\n--" + boundary + "--\r\n"),
+                    ]);
+                    return [4 /*yield*/, fetch('https://api.pinata.cloud/pinning/pinFileToIPFS', {
+                            method: 'POST',
+                            headers: {
+                                'pinata_api_key': apiKey,
+                                'pinata_secret_api_key': apiSecret,
+                                'Content-Type': "multipart/form-data; boundary=" + boundary
+                            },
+                            body: body
+                        })];
+                case 1:
+                    response = _a.sent();
+                    if (!!response.ok) return [3 /*break*/, 3];
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    error = _a.sent();
+                    throw new Error("Pinata upload failed: " + response.status + " " + error);
+                case 3: return [4 /*yield*/, response.json()];
+                case 4:
+                    result = _a.sent();
+                    cid = result.IpfsHash;
+                    gateway = options.gateway || 'https://gateway.pinata.cloud';
+                    console.log("[IPFS] Upload complete!");
+                    console.log("[IPFS] CID: " + cid);
+                    return [2 /*return*/, {
+                            cid: cid,
+                            size: content.length,
+                            gateway: gateway,
+                            pinnedAt: new Date().toISOString(),
+                            url: gateway + "/ipfs/" + cid
+                        }];
+            }
+        });
     });
-    if (!response.ok) {
-        const error = await response.text();
-        throw new Error(`Pinata upload failed: ${response.status} ${error}`);
-    }
-    const result = await response.json();
-    const cid = result.IpfsHash;
-    const gateway = options.gateway || 'https://gateway.pinata.cloud';
-    console.log(`[IPFS] Upload complete!`);
-    console.log(`[IPFS] CID: ${cid}`);
-    return {
-        cid,
-        size: content.length,
-        gateway,
-        pinnedAt: new Date().toISOString(),
-        url: `${gateway}/ipfs/${cid}`,
-    };
 }
 /**
  * Upload content to IPFS
@@ -137,230 +198,313 @@ async function uploadToPinata(content, options) {
  * - Pinata (PINATA_API_KEY + PINATA_API_SECRET) - Free 1GB tier
  * - Demo mode (generates deterministic CIDs when no credentials)
  */
-export async function uploadToIPFS(content, options = {}) {
-    const { pin = true, pinningService, gateway = 'https://w3s.link', name = 'pattern', } = options;
-    // Check environment variables
-    const localIPFS = process.env.IPFS_API_URL;
-    const web3Token = getWeb3StorageToken();
-    const pinataKey = process.env.PINATA_API_KEY;
-    // 1. Try local/custom IPFS node first (FREE - your own node)
-    if (localIPFS || pinningService === 'local') {
-        try {
-            const isAvailable = await checkLocalIPFSNode();
-            if (isAvailable) {
-                return await uploadToLocalIPFS(content, options);
-            }
-            else {
-                console.warn(`[IPFS] Local node at ${localIPFS || 'localhost:5001'} not available`);
+export function uploadToIPFS(content, options) {
+    if (options === void 0) { options = {}; }
+    return __awaiter(this, void 0, Promise, function () {
+        var _a, pin, pinningService, _b, gateway, _c, name, localIPFS, web3Token, pinataKey, isAvailable, error_1, error_2, error_3, cid, size, result;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    _a = options.pin, pin = _a === void 0 ? true : _a, pinningService = options.pinningService, _b = options.gateway, gateway = _b === void 0 ? 'https://w3s.link' : _b, _c = options.name, name = _c === void 0 ? 'pattern' : _c;
+                    localIPFS = process.env.IPFS_API_URL;
+                    web3Token = getWeb3StorageToken();
+                    pinataKey = process.env.PINATA_API_KEY;
+                    if (!(localIPFS || pinningService === 'local')) return [3 /*break*/, 7];
+                    _d.label = 1;
+                case 1:
+                    _d.trys.push([1, 6, , 7]);
+                    return [4 /*yield*/, checkLocalIPFSNode()];
+                case 2:
+                    isAvailable = _d.sent();
+                    if (!isAvailable) return [3 /*break*/, 4];
+                    return [4 /*yield*/, uploadToLocalIPFS(content, options)];
+                case 3: return [2 /*return*/, _d.sent()];
+                case 4:
+                    console.warn("[IPFS] Local node at " + (localIPFS || 'localhost:5001') + " not available");
+                    _d.label = 5;
+                case 5: return [3 /*break*/, 7];
+                case 6:
+                    error_1 = _d.sent();
+                    console.warn("[IPFS] Local IPFS upload failed: " + error_1);
+                    return [3 /*break*/, 7];
+                case 7:
+                    if (!(pinningService === 'pinata' || (pinataKey && !web3Token))) return [3 /*break*/, 11];
+                    _d.label = 8;
+                case 8:
+                    _d.trys.push([8, 10, , 11]);
+                    return [4 /*yield*/, uploadToPinata(content, options)];
+                case 9: return [2 /*return*/, _d.sent()];
+                case 10:
+                    error_2 = _d.sent();
+                    console.warn("[IPFS] Pinata upload failed: " + error_2);
+                    return [3 /*break*/, 11];
+                case 11:
+                    if (!(web3Token || pinningService === 'web3storage')) return [3 /*break*/, 15];
+                    _d.label = 12;
+                case 12:
+                    _d.trys.push([12, 14, , 15]);
+                    return [4 /*yield*/, uploadToWeb3Storage(content, options)];
+                case 13: return [2 /*return*/, _d.sent()];
+                case 14:
+                    error_3 = _d.sent();
+                    console.warn("[IPFS] Web3.storage upload failed: " + error_3);
+                    return [3 /*break*/, 15];
+                case 15:
+                    // Fall back to demo mode - WARN user prominently
+                    console.warn("\u26A0 [IPFS] DEMO MODE - No IPFS credentials configured");
+                    console.warn("\u26A0 [IPFS] Content will NOT be uploaded to decentralized storage");
+                    console.warn("\u26A0 [IPFS] To enable real uploads, configure one of:");
+                    console.warn("\u26A0 [IPFS]   - IPFS_API_URL=http://YOUR_NODE:5001 (FREE - your own node)");
+                    console.warn("\u26A0 [IPFS]   - WEB3_STORAGE_TOKEN (free 5GB at web3.storage)");
+                    console.warn("\u26A0 [IPFS]   - PINATA_API_KEY + PINATA_SECRET_KEY (free tier available)");
+                    cid = generateDemoCID(content);
+                    size = content.length;
+                    console.log("[IPFS] Demo upload: " + size + " bytes");
+                    console.log("[IPFS] Name: " + name);
+                    result = {
+                        cid: cid,
+                        size: size,
+                        gateway: gateway,
+                        url: gateway + "/ipfs/" + cid
+                    };
+                    if (pin) {
+                        result.pinnedAt = new Date().toISOString();
+                        console.log("[IPFS] Demo pinned at: " + result.pinnedAt);
+                    }
+                    console.log("[IPFS] Demo CID: " + cid);
+                    console.log("[IPFS] Demo URL: " + result.url);
+                    return [2 /*return*/, result];
             }
-        }
-        catch (error) {
-            console.warn(`[IPFS] Local IPFS upload failed: ${error}`);
-        }
-    }
-    // 2. Try Pinata
-    if (pinningService === 'pinata' || (pinataKey && !web3Token)) {
-        try {
-            return await uploadToPinata(content, options);
-        }
-        catch (error) {
-            console.warn(`[IPFS] Pinata upload failed: ${error}`);
-        }
-    }
-    // 3. Try Web3.storage
-    if (web3Token || pinningService === 'web3storage') {
-        try {
-            return await uploadToWeb3Storage(content, options);
-        }
-        catch (error) {
-            console.warn(`[IPFS] Web3.storage upload failed: ${error}`);
-        }
-    }
-    // Fall back to demo mode - WARN user prominently
-    console.warn(`⚠ [IPFS] DEMO MODE - No IPFS credentials configured`);
-    console.warn(`⚠ [IPFS] Content will NOT be uploaded to decentralized storage`);
-    console.warn(`⚠ [IPFS] To enable real uploads, configure one of:`);
-    console.warn(`⚠ [IPFS]   - IPFS_API_URL=http://YOUR_NODE:5001 (FREE - your own node)`);
-    console.warn(`⚠ [IPFS]   - WEB3_STORAGE_TOKEN (free 5GB at web3.storage)`);
-    console.warn(`⚠ [IPFS]   - PINATA_API_KEY + PINATA_SECRET_KEY (free tier available)`);
-    const cid = generateDemoCID(content);
-    const size = content.length;
-    console.log(`[IPFS] Demo upload: ${size} bytes`);
-    console.log(`[IPFS] Name: ${name}`);
-    // Simulate upload delay
-    await new Promise(resolve => setTimeout(resolve, 500));
-    const result = {
-        cid,
-        size,
-        gateway,
-        url: `${gateway}/ipfs/${cid}`,
-    };
-    if (pin) {
-        result.pinnedAt = new Date().toISOString();
-        console.log(`[IPFS] Demo pinned at: ${result.pinnedAt}`);
-    }
-    console.log(`[IPFS] Demo CID: ${cid}`);
-    console.log(`[IPFS] Demo URL: ${result.url}`);
-    return result;
+        });
+    });
 }
 /**
  * Pin content by CID
  */
-export async function pinContent(cid, options = {}) {
-    const web3Token = getWeb3StorageToken();
-    const pinataKey = process.env.PINATA_API_KEY;
-    // Real pinning with Pinata
-    if (pinataKey && options.service !== 'web3storage') {
-        try {
-            const pinataSecret = process.env.PINATA_API_SECRET;
-            const response = await fetch('https://api.pinata.cloud/pinning/pinByHash', {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'pinata_api_key': pinataKey,
-                    'pinata_secret_api_key': pinataSecret || '',
-                },
-                body: JSON.stringify({
-                    hashToPin: cid,
-                    pinataMetadata: { name: options.name || cid },
-                }),
-            });
-            if (response.ok) {
-                const pinnedAt = new Date().toISOString();
-                console.log(`[IPFS] Pinned ${cid} via Pinata at ${pinnedAt}`);
-                return { success: true, pinnedAt };
+export function pinContent(cid, options) {
+    if (options === void 0) { options = {}; }
+    return __awaiter(this, void 0, Promise, function () {
+        var web3Token, pinataKey, pinataSecret, response, pinnedAt_1, error_4, pinnedAt;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    web3Token = getWeb3StorageToken();
+                    pinataKey = process.env.PINATA_API_KEY;
+                    if (!(pinataKey && options.service !== 'web3storage')) return [3 /*break*/, 4];
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    pinataSecret = process.env.PINATA_API_SECRET;
+                    return [4 /*yield*/, fetch('https://api.pinata.cloud/pinning/pinByHash', {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/json',
+                                'pinata_api_key': pinataKey,
+                                'pinata_secret_api_key': pinataSecret || ''
+                            },
+                            body: JSON.stringify({
+                                hashToPin: cid,
+                                pinataMetadata: { name: options.name || cid }
+                            })
+                        })];
+                case 2:
+                    response = _a.sent();
+                    if (response.ok) {
+                        pinnedAt_1 = new Date().toISOString();
+                        console.log("[IPFS] Pinned " + cid + " via Pinata at " + pinnedAt_1);
+                        return [2 /*return*/, { success: true, pinnedAt: pinnedAt_1 }];
+                    }
+                    return [3 /*break*/, 4];
+                case 3:
+                    error_4 = _a.sent();
+                    console.warn("[IPFS] Pinata pin failed: " + error_4);
+                    return [3 /*break*/, 4];
+                case 4:
+                    pinnedAt = new Date().toISOString();
+                    console.log("[IPFS] Demo pinning " + cid + "...");
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 300); })];
+                case 5:
+                    _a.sent();
+                    console.log("[IPFS] Demo pinned at " + pinnedAt);
+                    return [2 /*return*/, { success: true, pinnedAt: pinnedAt }];
             }
-        }
-        catch (error) {
-            console.warn(`[IPFS] Pinata pin failed: ${error}`);
-        }
-    }
-    // Demo mode
-    const pinnedAt = new Date().toISOString();
-    console.log(`[IPFS] Demo pinning ${cid}...`);
-    await new Promise(resolve => setTimeout(resolve, 300));
-    console.log(`[IPFS] Demo pinned at ${pinnedAt}`);
-    return { success: true, pinnedAt };
+        });
+    });
 }
 /**
  * Unpin content by CID
  */
-export async function unpinContent(cid, options = {}) {
-    const pinataKey = process.env.PINATA_API_KEY;
-    // Real unpinning with Pinata
-    if (pinataKey) {
-        try {
-            const pinataSecret = process.env.PINATA_API_SECRET;
-            const response = await fetch(`https://api.pinata.cloud/pinning/unpin/${cid}`, {
-                method: 'DELETE',
-                headers: {
-                    'pinata_api_key': pinataKey,
-                    'pinata_secret_api_key': pinataSecret || '',
-                },
-            });
-            if (response.ok) {
-                console.log(`[IPFS] Unpinned ${cid} from Pinata`);
-                return { success: true };
+export function unpinContent(cid, options) {
+    if (options === void 0) { options = {}; }
+    return __awaiter(this, void 0, Promise, function () {
+        var pinataKey, pinataSecret, response, error_5;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    pinataKey = process.env.PINATA_API_KEY;
+                    if (!pinataKey) return [3 /*break*/, 4];
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    pinataSecret = process.env.PINATA_API_SECRET;
+                    return [4 /*yield*/, fetch("https://api.pinata.cloud/pinning/unpin/" + cid, {
+                            method: 'DELETE',
+                            headers: {
+                                'pinata_api_key': pinataKey,
+                                'pinata_secret_api_key': pinataSecret || ''
+                            }
+                        })];
+                case 2:
+                    response = _a.sent();
+                    if (response.ok) {
+                        console.log("[IPFS] Unpinned " + cid + " from Pinata");
+                        return [2 /*return*/, { success: true }];
+                    }
+                    return [3 /*break*/, 4];
+                case 3:
+                    error_5 = _a.sent();
+                    console.warn("[IPFS] Pinata unpin failed: " + error_5);
+                    return [3 /*break*/, 4];
+                case 4:
+                    // Demo mode
+                    console.log("[IPFS] Demo unpinning " + cid + "...");
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 200); })];
+                case 5:
+                    _a.sent();
+                    console.log("[IPFS] Demo unpinned");
+                    return [2 /*return*/, { success: true }];
             }
-        }
-        catch (error) {
-            console.warn(`[IPFS] Pinata unpin failed: ${error}`);
-        }
-    }
-    // Demo mode
-    console.log(`[IPFS] Demo unpinning ${cid}...`);
-    await new Promise(resolve => setTimeout(resolve, 200));
-    console.log(`[IPFS] Demo unpinned`);
-    return { success: true };
+        });
+    });
 }
 /**
  * Check if content exists on IPFS
  */
-export async function checkContent(cid, gateway = 'https://w3s.link') {
-    console.log(`[IPFS] Checking ${cid}...`);
-    try {
-        const response = await fetch(`${gateway}/ipfs/${cid}`, {
-            method: 'HEAD',
+export function checkContent(cid, gateway) {
+    if (gateway === void 0) { gateway = 'https://w3s.link'; }
+    return __awaiter(this, void 0, Promise, function () {
+        var response, size, error_6;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    console.log("[IPFS] Checking " + cid + "...");
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, fetch(gateway + "/ipfs/" + cid, {
+                            method: 'HEAD'
+                        })];
+                case 2:
+                    response = _a.sent();
+                    if (response.ok) {
+                        size = parseInt(response.headers.get('content-length') || '0', 10);
+                        console.log("[IPFS] Content exists, size: " + size);
+                        return [2 /*return*/, { exists: true, size: size }];
+                    }
+                    return [3 /*break*/, 4];
+                case 3:
+                    error_6 = _a.sent();
+                    console.log("[IPFS] Content check failed: " + error_6);
+                    return [3 /*break*/, 4];
+                case 4: return [2 /*return*/, { exists: false }];
+            }
         });
-        if (response.ok) {
-            const size = parseInt(response.headers.get('content-length') || '0', 10);
-            console.log(`[IPFS] Content exists, size: ${size}`);
-            return { exists: true, size };
-        }
-    }
-    catch (error) {
-        console.log(`[IPFS] Content check failed: ${error}`);
-    }
-    return { exists: false };
+    });
 }
 /**
  * Get gateway URL for CID
  */
-export function getGatewayURL(cid, gateway = 'https://w3s.link') {
-    return `${gateway}/ipfs/${cid}`;
+export function getGatewayURL(cid, gateway) {
+    if (gateway === void 0) { gateway = 'https://w3s.link'; }
+    return gateway + "/ipfs/" + cid;
 }
 /**
  * Get IPNS URL for name
  */
-export function getIPNSURL(name, gateway = 'https://w3s.link') {
-    return `${gateway}/ipns/${name}`;
+export function getIPNSURL(name, gateway) {
+    if (gateway === void 0) { gateway = 'https://w3s.link'; }
+    return gateway + "/ipns/" + name;
 }
 /**
  * Upload to a local/custom IPFS node
  * Connect to your own IPFS daemon via HTTP API
  */
-async function uploadToLocalIPFS(content, options) {
-    const apiUrl = process.env.IPFS_API_URL || 'http://localhost:5001';
-    const name = options.name || 'pattern.cfp.json';
-    console.log(`[IPFS] Uploading ${content.length} bytes to ${apiUrl}...`);
-    const boundary = '----IPFSBoundary' + crypto.randomBytes(16).toString('hex');
-    const body = Buffer.concat([
-        Buffer.from(`--${boundary}\r\n`),
-        Buffer.from(`Content-Disposition: form-data; name="file"; filename="${name}"\r\n`),
-        Buffer.from(`Content-Type: application/json\r\n\r\n`),
-        content,
-        Buffer.from(`\r\n--${boundary}--\r\n`),
-    ]);
-    const response = await fetch(`${apiUrl}/api/v0/add?pin=${options.pin !== false}`, {
-        method: 'POST',
-        headers: {
-            'Content-Type': `multipart/form-data; boundary=${boundary}`,
-        },
-        body,
+function uploadToLocalIPFS(content, options) {
+    return __awaiter(this, void 0, Promise, function () {
+        var apiUrl, name, boundary, body, response, error, result, cid, gatewayUrl;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    apiUrl = process.env.IPFS_API_URL || 'http://localhost:5001';
+                    name = options.name || 'pattern.cfp.json';
+                    console.log("[IPFS] Uploading " + content.length + " bytes to " + apiUrl + "...");
+                    boundary = '----IPFSBoundary' + crypto.randomBytes(16).toString('hex');
+                    body = Buffer.concat([
+                        Buffer.from("--" + boundary + "\r\n"),
+                        Buffer.from("Content-Disposition: form-data; name=\"file\"; filename=\"" + name + "\"\r\n"),
+                        Buffer.from("Content-Type: application/json\r\n\r\n"),
+                        content,
+                        Buffer.from("\r\n--" + boundary + "--\r\n"),
+                    ]);
+                    return [4 /*yield*/, fetch(apiUrl + "/api/v0/add?pin=" + (options.pin !== false), {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': "multipart/form-data; boundary=" + boundary
+                            },
+                            body: body
+                        })];
+                case 1:
+                    response = _a.sent();
+                    if (!!response.ok) return [3 /*break*/, 3];
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    error = _a.sent();
+                    throw new Error("Local IPFS upload failed: " + response.status + " " + error);
+                case 3: return [4 /*yield*/, response.json()];
+                case 4:
+                    result = _a.sent();
+                    cid = result.Hash;
+                    gatewayUrl = process.env.IPFS_GATEWAY_URL || options.gateway || 'https://ipfs.io';
+                    console.log("[IPFS] Upload complete!");
+                    console.log("[IPFS] CID: " + cid);
+                    return [2 /*return*/, {
+                            cid: cid,
+                            size: content.length,
+                            gateway: gatewayUrl,
+                            pinnedAt: options.pin !== false ? new Date().toISOString() : undefined,
+                            url: gatewayUrl + "/ipfs/" + cid
+                        }];
+            }
+        });
     });
-    if (!response.ok) {
-        const error = await response.text();
-        throw new Error(`Local IPFS upload failed: ${response.status} ${error}`);
-    }
-    const result = await response.json();
-    const cid = result.Hash;
-    // Try to get external gateway URL if configured
-    const gatewayUrl = process.env.IPFS_GATEWAY_URL || options.gateway || 'https://ipfs.io';
-    console.log(`[IPFS] Upload complete!`);
-    console.log(`[IPFS] CID: ${cid}`);
-    return {
-        cid,
-        size: content.length,
-        gateway: gatewayUrl,
-        pinnedAt: options.pin !== false ? new Date().toISOString() : undefined,
-        url: `${gatewayUrl}/ipfs/${cid}`,
-    };
 }
 /**
  * Check if local IPFS node is available
  */
-async function checkLocalIPFSNode() {
-    const apiUrl = process.env.IPFS_API_URL || 'http://localhost:5001';
-    try {
-        const response = await fetch(`${apiUrl}/api/v0/id`, {
-            method: 'POST',
-            signal: AbortSignal.timeout(2000),
+function checkLocalIPFSNode() {
+    return __awaiter(this, void 0, Promise, function () {
+        var apiUrl, response, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    apiUrl = process.env.IPFS_API_URL || 'http://localhost:5001';
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, fetch(apiUrl + "/api/v0/id", {
+                            method: 'POST',
+                            signal: AbortSignal.timeout(2000)
+                        })];
+                case 2:
+                    response = _b.sent();
+                    return [2 /*return*/, response.ok];
+                case 3:
+                    _a = _b.sent();
+                    return [2 /*return*/, false];
+                case 4: return [2 /*return*/];
+            }
         });
-        return response.ok;
-    }
-    catch {
-        return false;
-    }
+    });
 }
 /**
  * Check if real IPFS credentials are available
@@ -372,29 +516,29 @@ export function hasIPFSCredentials() {
  * Get IPFS service status
  */
 export function getIPFSServiceStatus() {
-    const localIPFS = process.env.IPFS_API_URL;
-    const web3Token = getWeb3StorageToken();
-    const pinataKey = process.env.PINATA_API_KEY;
+    var localIPFS = process.env.IPFS_API_URL;
+    var web3Token = getWeb3StorageToken();
+    var pinataKey = process.env.PINATA_API_KEY;
     if (localIPFS) {
         return {
             service: 'local',
             configured: true,
-            message: `Local IPFS node configured at ${localIPFS} - FREE uploads enabled`,
-            apiUrl: localIPFS,
+            message: "Local IPFS node configured at " + localIPFS + " - FREE uploads enabled",
+            apiUrl: localIPFS
         };
     }
     if (web3Token) {
         return {
             service: 'web3storage',
             configured: true,
-            message: 'Web3.storage configured - real IPFS uploads enabled',
+            message: 'Web3.storage configured - real IPFS uploads enabled'
         };
     }
     if (pinataKey) {
         return {
             service: 'pinata',
             configured: true,
-            message: 'Pinata configured - real IPFS uploads enabled',
+            message: 'Pinata configured - real IPFS uploads enabled'
         };
     }
     return {
@@ -403,7 +547,7 @@ export function getIPFSServiceStatus() {
         message: 'No IPFS credentials - using demo mode. Options:\n' +
             '  1. IPFS_API_URL=http://YOUR_NODE:5001 (FREE - your own node)\n' +
             '  2. WEB3_STORAGE_TOKEN (free 5GB at web3.storage)\n' +
-            '  3. PINATA_API_KEY (free 1GB at pinata.cloud)',
+            '  3. PINATA_API_KEY (free 1GB at pinata.cloud)'
     };
 }
 /**