pinme 1.1.2 → 1.1.3-alpha.2

package/dist/index.js

@@ -99,7 +99,7 @@ var require_main = __commonJS({
     var fs6 = require("fs");
     var path6 = require("path");
     var os3 = require("os");
-    var crypto = require("crypto");
+    var crypto2 = require("crypto");
     var packageJson = require_package();
     var version2 = packageJson.version;
     var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
@@ -295,7 +295,7 @@ var require_main = __commonJS({
       const authTag = ciphertext.subarray(-16);
       ciphertext = ciphertext.subarray(12, -16);
       try {
-        const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+        const aesgcm = crypto2.createDecipheriv("aes-256-gcm", key, nonce);
         aesgcm.setAuthTag(authTag);
         return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
       } catch (error) {
@@ -1481,15 +1481,15 @@ var require_follow_redirects = __commonJS({
 // bin/index.ts
 var import_dotenv = __toESM(require_main());
 var import_commander = require("commander");
-var import_chalk6 = __toESM(require("chalk"));
+var import_chalk5 = __toESM(require("chalk"));
 var import_figlet3 = __toESM(require("figlet"));
 
 // package.json
-var version = "1.1.2";
+var version = "1.1.3-alpha.2";
 
 // bin/upload.ts
 var import_path5 = __toESM(require("path"));
-var import_chalk3 = __toESM(require("chalk"));
+var import_chalk2 = __toESM(require("chalk"));
 var import_inquirer = __toESM(require("inquirer"));
 var import_figlet = __toESM(require("figlet"));
 
@@ -4360,12 +4360,12 @@ var {
   mergeConfig: mergeConfig2
 } = axios_default;
 
-// bin/utils/uploadToIpfs.ts
+// bin/utils/uploadToIpfs2.ts
 var import_fs_extra3 = __toESM(require("fs-extra"));
 var import_path4 = __toESM(require("path"));
 var import_form_data2 = __toESM(require("form-data"));
 var import_ora = __toESM(require("ora"));
-var import_chalk2 = __toESM(require("chalk"));
+var crypto = __toESM(require("crypto"));
 
 // bin/utils/uploadLimits.ts
 var import_fs = __toESM(require("fs"));
@@ -4520,653 +4520,458 @@ function getDeviceId() {
   return deviceId;
 }
 
-// bin/utils/uploadToIpfs.ts
-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));
+// bin/utils/uploadToIpfs2.ts
+var IPFS_API_URL = "https://up.pinme.dev/api/v3";
+var MAX_RETRIES = parseInt(process.env.MAX_RETRIES || "2");
+var RETRY_DELAY = parseInt(process.env.RETRY_DELAY_MS || "1000");
+var TIMEOUT = parseInt(process.env.TIMEOUT_MS || "600000");
+var MAX_POLL_TIME = parseInt("5") * 60 * 1e3;
+var POLL_INTERVAL = parseInt(process.env.POLL_INTERVAL_SECONDS || "2") * 1e3;
+var PROGRESS_UPDATE_INTERVAL = 200;
+var EXPECTED_UPLOAD_TIME = 6e4;
+var MAX_PROGRESS = 0.95;
+var StepProgressBar = class {
+  spinner;
+  fileName;
+  startTime;
+  currentStep = 0;
+  stepStartTime = 0;
+  progressInterval = null;
+  constructor(fileName, isDirectory = false) {
+    this.fileName = fileName;
+    this.spinner = (0, import_ora.default)(`Preparing to upload ${fileName}...`).start();
+    this.startTime = Date.now();
+    this.stepStartTime = Date.now();
+    this.startProgress();
   }
-  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)`
-    );
+  startStep(stepIndex, stepName) {
+    this.currentStep = stepIndex;
+    this.stepStartTime = Date.now();
   }
-  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}`);
+  updateProgress(progress, total) {
   }
-  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: ${"500"}MB,single folder max size: ${"500"}MB`,
-  "30002": `Max storage quorum ${Number("1000") / 1e3} GB reached`
-};
-function loadFilesToArrRecursively(directoryPath, dist, basePath) {
-  const filesArr = [];
-  const sep = import_path4.default.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) => {
-      const filePath = import_path4.default.join(directoryPath, file);
-      if (import_fs_extra3.default.statSync(filePath).isFile()) {
-        const sizeCheck = checkFileSizeLimit(filePath);
-        if (sizeCheck.exceeds) {
-          throw new Error(
-            `File ${file} exceeds size limit of ${formatSize(
-              sizeCheck.limit
-            )} (size: ${formatSize(sizeCheck.size)})`
-          );
-        }
-        const relativePath = filePath.replace(basePath, "");
-        const encodedPath = relativePath.replaceAll(sep, "%2F");
-        filesArr.push({
-          name: encodedPath,
-          path: filePath
-        });
-      } else if (import_fs_extra3.default.statSync(filePath).isDirectory()) {
-        const recursiveFiles = loadFilesToArrRecursively(
-          filePath,
-          dist,
-          basePath
-        );
-        filesArr.push(...recursiveFiles);
-      }
-    });
-  } else {
-    console.error("Error: path must be a directory");
+  completeStep() {
   }
-  return filesArr;
-}
-function countFilesInDirectory(directoryPath) {
-  let count = 0;
-  const files = import_fs_extra3.default.readdirSync(directoryPath);
-  for (const file of files) {
-    const filePath = import_path4.default.join(directoryPath, file);
-    const stats = import_fs_extra3.default.statSync(filePath);
-    if (stats.isFile()) {
-      count++;
-    } else if (stats.isDirectory()) {
-      count += countFilesInDirectory(filePath);
-    }
+  failStep(error) {
+    this.stopProgress();
+    this.spinner.fail(`Upload failed: ${error}`);
   }
-  return count;
-}
-async function uploadDirectory(directoryPath, deviceId) {
-  const sizeCheck = checkDirectorySizeLimit(directoryPath);
-  if (sizeCheck.exceeds) {
-    throw new Error(
-      `Directory ${directoryPath} exceeds size limit of ${formatSize(
-        sizeCheck.limit
-      )} (size: ${formatSize(sizeCheck.size)})`
-    );
+  complete() {
+    this.stopProgress();
+    const totalTime = Math.floor((Date.now() - this.startTime) / 1e3);
+    const progressBar = this.createProgressBar(1);
+    this.spinner.succeed(`Upload completed ${progressBar} 100% (${totalTime}s)`);
   }
-  const formData = new import_form_data2.default();
-  if (directoryPath.endsWith(import_path4.default.sep))
-    directoryPath = directoryPath.slice(0, -1);
-  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`
-    );
+  fail(error) {
+    this.stopProgress();
+    const totalTime = Math.floor((Date.now() - this.startTime) / 1e3);
+    this.spinner.fail(`Upload failed: ${error} (${totalTime}s)`);
   }
-  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}`);
+  startProgress() {
+    this.progressInterval = setInterval(() => {
+      const elapsed = Date.now() - this.startTime;
+      const progress = this.calculateProgress(elapsed);
+      const progressBar = this.createProgressBar(progress);
+      this.spinner.text = `Uploading ${this.fileName}... ${progressBar} ${Math.round(progress * 100)}%`;
+    }, PROGRESS_UPDATE_INTERVAL);
+  }
+  stopProgress() {
+    if (this.progressInterval) {
+      clearInterval(this.progressInterval);
+      this.progressInterval = null;
     }
-    formData.append("file", import_fs_extra3.default.createReadStream(file.path), {
-      filename: file.name
-    });
+  }
+  calculateProgress(elapsed) {
+    return Math.min(elapsed / EXPECTED_UPLOAD_TIME * MAX_PROGRESS, MAX_PROGRESS);
+  }
+  createProgressBar(progress, width = 20) {
+    const percentage = Math.min(progress, 1);
+    const filledWidth = Math.round(width * percentage);
+    const emptyWidth = width - filledWidth;
+    return `[${"\u2588".repeat(filledWidth)}${"\u2591".repeat(emptyWidth)}]`;
+  }
+};
+async function calculateMD5(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash("md5");
+    const stream4 = import_fs_extra3.default.createReadStream(filePath);
+    stream4.on("data", hash.update.bind(hash));
+    stream4.on("end", () => resolve(hash.digest("hex")));
+    stream4.on("error", reject);
   });
-  const startTime = Date.now();
-  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) {
+}
+async function compressDirectory(sourcePath) {
+  return new Promise((resolve, reject) => {
+    const tempDir = import_path4.default.join(process.cwd(), "temp");
+    if (!import_fs_extra3.default.existsSync(tempDir)) {
+      import_fs_extra3.default.mkdirSync(tempDir, { recursive: true });
+    }
+    const outputPath = import_path4.default.join(
+      tempDir,
+      `${import_path4.default.basename(sourcePath)}_${Date.now()}.zip`
+    );
+    const output = import_fs_extra3.default.createWriteStream(outputPath);
+    const zlib2 = require("zlib");
+    const gzip = zlib2.createGzip({ level: 9 });
+    output.on("close", () => resolve(outputPath));
+    gzip.on("error", reject);
+    gzip.pipe(output);
+    const stats = import_fs_extra3.default.statSync(sourcePath);
+    if (stats.isDirectory()) {
+      const archive = require("archiver");
+      const archiveStream = archive("zip", { zlib: { level: 9 } });
+      archiveStream.on("error", reject);
+      archiveStream.pipe(output);
+      archiveStream.directory(sourcePath, false);
+      archiveStream.finalize();
+    } else {
+      const fileStream = import_fs_extra3.default.createReadStream(sourcePath);
+      fileStream.pipe(gzip);
     }
   });
-  const smartProgress = new SmartProgressBar(
-    dist,
-    totalFiles,
-    totalSize,
-    spinner
-  );
-  const timeInterval = setInterval(() => {
-    smartProgress.updateTime();
-  }, 1e3);
-  const progressInterval = setInterval(() => {
-    smartProgress.updateProgress();
-  }, 200);
+}
+async function initChunkSession(filePath, deviceId, isDirectory = false) {
+  const stats = import_fs_extra3.default.statSync(filePath);
+  const fileName = import_path4.default.basename(filePath);
+  const fileSize = stats.size;
+  const md5 = await calculateMD5(filePath);
   try {
-    smartProgress.startUpload();
     const response = await axios_default.post(
-      `${ipfsApiUrl}/add?uid=${deviceId}&cidV=1`,
-      formData,
+      `${IPFS_API_URL}/chunk/init`,
       {
-        headers: {
-          ...formData.getHeaders()
-        },
-        timeout: 18e5
-        // 30 minutes timeout
+        file_name: fileName,
+        file_size: fileSize,
+        md5,
+        is_directory: isDirectory,
+        uid: deviceId
+      },
+      {
+        timeout: TIMEOUT,
+        headers: { "Content-Type": "application/json" }
       }
     );
-    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 { code, msg, data } = response.data;
+    if (code === 200 && data) {
+      return data;
     }
-    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;
+    throw new Error(`Session initialization failed: ${msg} (code: ${code})`);
   } 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]) {
-        smartProgress.fail(
-          `Error: ${ERROR_CODES[errorCode]} (Code: ${errorCode})`
-        );
-        console.log(
-          import_chalk2.default.red(`Error: ${ERROR_CODES[errorCode]} (Code: ${errorCode})`)
-        );
-        return null;
-      }
+    if (axios_default.isAxiosError(error)) {
+      throw new Error(`Network error: ${error.message}`);
     }
-    smartProgress.fail(`Error: ${error.message}`);
-    console.log(import_chalk2.default.red(`Error: ${error.message}`));
-    return null;
+    throw error;
   }
 }
-async function uploadFile(filePath, deviceId) {
-  const sizeCheck = checkFileSizeLimit(filePath);
-  if (sizeCheck.exceeds) {
-    throw new Error(
-      `File ${filePath} exceeds size limit of ${formatSize(
-        sizeCheck.limit
-      )} (size: ${formatSize(sizeCheck.size)})`
-    );
-  }
-  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)(`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(() => {
-    smartProgress.updateTime();
-  }, 1e3);
-  const progressInterval = setInterval(() => {
-    smartProgress.updateProgress();
-  }, 200);
+async function uploadChunkWithAbort(sessionId, chunkIndex, chunkData, deviceId, signal, retryCount = 0) {
   try {
-    smartProgress.startUpload();
-    const formData = new import_form_data2.default();
-    const encodedFileName = encodeURIComponent(fileName);
-    formData.append("file", import_fs_extra3.default.createReadStream(filePath), {
-      filename: encodedFileName
+    if (signal.aborted) {
+      throw new Error("Request cancelled");
+    }
+    const form = new import_form_data2.default();
+    form.append("session_id", sessionId);
+    form.append("chunk_index", chunkIndex.toString());
+    form.append("uid", deviceId);
+    form.append("chunk", chunkData, {
+      filename: `chunk_${chunkIndex}`,
+      contentType: "application/octet-stream"
     });
     const response = await axios_default.post(
-      `${ipfsApiUrl}/add?uid=${deviceId}&cidV=1`,
-      formData,
+      `${IPFS_API_URL}/chunk/upload`,
+      form,
       {
-        headers: {
-          ...formData.getHeaders()
-        },
-        timeout: 18e5
-        // 30 minutes timeout
+        headers: { ...form.getHeaders() },
+        timeout: TIMEOUT,
+        signal
       }
     );
-    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
-      };
+    const { code, msg, data } = response.data;
+    if (code === 200 && data) {
+      return data;
     }
-    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;
+    throw new Error(`Chunk upload failed: ${msg} (code: ${code})`);
   } catch (error) {
-    clearInterval(progressInterval);
-    clearInterval(timeInterval);
-    if (error.message && error.message.includes("multipart")) {
-      const errorMessage = handleMultipartError(
-        error,
-        `File upload: ${fileName}`
+    if (error.name === "CanceledError" || signal.aborted) {
+      throw new Error("Request cancelled");
+    }
+    if (retryCount < MAX_RETRIES) {
+      await delayWithAbortCheck(RETRY_DELAY, signal);
+      return uploadChunkWithAbort(
+        sessionId,
+        chunkIndex,
+        chunkData,
+        deviceId,
+        signal,
+        retryCount + 1
       );
-      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]) {
-        smartProgress.fail(
-          `Error: ${ERROR_CODES[errorCode]} (Code: ${errorCode})`
-        );
-        console.log(
-          import_chalk2.default.red(`Error: ${ERROR_CODES[errorCode]} (Code: ${errorCode})`)
-        );
-        return null;
-      }
-    }
-    smartProgress.fail(`Error: ${error.message}`);
-    console.log(import_chalk2.default.red(`Error: ${error.message}`));
-    return null;
+    throw new Error(
+      `Chunk ${chunkIndex + 1} upload failed after ${MAX_RETRIES} retries: ${error.message}`
+    );
   }
 }
-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) {
+async function delayWithAbortCheck(delay, signal) {
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      if (signal.aborted) {
+        reject(new Error("Request cancelled"));
+      } else {
+        resolve();
+      }
+    }, delay);
+    if (signal.aborted) {
+      clearTimeout(timeoutId);
+      reject(new Error("Request cancelled"));
       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 checkInterval = setInterval(() => {
+      if (signal.aborted) {
+        clearTimeout(timeoutId);
+        clearInterval(checkInterval);
+        reject(new Error("Request cancelled"));
+      }
+    }, 50);
+  });
+}
+async function uploadFileChunks(filePath, sessionId, totalChunks, chunkSize, deviceId, progressBar) {
+  const fileData = import_fs_extra3.default.readFileSync(filePath);
+  const abortController = new AbortController();
+  let completedCount = 0;
+  let hasFatalError = false;
+  let fatalError = null;
+  const uploadTasks = Array.from({ length: totalChunks }, (_, chunkIndex) => {
+    const start = chunkIndex * chunkSize;
+    const end = Math.min(start + chunkSize, fileData.length);
+    const chunkData = fileData.slice(start, end);
+    return async () => {
+      if (abortController.signal.aborted) return;
+      try {
+        await uploadChunkWithAbort(
+          sessionId,
+          chunkIndex,
+          chunkData,
+          deviceId,
+          abortController.signal
+        );
+        if (abortController.signal.aborted) return;
+        completedCount++;
+        progressBar.updateProgress(completedCount, totalChunks);
+      } catch (error) {
+        if (error.name === "AbortError" || abortController.signal.aborted) {
+          return;
+        }
+        hasFatalError = true;
+        fatalError = `Chunk ${chunkIndex + 1}/${totalChunks} upload failed: ${error.message}`;
+        abortController.abort();
+        throw new Error(fatalError);
+      }
+    };
+  });
+  try {
+    const results = await Promise.allSettled(uploadTasks.map((task) => task()));
+    const failedResults = results.filter((result) => result.status === "rejected");
+    if (failedResults.length > 0) {
+      const firstFailure = failedResults[0];
+      throw new Error(firstFailure.reason.message || "Error occurred during upload");
+    }
+    if (hasFatalError) {
+      throw new Error(fatalError || "Unknown error occurred during upload");
     }
-    const fileInfo = this.fileCount > 1 ? `${this.fileName} (${this.fileCount} files)` : this.fileName;
-    this.spinner.text = `Uploading ${fileInfo} ${progressBar} ${duration} (${status})`;
+  } catch (error) {
+    throw fatalError ? new Error(fatalError) : error;
   }
-  // Update time display only (called every second)
-  updateTime() {
-    if (this.isCompleted) {
-      return;
+}
+async function completeChunkUpload(sessionId, deviceId) {
+  try {
+    const response = await axios_default.post(
+      `${IPFS_API_URL}/chunk/complete`,
+      { session_id: sessionId, uid: deviceId },
+      {
+        timeout: TIMEOUT,
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+    const { code, msg, data } = response.data;
+    if (code === 200 && data) {
+      return data.trace_id;
     }
-    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";
+    throw new Error(`Complete upload failed: ${msg} (code: ${code})`);
+  } catch (error) {
+    if (axios_default.isAxiosError(error)) {
+      throw new Error(`Network error: ${error.message}`);
     }
-    const fileInfo = this.fileCount > 1 ? `${this.fileName} (${this.fileCount} files)` : this.fileName;
-    this.spinner.text = `Uploading ${fileInfo} ${progressBar} ${duration} (${status})`;
+    throw error;
   }
-  // Update progress bar only (called every 200ms)
-  updateProgress() {
-    if (this.isCompleted) {
-      return;
+}
+async function getChunkStatus(sessionId, deviceId) {
+  try {
+    const response = await axios_default.get(
+      `${IPFS_API_URL}/up_status`,
+      {
+        params: { trace_id: sessionId, uid: deviceId },
+        timeout: TIMEOUT,
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+    const { code, msg, data } = response.data;
+    if (code === 200) {
+      return data;
     }
-    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";
+    throw new Error(`Server returned error: ${msg} (code: ${code})`);
+  } catch (error) {
+    if (axios_default.isAxiosError(error)) {
+      throw new Error(`Network error: ${error.message}`);
     }
-    const fileInfo = this.fileCount > 1 ? `${this.fileName} (${this.fileCount} files)` : this.fileName;
-    this.spinner.text = `Uploading ${fileInfo} ${progressBar} ${duration} (${status})`;
+    throw error;
   }
-  // Update display (for manual updates)
-  updateDisplay() {
-    this.updateTime();
+}
+async function monitorChunkProgress(traceId, deviceId) {
+  let consecutiveErrors = 0;
+  const startTime = Date.now();
+  while (Date.now() - startTime < MAX_POLL_TIME) {
+    try {
+      const status = await getChunkStatus(traceId, deviceId);
+      consecutiveErrors = 0;
+      if (status.is_ready && status.upload_rst.Hash) {
+        return {
+          hash: status.upload_rst.Hash,
+          shortUrl: status.upload_rst.ShortUrl
+        };
+      }
+    } catch (error) {
+      consecutiveErrors++;
+      if (consecutiveErrors > 10) {
+        throw new Error(`Polling failed: ${error.message}`);
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL));
   }
-  // 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}`;
+  const maxPollTimeMinutes = Math.floor(MAX_POLL_TIME / (60 * 1e3));
+  throw new Error(`Polling timeout after ${maxPollTimeMinutes} minutes`);
+}
+async function uploadDirectoryInChunks(directoryPath, deviceId) {
+  const sizeCheck = checkDirectorySizeLimit(directoryPath);
+  if (sizeCheck.exceeds) {
+    throw new Error(
+      `Directory ${directoryPath} exceeds size limit ${formatSize(sizeCheck.limit)} (size: ${formatSize(sizeCheck.size)})`
+    );
   }
-  // Complete progress
-  complete(traceId) {
-    if (this.isCompleted) {
-      return;
+  const progressBar = new StepProgressBar(import_path4.default.basename(directoryPath), true);
+  try {
+    progressBar.startStep(0, "Preparing compression");
+    const compressedPath = await compressDirectory(directoryPath);
+    progressBar.completeStep();
+    progressBar.startStep(1, "Initializing session");
+    const sessionInfo = await initChunkSession(compressedPath, deviceId, true);
+    progressBar.completeStep();
+    progressBar.startStep(2, "Chunk upload");
+    await uploadFileChunks(
+      compressedPath,
+      sessionInfo.session_id,
+      sessionInfo.total_chunks,
+      sessionInfo.chunk_size,
+      deviceId,
+      progressBar
+    );
+    progressBar.completeStep();
+    progressBar.startStep(3, "Completing upload");
+    const traceId = await completeChunkUpload(sessionInfo.session_id, deviceId);
+    progressBar.completeStep();
+    progressBar.startStep(4, "Waiting for processing");
+    const result = await monitorChunkProgress(traceId, deviceId);
+    progressBar.completeStep();
+    try {
+      import_fs_extra3.default.unlinkSync(compressedPath);
+    } catch (error) {
     }
-    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 uploadData = {
+      path: directoryPath,
+      filename: import_path4.default.basename(directoryPath),
+      contentHash: (result == null ? void 0 : result.hash) || "unknown",
+      size: sizeCheck.size,
+      fileCount: 0,
+      isDirectory: true,
+      shortUrl: (result == null ? void 0 : result.shortUrl) || null
+    };
+    saveUploadHistory(uploadData);
+    if (!(result == null ? void 0 : result.hash)) {
+      throw new Error("Server did not return valid hash value");
     }
-    const elapsed = Math.floor((Date.now() - this.startTime) / 1e3);
-    const duration = this.formatDuration(elapsed);
-    this.spinner.fail(`${message} ${duration}`);
-    this.isCompleted = true;
+    progressBar.complete();
+    return result;
+  } catch (error) {
+    progressBar.fail(error.message);
+    throw error;
   }
-  // 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 uploadFileInChunks(filePath, deviceId) {
+  const sizeCheck = checkFileSizeLimit(filePath);
+  if (sizeCheck.exceeds) {
+    throw new Error(
+      `File ${filePath} exceeds size limit ${formatSize(sizeCheck.limit)} (size: ${formatSize(sizeCheck.size)})`
+    );
+  }
+  const fileName = import_path4.default.basename(filePath);
+  const progressBar = new StepProgressBar(fileName, false);
+  try {
+    progressBar.startStep(0, "Initializing session");
+    const sessionInfo = await initChunkSession(filePath, deviceId, false);
+    progressBar.completeStep();
+    progressBar.startStep(1, "Chunk upload");
+    await uploadFileChunks(
+      filePath,
+      sessionInfo.session_id,
+      sessionInfo.total_chunks,
+      sessionInfo.chunk_size,
+      deviceId,
+      progressBar
+    );
+    progressBar.completeStep();
+    progressBar.startStep(2, "Completing upload");
+    const traceId = await completeChunkUpload(sessionInfo.session_id, deviceId);
+    progressBar.completeStep();
+    progressBar.startStep(3, "Waiting for processing");
+    const result = await monitorChunkProgress(traceId, deviceId);
+    progressBar.completeStep();
+    const uploadData = {
+      path: filePath,
+      filename: fileName,
+      contentHash: (result == null ? void 0 : result.hash) || "unknown",
+      previewHash: null,
+      size: sizeCheck.size,
+      fileCount: 1,
+      isDirectory: false,
+      shortUrl: (result == null ? void 0 : result.shortUrl) || null
+    };
+    saveUploadHistory(uploadData);
+    if (!(result == null ? void 0 : result.hash)) {
+      throw new Error("Server did not return valid hash value");
     }
+    progressBar.complete();
+    return result;
+  } catch (error) {
+    progressBar.fail(error.message);
+    throw error;
   }
-};
-async function uploadToIpfs_default(filePath) {
+}
+async function uploadToIpfs2_default(filePath) {
   const deviceId = getDeviceId();
   if (!deviceId) {
     throw new Error("Device ID not found");
   }
-  let contentHash = "";
-  let shortUrl = "";
-  if (import_fs_extra3.default.statSync(filePath).isDirectory()) {
-    const result = await uploadDirectory(filePath, deviceId);
-    if (result) {
-      contentHash = result.hash;
-      shortUrl = result.shortUrl || "";
-    }
-  } else {
-    const result = await uploadFile(filePath, deviceId);
-    if (result) {
-      contentHash = result.hash;
-      shortUrl = result.shortUrl || "";
+  try {
+    const isDirectory = import_fs_extra3.default.statSync(filePath).isDirectory();
+    const result = isDirectory ? await uploadDirectoryInChunks(filePath, deviceId) : await uploadFileInChunks(filePath, deviceId);
+    if (result == null ? void 0 : result.hash) {
+      return {
+        contentHash: result.hash,
+        previewHash: null,
+        shortUrl: result.shortUrl
+      };
     }
+    return null;
+  } catch (error) {
+    return null;
   }
-  if (contentHash) {
-    return {
-      contentHash,
-      previewHash: null,
-      shortUrl
-    };
-  }
-  return null;
 }
 
 // bin/upload.ts
@@ -5195,7 +5000,7 @@ function checkPathSync(inputPath) {
     }
     return null;
   } catch (error) {
-    console.error(import_chalk3.default.red(`error checking path: ${error.message}`));
+    console.error(import_chalk2.default.red(`error checking path: ${error.message}`));
     return null;
   }
 }
@@ -5214,26 +5019,27 @@ var upload_default = async (options) => {
     if (argPath && !argPath.startsWith("-")) {
       const absolutePath = checkPathSync(argPath);
       if (!absolutePath) {
-        console.log(import_chalk3.default.red(`path ${argPath} does not exist`));
+        console.log(import_chalk2.default.red(`path ${argPath} does not exist`));
         return;
       }
-      console.log(import_chalk3.default.blue(`uploading ${absolutePath} to ipfs...`));
+      console.log(import_chalk2.default.blue(`uploading ${absolutePath} to ipfs...`));
       try {
-        const result = await uploadToIpfs_default(absolutePath);
+        const result = await uploadToIpfs2_default(absolutePath);
         if (result) {
           const encryptedCID = encryptHash(result.contentHash, secretKey);
           console.log(
-            import_chalk3.default.cyan(
+            import_chalk2.default.cyan(
               import_figlet.default.textSync("Successful", { horizontalLayout: "full" })
             )
           );
-          console.log(import_chalk3.default.cyan(`URL:`));
-          console.log(import_chalk3.default.cyan(`${URL2}${encryptedCID}`));
+          console.log(import_chalk2.default.cyan(`URL:`));
+          console.log(import_chalk2.default.cyan(`${URL2}${encryptedCID}`));
+          console.log(import_chalk2.default.green("\n\u{1F389} \u4E0A\u4F20\u5B8C\u6210\uFF0C\u7A0B\u5E8F\u9000\u51FA"));
         }
       } catch (error) {
-        console.error(import_chalk3.default.red(`Error: ${error.message}`));
+        console.error(import_chalk2.default.red(`Error: ${error.message}`));
       }
-      return;
+      process.exit(0);
     }
     const answer = await import_inquirer.default.prompt([
       {
@@ -5245,44 +5051,46 @@ var upload_default = async (options) => {
     if (answer.path) {
       const absolutePath = checkPathSync(answer.path);
       if (!absolutePath) {
-        console.log(import_chalk3.default.red(`path ${answer.path} does not exist`));
+        console.log(import_chalk2.default.red(`path ${answer.path} does not exist`));
         return;
       }
-      console.log(import_chalk3.default.blue(`uploading ${absolutePath} to ipfs...`));
+      console.log(import_chalk2.default.blue(`uploading ${absolutePath} to ipfs...`));
       try {
-        const result = await uploadToIpfs_default(absolutePath);
+        const result = await uploadToIpfs2_default(absolutePath);
         if (result) {
           const encryptedCID = encryptHash(result.contentHash, secretKey);
           console.log(
-            import_chalk3.default.cyan(
+            import_chalk2.default.cyan(
               import_figlet.default.textSync("Successful", { horizontalLayout: "full" })
             )
           );
-          console.log(import_chalk3.default.cyan(`URL:`));
-          console.log(import_chalk3.default.cyan(`${URL2}${encryptedCID}`));
+          console.log(import_chalk2.default.cyan(`URL:`));
+          console.log(import_chalk2.default.cyan(`${URL2}${encryptedCID}`));
+          console.log(import_chalk2.default.green("\n\u{1F389} \u4E0A\u4F20\u5B8C\u6210\uFF0C\u7A0B\u5E8F\u9000\u51FA"));
         }
       } catch (error) {
-        console.error(import_chalk3.default.red(`Error: ${error.message}`));
+        console.error(import_chalk2.default.red(`Error: ${error.message}`));
       }
+      process.exit(0);
     }
   } catch (error) {
-    console.error(import_chalk3.default.red(`error executing: ${error.message}`));
+    console.error(import_chalk2.default.red(`error executing: ${error.message}`));
     console.error(error.stack);
   }
 };
 
 // bin/remove.ts
-var import_chalk5 = __toESM(require("chalk"));
+var import_chalk4 = __toESM(require("chalk"));
 var import_inquirer2 = __toESM(require("inquirer"));
 var import_figlet2 = __toESM(require("figlet"));
 
 // bin/utils/removeFromIpfs.ts
-var import_chalk4 = __toESM(require("chalk"));
-var ipfsApiUrl2 = "https://pinme.dev/api/v3";
+var import_chalk3 = __toESM(require("chalk"));
+var ipfsApiUrl = "https://up.pinme.dev/api/v3";
 async function removeFromIpfs(value, type = "hash") {
   try {
     const uid = getDeviceId();
-    console.log(import_chalk4.default.blue(`Removing content from IPFS: ${value}...`));
+    console.log(import_chalk3.default.blue(`Removing content from IPFS: ${value}...`));
     const queryParams = new URLSearchParams({
       uid
     });
@@ -5291,37 +5099,37 @@ async function removeFromIpfs(value, type = "hash") {
     } else {
       queryParams.append("arg", value);
     }
-    const response = await axios_default.post(`${ipfsApiUrl2}/block/rm?${queryParams.toString()}`, {
+    const response = await axios_default.post(`${ipfsApiUrl}/block/rm?${queryParams.toString()}`, {
       timeout: 3e4
       // 30 seconds timeout
     });
     const { code, msg, data } = response.data;
     if (code === 200) {
-      console.log(import_chalk4.default.green("\u2713 Removal successful!"));
-      console.log(import_chalk4.default.cyan(`Content ${type}: ${value} has been removed from IPFS network`));
+      console.log(import_chalk3.default.green("\u2713 Removal successful!"));
+      console.log(import_chalk3.default.cyan(`Content ${type}: ${value} has been removed from IPFS network`));
       return true;
     } else {
-      console.log(import_chalk4.default.red("\u2717 Removal failed"));
-      console.log(import_chalk4.default.red(`Error: ${msg || "Unknown error occurred"}`));
+      console.log(import_chalk3.default.red("\u2717 Removal failed"));
+      console.log(import_chalk3.default.red(`Error: ${msg || "Unknown error occurred"}`));
       return false;
     }
   } catch (error) {
-    console.log(import_chalk4.default.red("\u2717 Removal failed", error));
+    console.log(import_chalk3.default.red("\u2717 Removal failed", error));
     if (error.response) {
       const { status, data } = error.response;
-      console.log(import_chalk4.default.red(`HTTP Error ${status}: ${(data == null ? void 0 : data.msg) || "Server error"}`));
+      console.log(import_chalk3.default.red(`HTTP Error ${status}: ${(data == null ? void 0 : data.msg) || "Server error"}`));
       if (status === 404) {
-        console.log(import_chalk4.default.yellow("Content not found on the network or already removed"));
+        console.log(import_chalk3.default.yellow("Content not found on the network or already removed"));
       } else if (status === 403) {
-        console.log(import_chalk4.default.yellow("Permission denied - you may not have access to remove this content"));
+        console.log(import_chalk3.default.yellow("Permission denied - you may not have access to remove this content"));
       } else if (status === 500) {
-        console.log(import_chalk4.default.yellow("Server internal error - please try again later"));
+        console.log(import_chalk3.default.yellow("Server internal error - please try again later"));
       }
     } else if (error.request) {
-      console.log(import_chalk4.default.red("Network error: Unable to connect to IPFS service"));
-      console.log(import_chalk4.default.yellow("Please check your internet connection and try again"));
+      console.log(import_chalk3.default.red("Network error: Unable to connect to IPFS service"));
+      console.log(import_chalk3.default.yellow("Please check your internet connection and try again"));
     } else {
-      console.log(import_chalk4.default.red(`Error: ${error.message}`));
+      console.log(import_chalk3.default.red(`Error: ${error.message}`));
     }
     return false;
   }
@@ -5380,30 +5188,30 @@ var remove_default = async (options) => {
     if (argHash && !argHash.startsWith("-")) {
       const parsedInput = parseInput(argHash);
       if (!parsedInput) {
-        console.log(import_chalk5.default.red(`Invalid input format: ${argHash}`));
-        console.log(import_chalk5.default.yellow("Supported formats:"));
-        console.log(import_chalk5.default.yellow("  - IPFS hash: bafybeig..."));
-        console.log(import_chalk5.default.yellow("  - Full URL: https://bafybeig....pinme.dev"));
-        console.log(import_chalk5.default.yellow("  - Subname: 3abt6ztu"));
-        console.log(import_chalk5.default.yellow("  - Subname URL: https://3abt6ztu.pinit.eth.limo"));
+        console.log(import_chalk4.default.red(`Invalid input format: ${argHash}`));
+        console.log(import_chalk4.default.yellow("Supported formats:"));
+        console.log(import_chalk4.default.yellow("  - IPFS hash: bafybeig..."));
+        console.log(import_chalk4.default.yellow("  - Full URL: https://bafybeig....pinme.dev"));
+        console.log(import_chalk4.default.yellow("  - Subname: 3abt6ztu"));
+        console.log(import_chalk4.default.yellow("  - Subname URL: https://3abt6ztu.pinit.eth.limo"));
         return;
       }
       try {
         const success = await removeFromIpfs(parsedInput.value, parsedInput.type);
         if (success) {
           console.log(
-            import_chalk5.default.cyan(
+            import_chalk4.default.cyan(
               import_figlet2.default.textSync("Successful", { horizontalLayout: "full" })
             )
           );
         }
       } catch (error) {
-        console.error(import_chalk5.default.red(`Error: ${error.message}`));
+        console.error(import_chalk4.default.red(`Error: ${error.message}`));
       }
       return;
     }
-    console.log(import_chalk5.default.yellow("\u26A0\uFE0F  Warning: This action will permanently remove the content from IPFS network"));
-    console.log(import_chalk5.default.yellow("\u26A0\uFE0F  Make sure you have the correct IPFS hash"));
+    console.log(import_chalk4.default.yellow("\u26A0\uFE0F  Warning: This action will permanently remove the content from IPFS network"));
+    console.log(import_chalk4.default.yellow("\u26A0\uFE0F  Make sure you have the correct IPFS hash"));
     console.log("");
     const confirmAnswer = await import_inquirer2.default.prompt([
       {
@@ -5414,7 +5222,7 @@ var remove_default = async (options) => {
       }
     ]);
     if (!confirmAnswer.confirm) {
-      console.log(import_chalk5.default.yellow("Operation cancelled"));
+      console.log(import_chalk4.default.yellow("Operation cancelled"));
       return;
     }
     const answer = await import_inquirer2.default.prompt([
@@ -5437,7 +5245,7 @@ var remove_default = async (options) => {
     if (answer.input) {
       const parsedInput = parseInput(answer.input.trim());
       if (!parsedInput) {
-        console.log(import_chalk5.default.red("Invalid input format"));
+        console.log(import_chalk4.default.red("Invalid input format"));
         return;
       }
       const finalConfirm = await import_inquirer2.default.prompt([
@@ -5449,24 +5257,24 @@ var remove_default = async (options) => {
         }
       ]);
       if (!finalConfirm.confirm) {
-        console.log(import_chalk5.default.yellow("Operation cancelled"));
+        console.log(import_chalk4.default.yellow("Operation cancelled"));
         return;
       }
       try {
         const success = await removeFromIpfs(parsedInput.value, parsedInput.type);
         if (success) {
           console.log(
-            import_chalk5.default.cyan(
+            import_chalk4.default.cyan(
               import_figlet2.default.textSync("Successful", { horizontalLayout: "full" })
             )
           );
         }
       } catch (error) {
-        console.error(import_chalk5.default.red(`Error: ${error.message}`));
+        console.error(import_chalk4.default.red(`Error: ${error.message}`));
       }
     }
   } catch (error) {
-    console.error(import_chalk5.default.red(`Error executing remove command: ${error.message}`));
+    console.error(import_chalk4.default.red(`Error executing remove command: ${error.message}`));
     console.error(error.stack);
   }
 };
@@ -5475,11 +5283,11 @@ var remove_default = async (options) => {
 import_dotenv.default.config();
 function showBanner() {
   console.log(
-    import_chalk6.default.cyan(
+    import_chalk5.default.cyan(
       import_figlet3.default.textSync("Pinme", { horizontalLayout: "full" })
     )
   );
-  console.log(import_chalk6.default.cyan("A command-line tool for uploading files to IPFS\n"));
+  console.log(import_chalk5.default.cyan("A command-line tool for uploading files to IPFS\n"));
 }
 var program = new import_commander.Command();
 program.name("pinme").version(version).option("-v, --version", "output the current version");