pinme 1.1.1-alpha.1 → 1.1.1-alpha.3

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-alpha.1";
+var version = "1.1.1-alpha.3";
 
 // bin/upload.ts
 var import_path5 = __toESM(require("path"));
@@ -4525,7 +4525,9 @@ 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, spinner, startTime) {
+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(
@@ -4542,28 +4544,31 @@ async function pollUploadStatus(traceId, deviceId, spinner, startTime) {
       );
       const { code, msg, data } = response.data;
       if (code === 200) {
-        const elapsed = Math.floor((Date.now() - startTime) / 1e3);
+        consecutiveErrors = 0;
+        stopProgressUpdates = false;
         if (data.is_ready) {
-          const progressBar = createProgressBar(1, 1);
-          const duration = formatDuration(elapsed);
-          spinner.succeed(`Upload completed ${progressBar} ${duration} (request id: ${traceId})`);
+          smartProgress.complete(traceId);
           return data;
         } else {
-          const estimatedProgress = Math.min(elapsed / 30, 0.9);
-          const progressBar = createProgressBar(estimatedProgress, 1);
-          const duration = formatDuration(elapsed);
-          spinner.text = `Uploading... ${progressBar} ${duration} (request id: ${traceId})`;
+          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));
-  spinner.fail(`Upload timeout after ${maxPollTimeMinutes} minutes (request id: ${traceId})`);
+  smartProgress.fail(
+    `Upload timeout after ${maxPollTimeMinutes} minutes`,
+    traceId
+  );
   return null;
 }
 function diagnoseDirectoryUploadError(directoryName, resData, expectedName) {
@@ -4608,10 +4613,13 @@ var ERROR_CODES = {
   "30001": `File too large, single file max size: ${"20"}MB,single folder max size: ${"500"}MB`,
   "30002": `Max storage quorum ${Number("1000") / 1e3} GB reached`
 };
-function loadFilesToArrRecursively(directoryPath, dist) {
+function loadFilesToArrRecursively(directoryPath, dist, basePath) {
   const filesArr = [];
   const sep = import_path4.default.sep;
-  const basePath = import_path4.default.dirname(directoryPath) + sep;
+  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) => {
@@ -4625,14 +4633,18 @@ function loadFilesToArrRecursively(directoryPath, dist) {
             )} (size: ${formatSize(sizeCheck.size)})`
           );
         }
-        const filePathWithNoEndSep = filePath.replace(basePath, "");
-        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);
       }
     });
@@ -4671,18 +4683,9 @@ async function uploadDirectory(directoryPath, deviceId) {
   const files = loadFilesToArrRecursively(directoryPath, dist);
   const totalFiles = files.length;
   if (totalFiles === 0) {
-    throw new Error(`Directory ${directoryPath} is empty or contains no valid files`);
-  }
-  console.log(import_chalk2.default.gray(`
-\u{1F4C1} Directory upload details:`));
-  console.log(import_chalk2.default.gray(`  - Directory: ${dist}`));
-  console.log(import_chalk2.default.gray(`  - Total files: ${totalFiles}`));
-  console.log(import_chalk2.default.gray(`  - Files to upload:`));
-  files.slice(0, 5).forEach((file, index) => {
-    console.log(import_chalk2.default.gray(`    ${index + 1}. ${file.name} (${file.path})`));
-  });
-  if (files.length > 5) {
-    console.log(import_chalk2.default.gray(`    ... and ${files.length - 5} more files`));
+    throw new Error(
+      `Directory ${directoryPath} is empty or contains no valid files`
+    );
   }
   files.forEach((file) => {
     if (!import_fs_extra3.default.existsSync(file.path)) {
@@ -4697,16 +4700,29 @@ async function uploadDirectory(directoryPath, deviceId) {
     });
   });
   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);
-    const progressBar = createProgressBar(elapsed, Math.max(elapsed + 1, 30));
-    const duration = formatDuration(elapsed);
-    spinner.text = `Uploading ${dist} (${totalFiles} files) ${progressBar} ${duration}`;
+    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,
@@ -4718,22 +4734,23 @@ async function uploadDirectory(directoryPath, deviceId) {
         // 30 minutes timeout
       }
     );
-    clearInterval(timeInterval);
+    clearInterval(progressInterval);
+    smartProgress.startPolling();
     const { trace_id } = response.data.data;
     if (!trace_id) {
-      spinner.fail("No request id received from server");
+      smartProgress.fail("No request id received from server");
+      clearInterval(timeInterval);
       return null;
     }
-    spinner.text = `Upload initiated, waiting for completion... (request id: ${trace_id})`;
-    console.log(import_chalk2.default.blue(`
-\u{1F50D} REQUEST ID: ${trace_id}`));
+    smartProgress.updateDisplay();
     const uploadResult = await pollUploadStatus(
       trace_id,
       deviceId,
-      spinner,
+      smartProgress,
       startTime
     );
     if (!uploadResult) {
+      clearInterval(timeInterval);
       return null;
     }
     const directoryItem = uploadResult.upload_rst;
@@ -4750,6 +4767,7 @@ async function uploadDirectory(directoryPath, deviceId) {
         shortUrl: directoryItem.ShortUrl || null
       };
       saveUploadHistory(uploadData);
+      clearInterval(timeInterval);
       return {
         hash: directoryItem.Hash,
         shortUrl: directoryItem.ShortUrl
@@ -4760,7 +4778,7 @@ async function uploadDirectory(directoryPath, deviceId) {
       uploadResult.upload_rst,
       dist
     );
-    spinner.fail(`Directory hash not found in response`);
+    smartProgress.fail("Directory hash not found in response");
     console.log(
       import_chalk2.default.red(
         `
@@ -4773,19 +4791,23 @@ async function uploadDirectory(directoryPath, deviceId) {
     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`
-      )
+      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}`);
-      spinner.fail(errorMessage);
+      const errorMessage = handleMultipartError(
+        error,
+        `Directory upload: ${dist}`
+      );
+      smartProgress.fail(errorMessage);
       console.log(import_chalk2.default.red(`
 \u274C ${errorMessage}`));
       return null;
@@ -4793,14 +4815,16 @@ async function uploadDirectory(directoryPath, deviceId) {
     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;
   }
@@ -4822,15 +4846,30 @@ async function uploadFile(filePath, deviceId) {
   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);
-    const progressBar = createProgressBar(elapsed, Math.max(elapsed + 1, 20));
-    const duration = formatDuration(elapsed);
-    spinner.text = `Uploading ${fileName} ${progressBar} ${duration}`;
+    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), {
@@ -4847,22 +4886,23 @@ async function uploadFile(filePath, deviceId) {
         // 30 minutes timeout
       }
     );
-    clearInterval(timeInterval);
+    clearInterval(progressInterval);
+    smartProgress.startPolling();
     const trace_id = response.data.data.trace_id;
     if (!trace_id) {
-      spinner.fail("No request id received from server");
+      smartProgress.fail("No request id received from server");
+      clearInterval(timeInterval);
       return null;
     }
-    spinner.text = `Upload initiated, waiting for completion... (request id: ${trace_id})`;
-    console.log(import_chalk2.default.blue(`
-\u{1F50D} REQUEST ID: ${trace_id}`));
+    smartProgress.updateDisplay();
     const uploadResult = await pollUploadStatus(
       trace_id,
       deviceId,
-      spinner,
+      smartProgress,
       startTime
     );
     if (!uploadResult) {
+      clearInterval(timeInterval);
       return null;
     }
     const fileItem = uploadResult.upload_rst;
@@ -4878,12 +4918,14 @@ async function uploadFile(filePath, deviceId) {
         shortUrl: fileItem.ShortUrl || null
       };
       saveUploadHistory(uploadData);
+      smartProgress.complete(trace_id);
+      clearInterval(timeInterval);
       return {
         hash: fileItem.Hash,
         shortUrl: fileItem.ShortUrl
       };
     }
-    spinner.fail(`File hash not found in response`);
+    smartProgress.fail("File hash not found in response");
     console.log(
       import_chalk2.default.red(`
 \u274C File upload failed: File hash not found in response`)
@@ -4892,20 +4934,24 @@ async function uploadFile(filePath, deviceId) {
 \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}`
-      )
+      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}`);
-      spinner.fail(errorMessage);
+      const errorMessage = handleMultipartError(
+        error,
+        `File upload: ${fileName}`
+      );
+      smartProgress.fail(errorMessage);
       console.log(import_chalk2.default.red(`
 \u274C ${errorMessage}`));
       return null;
@@ -4913,40 +4959,186 @@ async function uploadFile(filePath, deviceId) {
     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;
   }
 }
-function createProgressBar(current, total, width = 20) {
-  const percentage = Math.min(current / total, 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)}%`;
-}
-function 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`;
+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) {

package/package.json

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