pinme 1.1.1 → 1.1.2

package/README.md

@@ -116,7 +116,7 @@ pinme rm
 pinme rm bafybeifdwyoz66u5czbbjvmmais5fzrzrolxbyiydqsbrxessndt3s6zdi
 ```
 
-**Note:** This action permanently removes content from the IPFS network. Make sure you have the correct IPFS hash before proceeding.
+**Note:** This action unpins the content from our IPFS node and deletes the ENS subdomain record. It does not ensure that the file is removed from the IPFS network.
 
 ### `list` / `ls`
 

package/dist/index.js

@@ -1485,7 +1485,7 @@ var import_chalk6 = __toESM(require("chalk"));
 var import_figlet3 = __toESM(require("figlet"));
 
 // package.json
-var version = "1.1.1";
+var version = "1.1.2";
 
 // bin/upload.ts
 var import_path5 = __toESM(require("path"));
@@ -4370,7 +4370,7 @@ var import_chalk2 = __toESM(require("chalk"));
 // bin/utils/uploadLimits.ts
 var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
-var FILE_SIZE_LIMIT = parseInt("20", 10) * 1024 * 1024;
+var FILE_SIZE_LIMIT = parseInt("500", 10) * 1024 * 1024;
 var DIRECTORY_SIZE_LIMIT = parseInt("500", 10) * 1024 * 1024;
 function checkFileSizeLimit(filePath) {
   const stats = import_fs.default.statSync(filePath);
@@ -4521,16 +4521,105 @@ function getDeviceId() {
 }
 
 // bin/utils/uploadToIpfs.ts
-var ipfsApiUrl = "https://pinme.dev/api/v2";
+var ipfsApiUrl = "https://pinme.dev/api/v3";
+var maxPollTime = parseInt(process.env.MAX_POLL_TIME_MINUTES || "5") * 60 * 1e3;
+var pollInterval = parseInt(process.env.POLL_INTERVAL_SECONDS || "2") * 1e3;
+var pollTimeout = parseInt(process.env.POLL_TIMEOUT_SECONDS || "10") * 1e3;
+async function pollUploadStatus(traceId, deviceId, smartProgress, startTime) {
+  let consecutiveErrors = 0;
+  let stopProgressUpdates = false;
+  while (Date.now() - startTime < maxPollTime) {
+    try {
+      const response = await axios_default.get(
+        `${ipfsApiUrl}/up_status?trace_id=${traceId}&uid=${deviceId}`,
+        {
+          timeout: pollTimeout,
+          headers: {
+            "User-Agent": "Pinme-CLI/1.0.0",
+            Accept: "*/*",
+            Host: new URL(ipfsApiUrl).host,
+            Connection: "keep-alive"
+          }
+        }
+      );
+      const { code, msg, data } = response.data;
+      if (code === 200) {
+        consecutiveErrors = 0;
+        stopProgressUpdates = false;
+        if (data.is_ready) {
+          smartProgress.complete(traceId);
+          return data;
+        } else {
+          smartProgress.updateDisplay();
+        }
+      } else {
+        console.log(import_chalk2.default.yellow(`Warning: ${msg}`));
+      }
+    } catch (error) {
+      consecutiveErrors++;
+      console.log(import_chalk2.default.yellow(`Polling error: ${error.message}`));
+      if (stopProgressUpdates) {
+        smartProgress.updateTimeOnly();
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+  }
+  const maxPollTimeMinutes = Math.floor(maxPollTime / (60 * 1e3));
+  smartProgress.fail(
+    `Upload timeout after ${maxPollTimeMinutes} minutes`,
+    traceId
+  );
+  return null;
+}
+function diagnoseDirectoryUploadError(directoryName, resData, expectedName) {
+  const issues = [];
+  if (directoryName.length > 100) {
+    issues.push(
+      `Directory name too long (${directoryName.length} characters, recommended under 100 characters)`
+    );
+  }
+  const availableName = resData.Name;
+  issues.push(`Name returned by IPFS: ${availableName}`);
+  issues.push(`Expected directory name: ${expectedName}`);
+  const encodedName = encodeURIComponent(directoryName);
+  if (encodedName !== directoryName) {
+    issues.push(`Directory name after encoding: ${encodedName}`);
+  }
+  return issues.join("\n  - ");
+}
+function handleMultipartError(error, context) {
+  if (error.message && error.message.includes("multipart: NextPart: EOF")) {
+    return `Multipart form data error: ${context}. This usually indicates:
+  - Empty directory or no valid files
+  - File access permissions issue
+  - Network interruption during upload
+  - Server-side multipart parsing error`;
+  }
+  if (error.message && error.message.includes("ENOENT")) {
+    return `File not found error: ${context}. Please check:
+  - File path is correct
+  - File exists and is accessible
+  - No permission issues`;
+  }
+  if (error.message && error.message.includes("EACCES")) {
+    return `Permission denied error: ${context}. Please check:
+  - File read permissions
+  - Directory access permissions
+  - User has sufficient privileges`;
+  }
+  return `Upload error: ${error.message}`;
+}
 var ERROR_CODES = {
-  "30001": `File too large, single file max size: ${"20"}MB,single folder max size: ${"500"}MB`,
+  "30001": `File too large, single file max size: ${"500"}MB,single folder max size: ${"500"}MB`,
   "30002": `Max storage quorum ${Number("1000") / 1e3} GB reached`
 };
-var dirPath = null;
-function loadFilesToArrRecursively(directoryPath, dist) {
+function loadFilesToArrRecursively(directoryPath, dist, basePath) {
   const filesArr = [];
   const sep = import_path4.default.sep;
-  dirPath = dirPath || directoryPath.replace(dist, "");
+  if (!basePath) {
+    const parentDir = import_path4.default.dirname(directoryPath);
+    basePath = parentDir.endsWith(sep) ? parentDir : parentDir + sep;
+  }
   if (import_fs_extra3.default.statSync(directoryPath).isDirectory()) {
     const files = import_fs_extra3.default.readdirSync(directoryPath);
     files.forEach((file) => {
@@ -4544,14 +4633,18 @@ function loadFilesToArrRecursively(directoryPath, dist) {
             )} (size: ${formatSize(sizeCheck.size)})`
           );
         }
-        const filePathWithNoEndSep = filePath.replace(dirPath, "");
-        const filePathEncodeSep = filePathWithNoEndSep.replaceAll(sep, "%2F");
+        const relativePath = filePath.replace(basePath, "");
+        const encodedPath = relativePath.replaceAll(sep, "%2F");
         filesArr.push({
-          name: filePathEncodeSep,
+          name: encodedPath,
           path: filePath
         });
       } else if (import_fs_extra3.default.statSync(filePath).isDirectory()) {
-        const recursiveFiles = loadFilesToArrRecursively(filePath, dist);
+        const recursiveFiles = loadFilesToArrRecursively(
+          filePath,
+          dist,
+          basePath
+        );
         filesArr.push(...recursiveFiles);
       }
     });
@@ -4589,18 +4682,47 @@ async function uploadDirectory(directoryPath, deviceId) {
   const dist = directoryPath.split(import_path4.default.sep).pop() || "";
   const files = loadFilesToArrRecursively(directoryPath, dist);
   const totalFiles = files.length;
+  if (totalFiles === 0) {
+    throw new Error(
+      `Directory ${directoryPath} is empty or contains no valid files`
+    );
+  }
   files.forEach((file) => {
+    if (!import_fs_extra3.default.existsSync(file.path)) {
+      throw new Error(`File not found: ${file.path}`);
+    }
+    const fileStats = import_fs_extra3.default.statSync(file.path);
+    if (!fileStats.isFile()) {
+      throw new Error(`Path is not a file: ${file.path}`);
+    }
     formData.append("file", import_fs_extra3.default.createReadStream(file.path), {
       filename: file.name
     });
   });
   const startTime = Date.now();
-  const spinner = (0, import_ora.default)(`Uploading ${dist} (${totalFiles} files)... 0s`).start();
+  const spinner = (0, import_ora.default)(`Preparing upload...`).start();
+  let totalSize = 0;
+  files.forEach((file) => {
+    try {
+      const stats = import_fs_extra3.default.statSync(file.path);
+      totalSize += stats.size;
+    } catch (error) {
+    }
+  });
+  const smartProgress = new SmartProgressBar(
+    dist,
+    totalFiles,
+    totalSize,
+    spinner
+  );
   const timeInterval = setInterval(() => {
-    const elapsed = Math.floor((Date.now() - startTime) / 1e3);
-    spinner.text = `Uploading ${dist} (${totalFiles} files)... ${elapsed}s`;
+    smartProgress.updateTime();
   }, 1e3);
+  const progressInterval = setInterval(() => {
+    smartProgress.updateProgress();
+  }, 200);
   try {
+    smartProgress.startUpload();
     const response = await axios_default.post(
       `${ipfsApiUrl}/add?uid=${deviceId}&cidV=1`,
       formData,
@@ -4612,52 +4734,97 @@ async function uploadDirectory(directoryPath, deviceId) {
         // 30 minutes timeout
       }
     );
-    clearInterval(timeInterval);
-    const resData = response.data.data;
-    if (Array.isArray(resData) && resData.length > 0) {
-      const directoryItem = resData.find((item) => item.Name === dist);
-      if (directoryItem) {
-        const elapsed = Math.floor((Date.now() - startTime) / 1e3);
-        spinner.succeed(
-          `Successfully uploaded ${dist} (${totalFiles} files) in ${elapsed}s`
-        );
-        const fileCount = countFilesInDirectory(directoryPath);
-        const uploadData = {
-          path: directoryPath,
-          filename: import_path4.default.basename(directoryPath),
-          contentHash: directoryItem.Hash,
-          previewHash: null,
-          size: sizeCheck.size,
-          fileCount,
-          isDirectory: true,
-          shortUrl: directoryItem.ShortUrl || null
-        };
-        saveUploadHistory(uploadData);
-        return {
-          hash: directoryItem.Hash,
-          shortUrl: directoryItem.ShortUrl
-        };
-      }
-      spinner.fail(`Directory hash not found in response`);
-      console.log(import_chalk2.default.red(`Directory hash not found in response`));
-    } else {
-      spinner.fail(`Invalid response format from IPFS`);
-      console.log(import_chalk2.default.red(`Invalid response format from IPFS`));
+    clearInterval(progressInterval);
+    smartProgress.startPolling();
+    const { trace_id } = response.data.data;
+    if (!trace_id) {
+      smartProgress.fail("No request id received from server");
+      clearInterval(timeInterval);
+      return null;
     }
+    smartProgress.updateDisplay();
+    const uploadResult = await pollUploadStatus(
+      trace_id,
+      deviceId,
+      smartProgress,
+      startTime
+    );
+    if (!uploadResult) {
+      clearInterval(timeInterval);
+      return null;
+    }
+    const directoryItem = uploadResult.upload_rst;
+    if (directoryItem) {
+      const fileCount = countFilesInDirectory(directoryPath);
+      const uploadData = {
+        path: directoryPath,
+        filename: import_path4.default.basename(directoryPath),
+        contentHash: directoryItem.Hash,
+        previewHash: null,
+        size: sizeCheck.size,
+        fileCount,
+        isDirectory: true,
+        shortUrl: directoryItem.ShortUrl || null
+      };
+      saveUploadHistory(uploadData);
+      clearInterval(timeInterval);
+      return {
+        hash: directoryItem.Hash,
+        shortUrl: directoryItem.ShortUrl
+      };
+    }
+    const diagnosticInfo = diagnoseDirectoryUploadError(
+      dist,
+      uploadResult.upload_rst,
+      dist
+    );
+    smartProgress.fail("Directory hash not found in response");
+    console.log(
+      import_chalk2.default.red(
+        `
+\u274C Directory upload failed: Directory hash not found in response`
+      )
+    );
+    console.log(import_chalk2.default.yellow(`
+\u{1F4CB} Error diagnosis information:`));
+    console.log(import_chalk2.default.gray(`  - ${diagnosticInfo}`));
+    console.log(import_chalk2.default.blue(`
+\u{1F527} Solutions:`));
+    console.log(
+      import_chalk2.default.gray(`  1. Ensure directory is not empty and contains valid files`)
+    );
+    console.log(import_chalk2.default.gray(`  2. Check network connection stability`));
+    console.log(
+      import_chalk2.default.gray(`  3. Try uploading a smaller directory for testing`)
+    );
+    clearInterval(timeInterval);
     return null;
   } catch (error) {
+    clearInterval(progressInterval);
     clearInterval(timeInterval);
+    if (error.message && error.message.includes("multipart")) {
+      const errorMessage = handleMultipartError(
+        error,
+        `Directory upload: ${dist}`
+      );
+      smartProgress.fail(errorMessage);
+      console.log(import_chalk2.default.red(`
+\u274C ${errorMessage}`));
+      return null;
+    }
     if (error.response && error.response.data && error.response.data.code) {
       const errorCode = error.response.data.code.toString();
       if (ERROR_CODES[errorCode]) {
-        spinner.fail(`Error: ${ERROR_CODES[errorCode]} (Code: ${errorCode})`);
+        smartProgress.fail(
+          `Error: ${ERROR_CODES[errorCode]} (Code: ${errorCode})`
+        );
         console.log(
           import_chalk2.default.red(`Error: ${ERROR_CODES[errorCode]} (Code: ${errorCode})`)
         );
         return null;
       }
     }
-    spinner.fail(`Error: ${error.message}`);
+    smartProgress.fail(`Error: ${error.message}`);
     console.log(import_chalk2.default.red(`Error: ${error.message}`));
     return null;
   }
@@ -4672,13 +4839,37 @@ async function uploadFile(filePath, deviceId) {
     );
   }
   const fileName = filePath.split(import_path4.default.sep).pop() || "";
+  if (!import_fs_extra3.default.existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  const fileStats = import_fs_extra3.default.statSync(filePath);
+  if (!fileStats.isFile()) {
+    throw new Error(`Path is not a file: ${filePath}`);
+  }
+  console.log(import_chalk2.default.blue("\n\u{1F4C4} File Upload Analysis:"));
+  console.log(import_chalk2.default.gray(`  File path: ${filePath}`));
+  console.log(import_chalk2.default.gray(`  File name: ${fileName}`));
+  console.log(import_chalk2.default.gray(`  File size: ${formatSize(fileStats.size)}`));
+  console.log(import_chalk2.default.gray(`  File exists: ${import_fs_extra3.default.existsSync(filePath)}`));
+  console.log(import_chalk2.default.gray(`  Is file: ${fileStats.isFile()}
+`));
   const startTime = Date.now();
-  const spinner = (0, import_ora.default)(`Uploading ${fileName}... 0s`).start();
+  const spinner = (0, import_ora.default)(`Preparing upload...`).start();
+  let totalSize = 0;
+  try {
+    const stats = import_fs_extra3.default.statSync(filePath);
+    totalSize = stats.size;
+  } catch (error) {
+  }
+  const smartProgress = new SmartProgressBar(fileName, 1, totalSize, spinner);
   const timeInterval = setInterval(() => {
-    const elapsed = Math.floor((Date.now() - startTime) / 1e3);
-    spinner.text = `Uploading ${fileName}... ${elapsed}s`;
+    smartProgress.updateTime();
   }, 1e3);
+  const progressInterval = setInterval(() => {
+    smartProgress.updateProgress();
+  }, 200);
   try {
+    smartProgress.startUpload();
     const formData = new import_form_data2.default();
     const encodedFileName = encodeURIComponent(fileName);
     formData.append("file", import_fs_extra3.default.createReadStream(filePath), {
@@ -4695,53 +4886,259 @@ async function uploadFile(filePath, deviceId) {
         // 30 minutes timeout
       }
     );
-    clearInterval(timeInterval);
-    const resData = response.data.data;
-    if (Array.isArray(resData) && resData.length > 0) {
-      const fileItem = resData.find((item) => item.Name === fileName);
-      if (fileItem) {
-        const elapsed = Math.floor((Date.now() - startTime) / 1e3);
-        spinner.succeed(`Successfully uploaded ${fileName} in ${elapsed}s`);
-        const uploadData = {
-          path: filePath,
-          filename: fileName,
-          contentHash: fileItem.Hash,
-          previewHash: null,
-          size: sizeCheck.size,
-          fileCount: 1,
-          isDirectory: false,
-          shortUrl: fileItem.ShortUrl || null
-        };
-        saveUploadHistory(uploadData);
-        return {
-          hash: fileItem.Hash,
-          shortUrl: fileItem.ShortUrl
-        };
-      }
-      spinner.fail(`File hash not found in response`);
-      console.log(import_chalk2.default.red(`File hash not found in response`));
-    } else {
-      spinner.fail(`Invalid response format from IPFS`);
-      console.log(import_chalk2.default.red(`Invalid response format from IPFS`));
+    clearInterval(progressInterval);
+    smartProgress.startPolling();
+    const trace_id = response.data.data.trace_id;
+    if (!trace_id) {
+      smartProgress.fail("No request id received from server");
+      clearInterval(timeInterval);
+      return null;
     }
+    smartProgress.updateDisplay();
+    const uploadResult = await pollUploadStatus(
+      trace_id,
+      deviceId,
+      smartProgress,
+      startTime
+    );
+    if (!uploadResult) {
+      clearInterval(timeInterval);
+      return null;
+    }
+    const fileItem = uploadResult.upload_rst;
+    if (fileItem) {
+      const uploadData = {
+        path: filePath,
+        filename: fileName,
+        contentHash: fileItem.Hash,
+        previewHash: null,
+        size: sizeCheck.size,
+        fileCount: 1,
+        isDirectory: false,
+        shortUrl: fileItem.ShortUrl || null
+      };
+      saveUploadHistory(uploadData);
+      smartProgress.complete(trace_id);
+      clearInterval(timeInterval);
+      return {
+        hash: fileItem.Hash,
+        shortUrl: fileItem.ShortUrl
+      };
+    }
+    smartProgress.fail("File hash not found in response");
+    console.log(
+      import_chalk2.default.red(`
+\u274C File upload failed: File hash not found in response`)
+    );
+    console.log(import_chalk2.default.yellow(`
+\u{1F4CB} Error diagnosis information:`));
+    console.log(import_chalk2.default.gray(`  - File name: ${fileName}`));
+    console.log(
+      import_chalk2.default.gray(`  - Name returned by IPFS: ${uploadResult.upload_rst.Name}`)
+    );
+    console.log(import_chalk2.default.blue(`
+\u{1F527} Solutions:`));
+    console.log(import_chalk2.default.gray(`  1. Check if file is corrupted or unreadable`));
+    console.log(import_chalk2.default.gray(`  2. Check network connection stability`));
+    console.log(import_chalk2.default.gray(`  3. Try uploading a smaller file for testing`));
+    clearInterval(timeInterval);
     return null;
   } catch (error) {
+    clearInterval(progressInterval);
     clearInterval(timeInterval);
+    if (error.message && error.message.includes("multipart")) {
+      const errorMessage = handleMultipartError(
+        error,
+        `File upload: ${fileName}`
+      );
+      smartProgress.fail(errorMessage);
+      console.log(import_chalk2.default.red(`
+\u274C ${errorMessage}`));
+      return null;
+    }
     if (error.response && error.response.data && error.response.data.code) {
       const errorCode = error.response.data.code.toString();
       if (ERROR_CODES[errorCode]) {
-        spinner.fail(`Error: ${ERROR_CODES[errorCode]} (Code: ${errorCode})`);
+        smartProgress.fail(
+          `Error: ${ERROR_CODES[errorCode]} (Code: ${errorCode})`
+        );
         console.log(
           import_chalk2.default.red(`Error: ${ERROR_CODES[errorCode]} (Code: ${errorCode})`)
         );
         return null;
       }
     }
-    spinner.fail(`Error: ${error.message}`);
+    smartProgress.fail(`Error: ${error.message}`);
     console.log(import_chalk2.default.red(`Error: ${error.message}`));
     return null;
   }
 }
+var SmartProgressBar = class {
+  timeConstant;
+  startTime;
+  uploadStartTime;
+  isUploading;
+  isPolling;
+  fileCount;
+  totalSize;
+  spinner;
+  fileName;
+  isCompleted;
+  // Add completion flag
+  constructor(fileName, fileCount, totalSize, spinner) {
+    this.fileName = fileName;
+    this.fileCount = fileCount;
+    this.totalSize = totalSize;
+    this.spinner = spinner;
+    this.timeConstant = this.calcTimeConstant(fileCount, totalSize);
+    this.startTime = Date.now();
+    this.uploadStartTime = 0;
+    this.isUploading = false;
+    this.isPolling = false;
+    this.isCompleted = false;
+  }
+  // Calculate time constant based on file count and total size
+  calcTimeConstant(fileCount, totalSize) {
+    const base = 8e3;
+    const countFactor = 0.3 * Math.log(1 + fileCount);
+    const sizeFactor = 0.7 * Math.log(1 + totalSize / 1024 / 1024);
+    const minTimeConstant = 15e3;
+    const calculatedTimeConstant = base * (1 + countFactor + sizeFactor);
+    return Math.max(calculatedTimeConstant, minTimeConstant);
+  }
+  // Calculate progress using exponential decay model with upper limit
+  calculateProgress() {
+    const elapsed = Date.now() - this.startTime;
+    const rawProgress = 1 - Math.exp(-elapsed / this.timeConstant);
+    const maxProgress = this.isPolling ? 0.95 : 0.9;
+    return Math.min(rawProgress, maxProgress);
+  }
+  // Start upload phase
+  startUpload() {
+    this.isUploading = true;
+    this.uploadStartTime = Date.now();
+  }
+  // Start polling phase
+  startPolling() {
+    this.isPolling = true;
+    this.isUploading = false;
+  }
+  // Update progress display
+  update() {
+    if (this.isCompleted) {
+      return;
+    }
+    const progress = this.calculateProgress();
+    const elapsed = Math.floor((Date.now() - this.startTime) / 1e3);
+    const progressBar = this.createProgressBar(progress);
+    const duration = this.formatDuration(elapsed);
+    let status = "";
+    if (this.isUploading) {
+      status = "uploading";
+    } else if (this.isPolling) {
+      status = "processing";
+    } else {
+      status = "preparing";
+    }
+    const fileInfo = this.fileCount > 1 ? `${this.fileName} (${this.fileCount} files)` : this.fileName;
+    this.spinner.text = `Uploading ${fileInfo} ${progressBar} ${duration} (${status})`;
+  }
+  // Update time display only (called every second)
+  updateTime() {
+    if (this.isCompleted) {
+      return;
+    }
+    const elapsed = Math.floor((Date.now() - this.startTime) / 1e3);
+    const duration = this.formatDuration(elapsed);
+    const progress = this.calculateProgress();
+    const progressBar = this.createProgressBar(progress);
+    let status = "";
+    if (this.isUploading) {
+      status = "uploading";
+    } else if (this.isPolling) {
+      status = "processing";
+    } else {
+      status = "preparing";
+    }
+    const fileInfo = this.fileCount > 1 ? `${this.fileName} (${this.fileCount} files)` : this.fileName;
+    this.spinner.text = `Uploading ${fileInfo} ${progressBar} ${duration} (${status})`;
+  }
+  // Update progress bar only (called every 200ms)
+  updateProgress() {
+    if (this.isCompleted) {
+      return;
+    }
+    const progress = this.calculateProgress();
+    const elapsed = Math.floor((Date.now() - this.startTime) / 1e3);
+    const progressBar = this.createProgressBar(progress);
+    const duration = this.formatDuration(elapsed);
+    let status = "";
+    if (this.isUploading) {
+      status = "uploading";
+    } else if (this.isPolling) {
+      status = "processing";
+    } else {
+      status = "preparing";
+    }
+    const fileInfo = this.fileCount > 1 ? `${this.fileName} (${this.fileCount} files)` : this.fileName;
+    this.spinner.text = `Uploading ${fileInfo} ${progressBar} ${duration} (${status})`;
+  }
+  // Update display (for manual updates)
+  updateDisplay() {
+    this.updateTime();
+  }
+  // Update progress display only (no progress bar)
+  updateTimeOnly() {
+    const elapsed = Math.floor((Date.now() - this.startTime) / 1e3);
+    const duration = this.formatDuration(elapsed);
+    this.spinner.text = `Uploading ${this.fileName} ${duration}`;
+  }
+  // Complete progress
+  complete(traceId) {
+    if (this.isCompleted) {
+      return;
+    }
+    const progressBar = this.createProgressBar(1);
+    const elapsed = Math.floor((Date.now() - this.startTime) / 1e3);
+    const duration = this.formatDuration(elapsed);
+    this.spinner.succeed(`Upload completed ${progressBar} ${duration}`);
+    this.isCompleted = true;
+  }
+  // Fail progress
+  fail(message, traceId) {
+    if (this.isCompleted) {
+      return;
+    }
+    const elapsed = Math.floor((Date.now() - this.startTime) / 1e3);
+    const duration = this.formatDuration(elapsed);
+    this.spinner.fail(`${message} ${duration}`);
+    this.isCompleted = true;
+  }
+  // Create visual progress bar
+  createProgressBar(progress, width = 20) {
+    const percentage = Math.min(progress, 1);
+    const filledWidth = Math.round(width * percentage);
+    const emptyWidth = width - filledWidth;
+    const filled = "\u2588".repeat(filledWidth);
+    const empty = "\u2591".repeat(emptyWidth);
+    return `[${filled}${empty}] ${Math.round(percentage * 100)}%`;
+  }
+  // Format time duration
+  formatDuration(seconds) {
+    if (seconds < 60) {
+      return `${seconds}s`;
+    } else if (seconds < 3600) {
+      const minutes = Math.floor(seconds / 60);
+      const remainingSeconds = seconds % 60;
+      return `${minutes}m ${remainingSeconds}s`;
+    } else {
+      const hours = Math.floor(seconds / 3600);
+      const minutes = Math.floor(seconds % 3600 / 60);
+      const remainingSeconds = seconds % 60;
+      return `${hours}h ${minutes}m ${remainingSeconds}s`;
+    }
+  }
+};
 async function uploadToIpfs_default(filePath) {
   const deviceId = getDeviceId();
   if (!deviceId) {
@@ -4881,7 +5278,7 @@ var import_figlet2 = __toESM(require("figlet"));
 
 // bin/utils/removeFromIpfs.ts
 var import_chalk4 = __toESM(require("chalk"));
-var ipfsApiUrl2 = "https://pinme.dev/api/v2";
+var ipfsApiUrl2 = "https://pinme.dev/api/v3";
 async function removeFromIpfs(value, type = "hash") {
   try {
     const uid = getDeviceId();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinme",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "publishConfig": {
     "access": "public"
   },