pinme 1.0.2 → 1.0.4

package/README.md

@@ -130,14 +130,14 @@ pinme help
 
 ## Upload Limits
 
-- Single file size limit: 100MB
+- Single file size limit: 20MB
 - Total directory size limit: 500MB
 
 ## File Storage
 
 Uploaded files are stored on the IPFS network and accessible through the Glitter Protocol's IPFS gateway. After a successful upload, you will receive:
 
-1. IPFS hash value
+1. IPFS content hash
 2. Accessible URL link
 
 ### Log Locations
@@ -151,6 +151,22 @@ Logs and configuration files are stored in:
 
 MIT License - See the [LICENSE](LICENSE) file for details
 
+## Usage Tips
+
+### Uploading Vite Projects
+
+When uploading projects built with Vite, please note:
+
+1. **Vite Configuration**: Add `base: "./"` to your Vite configuration file to ensure proper asset path resolution:
+
+```js
+// vite.config.js
+export default {
+  base: "./",
+  // other configurations...
+}
+```
+
 ## Contact Us
 
 If you have questions or suggestions, please contact us through:

package/dist/index.js

@@ -367,7 +367,7 @@ var import_chalk4 = __toESM(require("chalk"));
 var import_figlet2 = __toESM(require("figlet"));
 
 // package.json
-var version = "1.0.2";
+var version = "1.0.4";
 
 // bin/upload.ts
 var import_path5 = __toESM(require("path"));
@@ -386,7 +386,7 @@ var import_chalk2 = __toESM(require("chalk"));
 // bin/utils/uploadLimits.ts
 var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
-var FILE_SIZE_LIMIT = parseInt("100", 10) * 1024 * 1024;
+var FILE_SIZE_LIMIT = parseInt("20", 10) * 1024 * 1024;
 var DIRECTORY_SIZE_LIMIT = parseInt("500", 10) * 1024 * 1024;
 function checkFileSizeLimit(filePath) {
   const stats = import_fs.default.statSync(filePath);
@@ -454,7 +454,8 @@ var saveUploadHistory = (uploadData) => {
       previewHash: uploadData.previewHash,
       size: uploadData.size,
       fileCount: uploadData.fileCount || 1,
-      type: uploadData.isDirectory ? "directory" : "file"
+      type: uploadData.isDirectory ? "directory" : "file",
+      shortUrl: (uploadData == null ? void 0 : uploadData.shortUrl) || null
     };
     history.uploads.unshift(newRecord);
     import_fs_extra.default.writeJsonSync(HISTORY_FILE, history, { spaces: 2 });
@@ -480,25 +481,23 @@ var displayUploadHistory = (limit = 10) => {
     console.log(import_chalk.default.yellow("No upload history found."));
     return;
   }
-  console.log(import_chalk.default.bold("\n\u{1F4DC} Upload History:"));
-  console.log(import_chalk.default.dim("\u2500".repeat(80)));
-  history.forEach((record, index) => {
-    console.log(import_chalk.default.bold(`#${index + 1} - ${record.date}`));
-    console.log(import_chalk.default.cyan(`Name: ${record.filename}`));
-    console.log(import_chalk.default.cyan(`Path: ${record.path}`));
-    console.log(import_chalk.default.cyan(`Type: ${record.type}`));
-    console.log(import_chalk.default.cyan(`Size: ${formatSize(record.size)}`));
-    if (record.type === "directory") {
-      console.log(import_chalk.default.cyan(`Files: ${record.fileCount}`));
+  console.log(import_chalk.default.cyan("Upload History:"));
+  console.log(import_chalk.default.cyan("-".repeat(80)));
+  const recentHistory = history.slice(-limit);
+  recentHistory.forEach((item, index) => {
+    console.log(import_chalk.default.green(`${index + 1}. ${item.filename}`));
+    console.log(import_chalk.default.white(`   Path: ${item.path}`));
+    console.log(import_chalk.default.white(`   Content Hash: ${item.contentHash}`));
+    if (item.shortUrl) {
+      console.log(import_chalk.default.white(`   ENS URL: https://${item.shortUrl}.pinit.eth.limo`));
     }
-    console.log(import_chalk.default.cyan(`Content Hash: ${record.contentHash}`));
-    if (record.previewHash) {
-      console.log(import_chalk.default.cyan(`Preview Hash: ${record.previewHash}`));
-      console.log(import_chalk.default.cyan(`URL: https://ipfs.glitterprotocol.dev/ipfs/${record.previewHash}/#/?from=local`));
-    } else {
-      console.log(import_chalk.default.cyan(`URL: https://ipfs.glitterprotocol.dev/ipfs/${record.contentHash}`));
+    console.log(import_chalk.default.white(`   Size: ${formatSize(item.size)}`));
+    console.log(import_chalk.default.white(`   Files: ${item.fileCount}`));
+    console.log(import_chalk.default.white(`   Type: ${item.type === "directory" ? "Directory" : "File"}`));
+    if (item.timestamp) {
+      console.log(import_chalk.default.white(`   Date: ${new Date(item.timestamp).toLocaleString()}`));
     }
-    console.log(import_chalk.default.dim("\u2500".repeat(80)));
+    console.log(import_chalk.default.cyan("-".repeat(80)));
   });
   const totalSize = history.reduce((sum, record) => sum + record.size, 0);
   const totalFiles = history.reduce((sum, record) => sum + record.fileCount, 0);
@@ -539,6 +538,10 @@ function getDeviceId() {
 
 // bin/utils/uploadToIpfs.ts
 var ipfsApiUrl = "https://ipfs.glitterprotocol.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 = [];
@@ -551,7 +554,11 @@ function loadFilesToArrRecursively(directoryPath, dist) {
       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)})`);
+          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");
@@ -586,10 +593,15 @@ function countFilesInDirectory(directoryPath) {
 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)})`);
+    throw new Error(
+      `Directory ${directoryPath} exceeds size limit of ${formatSize(
+        sizeCheck.limit
+      )} (size: ${formatSize(sizeCheck.size)})`
+    );
   }
   const formData = new import_form_data.default();
-  if (directoryPath.endsWith(import_path4.default.sep)) directoryPath = directoryPath.slice(0, -1);
+  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);
   files.forEach((file) => {
@@ -597,97 +609,172 @@ async function uploadDirectory(directoryPath, deviceId) {
       filename: file.name
     });
   });
-  formData.append("uid", deviceId);
   const spinner = (0, import_ora.default)(`Uploading ${directoryPath} to glitter ipfs...`).start();
-  const response = await import_axios.default.post(`${ipfsApiUrl}/add`, formData, {
-    headers: {
-      ...formData.getHeaders()
+  try {
+    const response = await import_axios.default.post(
+      `${ipfsApiUrl}/add?uid=${deviceId}&cidV=1`,
+      formData,
+      {
+        headers: {
+          ...formData.getHeaders()
+        }
+      }
+    );
+    const resData = response.data.data;
+    if (Array.isArray(resData) && resData.length > 0) {
+      const directoryItem = resData.find((item) => item.Name === dist);
+      if (directoryItem) {
+        spinner.succeed(
+          `Successfully uploaded ${directoryPath} to glitter ipfs`
+        );
+        const fileStats = import_fs_extra3.default.statSync(directoryPath);
+        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 resData = response.data.data;
-  if (Array.isArray(resData) && resData.length > 0) {
-    spinner.succeed();
-    const directoryItem = resData.find((item) => item.Name === dist);
-    if (directoryItem) {
-      const fileStats = import_fs_extra3.default.statSync(directoryPath);
-      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
-      };
-      saveUploadHistory(uploadData);
-      return directoryItem.Hash;
+    return null;
+  } catch (error) {
+    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;
+      }
     }
-    spinner.fail();
-    console.log(import_chalk2.default.red(`Directory hash not found in response`));
-  } else {
-    spinner.fail();
-    console.log(import_chalk2.default.red(`Invalid response format from IPFS`));
+    spinner.fail(`Error: ${error.message}`);
+    console.log(import_chalk2.default.red(`Error: ${error.message}`));
+    return null;
   }
-  return null;
 }
 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)})`);
+    throw new Error(
+      `File ${filePath} exceeds size limit of ${formatSize(
+        sizeCheck.limit
+      )} (size: ${formatSize(sizeCheck.size)})`
+    );
   }
-  const formData = new import_form_data.default();
-  formData.append("file", import_fs_extra3.default.createReadStream(filePath), {
-    filename: filePath.split(import_path4.default.sep).pop() || ""
-  });
-  formData.append("uid", deviceId);
   const spinner = (0, import_ora.default)(`Uploading ${filePath} to glitter ipfs...`).start();
-  const response = await import_axios.default.post(`${ipfsApiUrl}/add`, formData, {
-    headers: {
-      ...formData.getHeaders()
+  try {
+    const formData = new import_form_data.default();
+    formData.append("file", import_fs_extra3.default.createReadStream(filePath), {
+      filename: filePath.split(import_path4.default.sep).pop() || ""
+    });
+    const response = await import_axios.default.post(
+      `${ipfsApiUrl}/add?uid=${deviceId}&cidV=1`,
+      formData,
+      {
+        headers: {
+          ...formData.getHeaders()
+        }
+      }
+    );
+    console.log(import_chalk2.default.cyan(JSON.stringify(response)));
+    const resData = response.data.data;
+    if (Array.isArray(resData) && resData.length > 0) {
+      const fileItem = resData.find(
+        (item) => item.Name === filePath.split(import_path4.default.sep).pop() || ""
+      );
+      if (fileItem) {
+        spinner.succeed(`Successfully uploaded ${filePath} to glitter ipfs`);
+        const uploadData = {
+          path: filePath,
+          filename: filePath.split(import_path4.default.sep).pop() || "",
+          contentHash: fileItem.Hash,
+          previewHash: null,
+          size: sizeCheck.size,
+          fileCount: 1,
+          isDirectory: false,
+          shortUrl: fileItem.ShortUrl || null
+        };
+        saveUploadHistory(uploadData);
+        return {
+          hash: fileItem.Hash,
+          shortUrl: fileItem.ShortUrl
+        };
+      }
+      spinner.fail(`File hash not found in response`);
+      console.log(import_chalk2.default.red(`File hash not found in response`));
+    } else {
+      spinner.fail(`Invalid response format from IPFS`);
+      console.log(import_chalk2.default.red(`Invalid response format from IPFS`));
     }
-  });
-  const resData = response.data.data;
-  if (Array.isArray(resData) && resData.length > 0) {
-    spinner.succeed();
-    const fileItem = resData.find((item) => item.Name === filePath.split(import_path4.default.sep).pop() || "");
-    if (fileItem) {
-      const uploadData = {
-        path: filePath,
-        filename: filePath.split(import_path4.default.sep).pop() || "",
-        contentHash: fileItem.Hash,
-        previewHash: null,
-        size: sizeCheck.size,
-        fileCount: 1,
-        isDirectory: false
-      };
-      saveUploadHistory(uploadData);
-      return fileItem.Hash;
+    return null;
+  } catch (error) {
+    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;
+      }
     }
-    spinner.fail();
-    console.log(import_chalk2.default.red(`File hash not found in response`));
-  } else {
-    spinner.fail();
-    console.log(import_chalk2.default.red(`Invalid response format from IPFS`));
+    spinner.fail(`Error: ${error.message}`);
+    console.log(import_chalk2.default.red(`Error: ${error.message}`));
+    return null;
   }
-  return null;
 }
 async function uploadToIpfs_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()) {
-    return {
-      contentHash: await uploadDirectory(filePath, deviceId) || "",
-      previewHash: null
-    };
+    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 || "";
+    }
+  }
+  if (contentHash) {
     return {
-      contentHash: await uploadFile(filePath, deviceId) || "",
-      previewHash: null
+      contentHash,
+      previewHash: null,
+      shortUrl
     };
   }
+  return null;
 }
 
 // bin/upload.ts
@@ -743,15 +830,15 @@ var upload_default = async (options) => {
         const result = await uploadToIpfs_default(absolutePath);
         if (result) {
           const encryptedCID = encryptHash(result.contentHash, secretKey);
-          console.log(import_chalk3.default.cyan(
-            import_figlet.default.textSync("Successful", { horizontalLayout: "full" })
-          ));
+          console.log(
+            import_chalk3.default.cyan(
+              import_figlet.default.textSync("Successful", { horizontalLayout: "full" })
+            )
+          );
           console.log(import_chalk3.default.cyan(`URL: ${URL2}${encryptedCID}`));
-        } else {
-          console.log(import_chalk3.default.red(`upload failed`));
         }
       } catch (error) {
-        console.error(import_chalk3.default.red(`error uploading: ${error.message}`));
+        console.error(import_chalk3.default.red(`Error: ${error.message}`));
       }
       return;
     }
@@ -773,15 +860,15 @@ var upload_default = async (options) => {
         const result = await uploadToIpfs_default(absolutePath);
         if (result) {
           const encryptedCID = encryptHash(result.contentHash, secretKey);
-          console.log(import_chalk3.default.cyan(
-            import_figlet.default.textSync("Successful", { horizontalLayout: "full" })
-          ));
+          console.log(
+            import_chalk3.default.cyan(
+              import_figlet.default.textSync("Successful", { horizontalLayout: "full" })
+            )
+          );
           console.log(import_chalk3.default.cyan(`URL: ${URL2}${encryptedCID}`));
-        } else {
-          console.log(import_chalk3.default.red(`upload failed`));
         }
       } catch (error) {
-        console.error(import_chalk3.default.red(`error uploading: ${error.message}`));
+        console.error(import_chalk3.default.red(`Error: ${error.message}`));
       }
     }
   } catch (error) {

package/package.json

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