pinme 1.1.1 → 1.1.3-alpha.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

@@ -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.1";
+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,17 +4360,17 @@ 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"));
 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);
@@ -4520,256 +4520,458 @@ function getDeviceId() {
   return deviceId;
 }
 
-// bin/utils/uploadToIpfs.ts
-var ipfsApiUrl = "https://pinme.dev/api/v2";
-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`
-};
-var dirPath = null;
-function loadFilesToArrRecursively(directoryPath, dist) {
-  const filesArr = [];
-  const sep = import_path4.default.sep;
-  dirPath = dirPath || directoryPath.replace(dist, "");
-  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 filePathWithNoEndSep = filePath.replace(dirPath, "");
-        const filePathEncodeSep = filePathWithNoEndSep.replaceAll(sep, "%2F");
-        filesArr.push({
-          name: filePathEncodeSep,
-          path: filePath
-        });
-      } else if (import_fs_extra3.default.statSync(filePath).isDirectory()) {
-        const recursiveFiles = loadFilesToArrRecursively(filePath, dist);
-        filesArr.push(...recursiveFiles);
-      }
-    });
-  } else {
-    console.error("Error: path must be a directory");
+// 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();
+  }
+  startStep(stepIndex, stepName) {
+    this.currentStep = stepIndex;
+    this.stepStartTime = Date.now();
+  }
+  updateProgress(progress, total) {
+  }
+  completeStep() {
+  }
+  failStep(error) {
+    this.stopProgress();
+    this.spinner.fail(`Upload failed: ${error}`);
+  }
+  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)`);
+  }
+  fail(error) {
+    this.stopProgress();
+    const totalTime = Math.floor((Date.now() - this.startTime) / 1e3);
+    this.spinner.fail(`Upload failed: ${error} (${totalTime}s)`);
+  }
+  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;
+    }
+  }
+  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)}]`;
   }
-  return filesArr;
+};
+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);
+  });
 }
-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);
+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);
     }
-  }
-  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)})`
+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 {
+    const response = await axios_default.post(
+      `${IPFS_API_URL}/chunk/init`,
+      {
+        file_name: fileName,
+        file_size: fileSize,
+        md5,
+        is_directory: isDirectory,
+        uid: deviceId
+      },
+      {
+        timeout: TIMEOUT,
+        headers: { "Content-Type": "application/json" }
+      }
     );
+    const { code, msg, data } = response.data;
+    if (code === 200 && data) {
+      return data;
+    }
+    throw new Error(`Session initialization failed: ${msg} (code: ${code})`);
+  } catch (error) {
+    if (axios_default.isAxiosError(error)) {
+      throw new Error(`Network error: ${error.message}`);
+    }
+    throw error;
   }
-  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;
-  files.forEach((file) => {
-    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 timeInterval = setInterval(() => {
-    const elapsed = Math.floor((Date.now() - startTime) / 1e3);
-    spinner.text = `Uploading ${dist} (${totalFiles} files)... ${elapsed}s`;
-  }, 1e3);
+}
+async function uploadChunkWithAbort(sessionId, chunkIndex, chunkData, deviceId, signal, retryCount = 0) {
   try {
+    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(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`));
+    const { code, msg, data } = response.data;
+    if (code === 200 && data) {
+      return data;
     }
-    return null;
+    throw new Error(`Chunk upload failed: ${msg} (code: ${code})`);
   } catch (error) {
-    clearInterval(timeInterval);
-    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})`);
-        console.log(
-          import_chalk2.default.red(`Error: ${ERROR_CODES[errorCode]} (Code: ${errorCode})`)
+    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
+      );
+    }
+    throw new Error(
+      `Chunk ${chunkIndex + 1} upload failed after ${MAX_RETRIES} retries: ${error.message}`
+    );
+  }
+}
+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 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
         );
-        return null;
+        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");
     }
-    spinner.fail(`Error: ${error.message}`);
-    console.log(import_chalk2.default.red(`Error: ${error.message}`));
-    return null;
+    if (hasFatalError) {
+      throw new Error(fatalError || "Unknown error occurred during upload");
+    }
+  } catch (error) {
+    throw fatalError ? new Error(fatalError) : 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)})`
+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;
+    }
+    throw new Error(`Complete upload failed: ${msg} (code: ${code})`);
+  } catch (error) {
+    if (axios_default.isAxiosError(error)) {
+      throw new Error(`Network error: ${error.message}`);
+    }
+    throw error;
   }
-  const fileName = filePath.split(import_path4.default.sep).pop() || "";
-  const startTime = Date.now();
-  const spinner = (0, import_ora.default)(`Uploading ${fileName}... 0s`).start();
-  const timeInterval = setInterval(() => {
-    const elapsed = Math.floor((Date.now() - startTime) / 1e3);
-    spinner.text = `Uploading ${fileName}... ${elapsed}s`;
-  }, 1e3);
+}
+async function getChunkStatus(sessionId, deviceId) {
   try {
-    const formData = new import_form_data2.default();
-    const encodedFileName = encodeURIComponent(fileName);
-    formData.append("file", import_fs_extra3.default.createReadStream(filePath), {
-      filename: encodedFileName
-    });
-    const response = await axios_default.post(
-      `${ipfsApiUrl}/add?uid=${deviceId}&cidV=1`,
-      formData,
+    const response = await axios_default.get(
+      `${IPFS_API_URL}/up_status`,
       {
-        headers: {
-          ...formData.getHeaders()
-        },
-        timeout: 18e5
-        // 30 minutes timeout
+        params: { trace_id: sessionId, uid: deviceId },
+        timeout: TIMEOUT,
+        headers: { "Content-Type": "application/json" }
       }
     );
-    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);
+    const { code, msg, data } = response.data;
+    if (code === 200) {
+      return data;
+    }
+    throw new Error(`Server returned error: ${msg} (code: ${code})`);
+  } catch (error) {
+    if (axios_default.isAxiosError(error)) {
+      throw new Error(`Network error: ${error.message}`);
+    }
+    throw error;
+  }
+}
+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: fileItem.Hash,
-          shortUrl: fileItem.ShortUrl
+          hash: status.upload_rst.Hash,
+          shortUrl: status.upload_rst.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`));
-    }
-    return null;
-  } catch (error) {
-    clearInterval(timeInterval);
-    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})`);
-        console.log(
-          import_chalk2.default.red(`Error: ${ERROR_CODES[errorCode]} (Code: ${errorCode})`)
-        );
-        return null;
+    } catch (error) {
+      consecutiveErrors++;
+      if (consecutiveErrors > 10) {
+        throw new Error(`Polling failed: ${error.message}`);
       }
     }
-    spinner.fail(`Error: ${error.message}`);
-    console.log(import_chalk2.default.red(`Error: ${error.message}`));
-    return null;
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL));
   }
+  const maxPollTimeMinutes = Math.floor(MAX_POLL_TIME / (60 * 1e3));
+  throw new Error(`Polling timeout after ${maxPollTimeMinutes} minutes`);
 }
-async function uploadToIpfs_default(filePath) {
-  const deviceId = getDeviceId();
-  if (!deviceId) {
-    throw new Error("Device ID not found");
+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)})`
+    );
   }
-  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 || "";
+  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) {
     }
-  } else {
-    const result = await uploadFile(filePath, deviceId);
-    if (result) {
-      contentHash = result.hash;
-      shortUrl = result.shortUrl || "";
+    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");
     }
+    progressBar.complete();
+    return result;
+  } catch (error) {
+    progressBar.fail(error.message);
+    throw error;
   }
-  if (contentHash) {
-    return {
-      contentHash,
+}
+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,
-      shortUrl
+      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 uploadToIpfs2_default(filePath) {
+  const deviceId = getDeviceId();
+  if (!deviceId) {
+    throw new Error("Device ID not found");
+  }
+  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;
   }
-  return null;
 }
 
 // bin/upload.ts
@@ -4798,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;
   }
 }
@@ -4817,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([
       {
@@ -4848,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/v2";
+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
     });
@@ -4894,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;
   }
@@ -4983,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([
       {
@@ -5017,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([
@@ -5040,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([
@@ -5052,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);
   }
 };
@@ -5078,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");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinme",
-  "version": "1.1.1",
+  "version": "1.1.3-alpha.2",
   "publishConfig": {
     "access": "public"
   },
@@ -26,6 +26,7 @@
   "author": "Glitter Protocol",
   "license": "MIT",
   "dependencies": {
+    "archiver": "^7.0.1",
     "axios": "^1.3.2",
     "base-x": "^5.0.1",
     "bip39": "^3.1.0",