pinme 1.0.0 → 1.0.2

package/README.md

@@ -1,8 +1,8 @@
-# Pinme CLI
+# PinMe
 
-A simple and easy-to-use command-line tool for uploading files and directories to the IPFS network.
+[PinMe](https://pinme.eth.limo/) is a simple and easy-to-use command-line tool for uploading files and directories to the [IPFS](https://ipfs.tech/) network.
 
-![Pinme CLI](https://via.placeholder.com/800x200?text=Pinme+CLI)
+Website：[https://pinme.eth.limo/](https://pinme.eth.limo/)
 
 ## Features
 
@@ -17,13 +17,13 @@ A simple and easy-to-use command-line tool for uploading files and directories t
 ### Using npm
 
 ```bash
-npm install -g @glitterprotocol/pinme
+npm install -g pinme
 ```
 
 ### Using yarn
 
 ```bash
-yarn global add @glitterprotocol/pinme
+yarn global add pinme
 ```
 
 ## Usage
@@ -59,9 +59,6 @@ pinme list -c
 ```bash
 # Display help information
 pinme help
-
-# Display help for a specific command
-pinme help upload
 ```
 
 ## Command Details
@@ -129,9 +126,6 @@ pinme help [command]
 ```bash
 # Display general help
 pinme help
-
-# Display help for the upload command
-pinme help upload
 ```
 
 ## Upload Limits
@@ -146,45 +140,12 @@ Uploaded files are stored on the IPFS network and accessible through the Glitter
 1. IPFS hash value
 2. Accessible URL link
 
-## Data Privacy
-
-- Upload history is stored locally (`~/.pinme/upload-history.json`)
-- Device ID is stored locally (`~/.pinme/device-id.json`)
-- All content uploaded to IPFS is public, do not upload sensitive information
-
-## Troubleshooting
-
-### Common Issues
-
-1. **Upload Failure**
-   - Check network connection
-   - Confirm the file/directory exists and has read permissions
-   - Confirm the file size does not exceed limits
-
-2. **Command Not Found**
-   - Confirm global installation was successful
-   - Check PATH environment variable
-   - Try reinstalling
-
-3. **History Not Displaying**
-   - Check if the `~/.pinme` directory exists
-   - Confirm read/write permissions
-
 ### Log Locations
 
 Logs and configuration files are stored in:
 - Linux/macOS: `~/.pinme/`
 - Windows: `%USERPROFILE%\.pinme\`
 
-## Contribution Guidelines
-
-Contributions of code, issue reports, or improvement suggestions are welcome! Please follow these steps:
-
-1. Fork the repository
-2. Create a feature branch (`git checkout -b feature/amazing-feature`)
-3. Commit your changes (`git commit -m 'Add some amazing feature'`)
-4. Push to the branch (`git push origin feature/amazing-feature`)
-5. Create a Pull Request
 
 ## License
 
@@ -194,9 +155,9 @@ MIT License - See the [LICENSE](LICENSE) file for details
 
 If you have questions or suggestions, please contact us through:
 
-- GitHub Issues: [https://github.com/glitterprotocol/pinme-cli/issues](https://github.com/glitterprotocol/pinme-cli/issues)
-- Email: [support@example.com](mailto:support@example.com)
+- GitHub Issues: [https://github.com/glitternetwork/pinme/issues](https://github.com/glitternetwork/pinme/issue)
+- Email: [pinme@glitterprotocol.io](mailto:pinme@glitterprotocol.io)
 
 ---
 
-Developed and maintained by the [Glitter Protocol](https://github.com/glitterprotocol) team
+Developed and maintained by the [Glitter Protocol](https://glitterprotocol.io/) team

package/dist/index.js

@@ -1,2 +1,838 @@
 #!/usr/bin/env node
-"use strict";var e=require("commander"),o=require("chalk"),t=require("figlet"),r=require("path"),i=require("inquirer");require("ethers"),require("bip39");var s=require("axios"),n=require("fs-extra"),a=require("form-data"),l=require("ora"),c=require("os"),d=require("uuid"),u=require("fs"),p=require("dayjs"),f=require("crypto-js");function h(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var y=h(e),m=h(o),g=h(t),S=h(r),$=h(i),v=h(s),z=h(n),w=h(a),H=h(l),x=h(c),F=h(d),I=h(u),L=h(p),D=h(f);const E=z.default,U=S.default,b=x.default,{v4:q}=F.default,j=U.join(b.homedir(),".pinme"),k=U.join(j,"device-id.json");var T={getDeviceId:function(){try{if(E.existsSync(j)||E.mkdirSync(j,{recursive:!0}),E.existsSync(k)){const e=E.readJsonSync(k);if(e&&e.deviceId)return e.deviceId}const e=q();return E.writeJsonSync(k,{deviceId:e,createdAt:(new Date).toISOString()},{spaces:2}),e}catch(e){return console.error(`Error getting device ID: ${e.message}`),q()}}};const C=I.default,J=S.default,M=10485760,P=524288e3,R=e=>{let o=0;const t=C.readdirSync(e);for(const r of t){const t=J.join(e,r),i=C.statSync(t);i.isFile()?o+=i.size:i.isDirectory()&&(o+=R(t))}return o};var A={checkFileSizeLimit:e=>{const o=C.statSync(e).size;return{size:o,exceeds:o>M,limit:M}},checkDirectorySizeLimit:e=>{let o=0,t={path:"",size:0},r=!1;const i=e=>{const s=C.readdirSync(e);for(const n of s){const s=J.join(e,n),a=C.statSync(s);a.isFile()?(o+=a.size,a.size>t.size&&(t={path:s,size:a.size}),a.size>M&&(r=!0)):a.isDirectory()&&i(s)}};return i(e),{totalSize:o,hasExceeded:r,largestFile:t,exceedsTotalLimit:o>P,limit:M,totalLimit:P}},calculateDirectorySize:R,formatSize:e=>e<1024?e+" B":e<1048576?(e/1024).toFixed(2)+" KB":e<1073741824?(e/1048576).toFixed(2)+" MB":(e/1073741824).toFixed(2)+" GB",SINGLE_FILE_LIMIT:M,TOTAL_SIZE_LIMIT:P};const B=z.default,_=S.default,N=x.default,W=L.default,Y=m.default,{formatSize:O}=A,Q=_.join(N.homedir(),".pinme"),Z=_.join(Q,"upload-history.json"),G=()=>{B.existsSync(Q)||B.mkdirSync(Q,{recursive:!0}),B.existsSync(Z)||B.writeJsonSync(Z,{uploads:[]})},K=(e=10)=>{try{G();return B.readJsonSync(Z).uploads.slice(0,e)}catch(e){return console.error(Y.red(`Error reading upload history: ${e.message}`)),[]}};var V={saveUploadHistory:e=>{try{G();const o=B.readJsonSync(Z),t={timestamp:Date.now(),date:W().format("YYYY-MM-DD HH:mm:ss"),path:e.path,filename:e.filename||_.basename(e.path),contentHash:e.contentHash,previewHash:e.previewHash,size:e.size,fileCount:e.fileCount||1,type:e.isDirectory?"directory":"file"};return o.uploads.unshift(t),B.writeJsonSync(Z,o,{spaces:2}),!0}catch(e){return console.error(Y.red(`Error saving upload history: ${e.message}`)),!1}},getUploadHistory:K,displayUploadHistory:(e=10)=>{const o=K(e);if(0===o.length)return void console.log(Y.yellow("No upload history found."));console.log(Y.bold("\n📜 Upload History:")),console.log(Y.dim("─".repeat(80))),o.forEach(((e,o)=>{console.log(Y.bold(`#${o+1} - ${e.date}`)),console.log(Y.cyan(`Name: ${e.filename}`)),console.log(Y.cyan(`Path: ${e.path}`)),console.log(Y.cyan(`Type: ${e.type}`)),console.log(Y.cyan(`Size: ${O(e.size)}`)),"directory"===e.type&&console.log(Y.cyan(`Files: ${e.fileCount}`)),console.log(Y.cyan(`Content Hash: ${e.contentHash}`)),e.previewHash?(console.log(Y.cyan(`Preview Hash: ${e.previewHash}`)),console.log(Y.cyan(`URL: https://ipfs.glitterprotocol.dev/ipfs/${e.previewHash}/#/?from=local`))):console.log(Y.cyan(`URL: https://ipfs.glitterprotocol.dev/ipfs/${e.contentHash}`)),console.log(Y.dim("─".repeat(80)))}));const t=o.reduce(((e,o)=>e+o.size),0),r=o.reduce(((e,o)=>e+o.fileCount),0);console.log(Y.bold(`Total Uploads: ${o.length}`)),console.log(Y.bold(`Total Files: ${r}`)),console.log(Y.bold(`Total Size: ${O(t)}`))},clearUploadHistory:()=>{try{return G(),B.writeJsonSync(Z,{uploads:[]}),console.log(Y.green("Upload history cleared successfully.")),!0}catch(e){return console.error(Y.red(`Error clearing upload history: ${e.message}`)),!1}}};const X=v.default,ee=z.default,oe=S.default,te=w.default,re=H.default,ie=m.default,se=x.default,{getDeviceId:ne}=T,{checkFileSizeLimit:ae,checkDirectorySizeLimit:le,calculateDirectorySize:ce,formatSize:de,TOTAL_SIZE_LIMIT:ue}=A,{saveUploadHistory:pe}=V;oe.join(se.homedir(),".pinme","upload-history.json");const fe="https://ipfs.glitterprotocol.dev/api/v2";let he=null;function ye(e,o){const t=[],r=oe.sep;if(he??=e.replace(o,""),ee.statSync(e).isDirectory()){ee.readdirSync(e).forEach((i=>{const s=oe.join(e,i);if(ee.statSync(s).isFile()){const e=ae(s);if(e.exceeds)throw new Error(`File ${i} exceeds size limit of ${e.limit/1048576}MB (size: ${e.size/1048576}MB)`);const o=s.replace(he,"").replaceAll(r,"%2F");t.push({name:o,path:s})}else if(ee.statSync(s).isDirectory()){const e=ye(s,o);t.push(...e)}}))}else console.error("Error: path must be a directory");return t}const me=e=>{let o=0;const t=e=>{const r=ee.readdirSync(e);for(const i of r){const r=oe.join(e,i),s=ee.statSync(r);s.isFile()?o++:s.isDirectory()&&t(r)}};return t(e),o};async function ge(e,o){const t=le(e);if(t.hasExceeded)throw new Error(`File ${t.largestFile.path} exceeds size limit of ${de(t.limit)} (size: ${de(t.largestFile.size)})`);if(t.exceedsTotalLimit)throw new Error(`Total directory size ${de(t.totalSize)} exceeds the limit of ${de(t.totalLimit)}`);const r=new te;e.endsWith(oe.sep)&&(e=e.slice(0,-1));const i=e.split(oe.sep).pop();ye(e,i).forEach((e=>{r.append("file",ee.createReadStream(e.path),{filename:e.name})}));const s=re(`Uploading ${e} to glitter ipfs...`).start(),n=(await X.post(`${fe}/add`,r,{headers:{...r.getHeaders(),uid:o}})).data.data;if(Array.isArray(n)&&n.length>0){s.succeed();const o=n.find((e=>e.Name===i));if(o){ee.statSync(e);const r=me(e),i={path:e,filename:oe.basename(e),contentHash:o.Hash,previewHash:null,size:t.totalSize,fileCount:r,isDirectory:!0};return pe(i),o.Hash}s.fail(),console.log(ie.red("Directory hash not found in response"))}else s.fail(),console.log(ie.red("Invalid response format from IPFS"));return null}var Se=async function(e){try{const o=ne();let t;return t=ee.statSync(e).isDirectory()?await ge(e,o):await async function(e,o){const t=ae(e);if(t.exceeds)throw new Error(`File exceeds size limit of ${de(t.limit)} (size: ${de(t.size)})`);const r=new te;r.append("file",ee.createReadStream(e));const i=re(`Uploading ${e} to glitter ipfs...`).start(),s=(await X.post(`${fe}/add`,r,{headers:{...r.getHeaders(),uid:o}})).data.data;if(s){i.succeed();const o=ee.statSync(e),t=1,r={path:e,filename:oe.basename(e),contentHash:s[0].Hash,previewHash:null,size:o.size,fileCount:t,isDirectory:!1};return pe(r),s[0].Hash}return i.fail(),console.log(ie.red("Invalid response format from IPFS")),null}(e,o),{contentHash:t}}catch(e){return console.log(ie.red(`${e}`)),null}};const $e=S.default,ve=m.default,ze=$.default,we=g.default,He=Se,xe=I.default,Fe=D.default,Ie="https://ipfs.glitterprotocol.dev/ipfs/QmRumtELULDtHJeJVUF1nthQnWLQ81DWCFpXikZS3WeEtU/#/preview/",Le="pinme-secret-key";function De(e,o){try{const t=Fe.RC4.encrypt(e,o).toString();return t.replace(/\+/g,"-").replace(/\//g,"_").replace(/=+$/,"")}catch(o){return console.error(`Encryption error: ${o.message}`),e}}function Ee(e){try{const o=$e.resolve(e);return xe.existsSync(o)?o:null}catch(e){return console.error(ve.red(`error checking path: ${e.message}`)),null}}var Ue="1.0.0";const be=y.default,qe=m.default,je=g.default,ke=async e=>{try{console.log(we.textSync("PINME",{font:"Shadow",horizontalLayout:"default",verticalLayout:"default",width:180,whitespaceBreak:!0}));const e=process.argv[3];if(e&&!e.startsWith("-")){const o=Ee(e);if(!o)return void console.log(ve.red(`path ${e} does not exist`));console.log(ve.blue(`uploading ${o} to ipfs...`));try{const e=await He(o);if(e){const o=De(e.contentHash,Le);console.log(ve.cyan(we.textSync("Successful",{horizontalLayout:"full"}))),console.log(ve.cyan(`URL: ${Ie}${o}`))}else console.log(ve.red("upload failed"))}catch(e){console.error(ve.red(`error uploading: ${e.message}`)),console.error(e.stack)}return}const o=await ze.prompt([{type:"input",name:"path",message:"path to upload: "}]);if(o.path){const e=Ee(o.path);if(!e)return void console.log(ve.red(`path ${o.path} does not exist`));console.log(ve.blue(`uploading ${e} to ipfs...`));try{const o=await He(e);if(o){const e=De(o.contentHash,Le);console.log(ve.cyan(we.textSync("Successful",{horizontalLayout:"full"}))),console.log(ve.cyan(`IPFS Hash: ${o.contentHash}`)),console.log(ve.cyan(`URL: ${Ie}${e}`))}else console.log(ve.red("upload failed"))}catch(e){console.error(ve.red(`error uploading: ${e.message}`)),console.error(e.stack)}}}catch(e){console.error(ve.red(`error executing: ${e.message}`)),console.error(e.stack)}},{displayUploadHistory:Te,clearUploadHistory:Ce}=V;function Je(){console.log(qe.cyan(je.textSync("Pinme",{horizontalLayout:"full"}))),console.log(qe.cyan("A command-line tool for uploading files to IPFS\n"))}be.name("pinme").version(Ue).option("-v, --version","output the current version"),be.command("upload").description("upload a file or directory to IPFS").action((()=>ke())),be.command("list").description("show upload history").option("-l, --limit <number>","limit the number of records to show",parseInt).option("-c, --clear","clear all upload history").action((e=>{e.clear?Ce():Te(e.limit||10)})),be.command("ls").description("alias for 'list' command").option("-l, --limit <number>","limit the number of records to show",parseInt).option("-c, --clear","clear all upload history").action((e=>{e.clear?Ce():Te(e.limit||10)})),be.command("help").description("display help information").action((()=>{Je(),be.help()})),be.on("--help",(()=>{console.log(""),console.log("Examples:"),console.log("  $ pinme upload"),console.log("  $ pinme list -l 5"),console.log("  $ pinme ls"),console.log("  $ pinme help"),console.log(""),console.log("For more information, visit: https://github.com/glitterprotocol/pinme-cli")})),be.parse(process.argv),2===process.argv.length&&(Je(),be.help()),module.exports={};
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/.pnpm/dotenv@16.5.0/node_modules/dotenv/package.json
+var require_package = __commonJS({
+  "node_modules/.pnpm/dotenv@16.5.0/node_modules/dotenv/package.json"(exports2, module2) {
+    module2.exports = {
+      name: "dotenv",
+      version: "16.5.0",
+      description: "Loads environment variables from .env file",
+      main: "lib/main.js",
+      types: "lib/main.d.ts",
+      exports: {
+        ".": {
+          types: "./lib/main.d.ts",
+          require: "./lib/main.js",
+          default: "./lib/main.js"
+        },
+        "./config": "./config.js",
+        "./config.js": "./config.js",
+        "./lib/env-options": "./lib/env-options.js",
+        "./lib/env-options.js": "./lib/env-options.js",
+        "./lib/cli-options": "./lib/cli-options.js",
+        "./lib/cli-options.js": "./lib/cli-options.js",
+        "./package.json": "./package.json"
+      },
+      scripts: {
+        "dts-check": "tsc --project tests/types/tsconfig.json",
+        lint: "standard",
+        pretest: "npm run lint && npm run dts-check",
+        test: "tap run --allow-empty-coverage --disable-coverage --timeout=60000",
+        "test:coverage": "tap run --show-full-coverage --timeout=60000 --coverage-report=lcov",
+        prerelease: "npm test",
+        release: "standard-version"
+      },
+      repository: {
+        type: "git",
+        url: "git://github.com/motdotla/dotenv.git"
+      },
+      homepage: "https://github.com/motdotla/dotenv#readme",
+      funding: "https://dotenvx.com",
+      keywords: [
+        "dotenv",
+        "env",
+        ".env",
+        "environment",
+        "variables",
+        "config",
+        "settings"
+      ],
+      readmeFilename: "README.md",
+      license: "BSD-2-Clause",
+      devDependencies: {
+        "@types/node": "^18.11.3",
+        decache: "^4.6.2",
+        sinon: "^14.0.1",
+        standard: "^17.0.0",
+        "standard-version": "^9.5.0",
+        tap: "^19.2.0",
+        typescript: "^4.8.4"
+      },
+      engines: {
+        node: ">=12"
+      },
+      browser: {
+        fs: false
+      }
+    };
+  }
+});
+
+// node_modules/.pnpm/dotenv@16.5.0/node_modules/dotenv/lib/main.js
+var require_main = __commonJS({
+  "node_modules/.pnpm/dotenv@16.5.0/node_modules/dotenv/lib/main.js"(exports2, module2) {
+    var fs6 = require("fs");
+    var path6 = require("path");
+    var os3 = require("os");
+    var crypto = 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;
+    function parse(src) {
+      const obj = {};
+      let lines = src.toString();
+      lines = lines.replace(/\r\n?/mg, "\n");
+      let match;
+      while ((match = LINE.exec(lines)) != null) {
+        const key = match[1];
+        let value = match[2] || "";
+        value = value.trim();
+        const maybeQuote = value[0];
+        value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
+        if (maybeQuote === '"') {
+          value = value.replace(/\\n/g, "\n");
+          value = value.replace(/\\r/g, "\r");
+        }
+        obj[key] = value;
+      }
+      return obj;
+    }
+    function _parseVault(options) {
+      const vaultPath = _vaultPath(options);
+      const result = DotenvModule.configDotenv({ path: vaultPath });
+      if (!result.parsed) {
+        const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+        err.code = "MISSING_DATA";
+        throw err;
+      }
+      const keys = _dotenvKey(options).split(",");
+      const length = keys.length;
+      let decrypted;
+      for (let i = 0; i < length; i++) {
+        try {
+          const key = keys[i].trim();
+          const attrs = _instructions(result, key);
+          decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+          break;
+        } catch (error) {
+          if (i + 1 >= length) {
+            throw error;
+          }
+        }
+      }
+      return DotenvModule.parse(decrypted);
+    }
+    function _warn(message) {
+      console.log(`[dotenv@${version2}][WARN] ${message}`);
+    }
+    function _debug(message) {
+      console.log(`[dotenv@${version2}][DEBUG] ${message}`);
+    }
+    function _dotenvKey(options) {
+      if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+        return options.DOTENV_KEY;
+      }
+      if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+        return process.env.DOTENV_KEY;
+      }
+      return "";
+    }
+    function _instructions(result, dotenvKey) {
+      let uri;
+      try {
+        uri = new URL(dotenvKey);
+      } catch (error) {
+        if (error.code === "ERR_INVALID_URL") {
+          const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        }
+        throw error;
+      }
+      const key = uri.password;
+      if (!key) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing key part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environment = uri.searchParams.get("environment");
+      if (!environment) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+      const ciphertext = result.parsed[environmentKey];
+      if (!ciphertext) {
+        const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+        err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+        throw err;
+      }
+      return { ciphertext, key };
+    }
+    function _vaultPath(options) {
+      let possibleVaultPath = null;
+      if (options && options.path && options.path.length > 0) {
+        if (Array.isArray(options.path)) {
+          for (const filepath of options.path) {
+            if (fs6.existsSync(filepath)) {
+              possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+            }
+          }
+        } else {
+          possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+        }
+      } else {
+        possibleVaultPath = path6.resolve(process.cwd(), ".env.vault");
+      }
+      if (fs6.existsSync(possibleVaultPath)) {
+        return possibleVaultPath;
+      }
+      return null;
+    }
+    function _resolveHome(envPath) {
+      return envPath[0] === "~" ? path6.join(os3.homedir(), envPath.slice(1)) : envPath;
+    }
+    function _configVault(options) {
+      const debug = Boolean(options && options.debug);
+      if (debug) {
+        _debug("Loading env from encrypted .env.vault");
+      }
+      const parsed = DotenvModule._parseVault(options);
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      DotenvModule.populate(processEnv, parsed, options);
+      return { parsed };
+    }
+    function configDotenv(options) {
+      const dotenvPath = path6.resolve(process.cwd(), ".env");
+      let encoding = "utf8";
+      const debug = Boolean(options && options.debug);
+      if (options && options.encoding) {
+        encoding = options.encoding;
+      } else {
+        if (debug) {
+          _debug("No encoding is specified. UTF-8 is used by default");
+        }
+      }
+      let optionPaths = [dotenvPath];
+      if (options && options.path) {
+        if (!Array.isArray(options.path)) {
+          optionPaths = [_resolveHome(options.path)];
+        } else {
+          optionPaths = [];
+          for (const filepath of options.path) {
+            optionPaths.push(_resolveHome(filepath));
+          }
+        }
+      }
+      let lastError;
+      const parsedAll = {};
+      for (const path7 of optionPaths) {
+        try {
+          const parsed = DotenvModule.parse(fs6.readFileSync(path7, { encoding }));
+          DotenvModule.populate(parsedAll, parsed, options);
+        } catch (e) {
+          if (debug) {
+            _debug(`Failed to load ${path7} ${e.message}`);
+          }
+          lastError = e;
+        }
+      }
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      DotenvModule.populate(processEnv, parsedAll, options);
+      if (lastError) {
+        return { parsed: parsedAll, error: lastError };
+      } else {
+        return { parsed: parsedAll };
+      }
+    }
+    function config(options) {
+      if (_dotenvKey(options).length === 0) {
+        return DotenvModule.configDotenv(options);
+      }
+      const vaultPath = _vaultPath(options);
+      if (!vaultPath) {
+        _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+        return DotenvModule.configDotenv(options);
+      }
+      return DotenvModule._configVault(options);
+    }
+    function decrypt(encrypted, keyStr) {
+      const key = Buffer.from(keyStr.slice(-64), "hex");
+      let ciphertext = Buffer.from(encrypted, "base64");
+      const nonce = ciphertext.subarray(0, 12);
+      const authTag = ciphertext.subarray(-16);
+      ciphertext = ciphertext.subarray(12, -16);
+      try {
+        const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+        aesgcm.setAuthTag(authTag);
+        return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+      } catch (error) {
+        const isRange = error instanceof RangeError;
+        const invalidKeyLength = error.message === "Invalid key length";
+        const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+        if (isRange || invalidKeyLength) {
+          const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        } else if (decryptionFailed) {
+          const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+          err.code = "DECRYPTION_FAILED";
+          throw err;
+        } else {
+          throw error;
+        }
+      }
+    }
+    function populate(processEnv, parsed, options = {}) {
+      const debug = Boolean(options && options.debug);
+      const override = Boolean(options && options.override);
+      if (typeof parsed !== "object") {
+        const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+        err.code = "OBJECT_REQUIRED";
+        throw err;
+      }
+      for (const key of Object.keys(parsed)) {
+        if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+          if (override === true) {
+            processEnv[key] = parsed[key];
+          }
+          if (debug) {
+            if (override === true) {
+              _debug(`"${key}" is already defined and WAS overwritten`);
+            } else {
+              _debug(`"${key}" is already defined and was NOT overwritten`);
+            }
+          }
+        } else {
+          processEnv[key] = parsed[key];
+        }
+      }
+    }
+    var DotenvModule = {
+      configDotenv,
+      _configVault,
+      _parseVault,
+      config,
+      decrypt,
+      parse,
+      populate
+    };
+    module2.exports.configDotenv = DotenvModule.configDotenv;
+    module2.exports._configVault = DotenvModule._configVault;
+    module2.exports._parseVault = DotenvModule._parseVault;
+    module2.exports.config = DotenvModule.config;
+    module2.exports.decrypt = DotenvModule.decrypt;
+    module2.exports.parse = DotenvModule.parse;
+    module2.exports.populate = DotenvModule.populate;
+    module2.exports = DotenvModule;
+  }
+});
+
+// bin/index.ts
+var import_dotenv = __toESM(require_main());
+var import_commander = require("commander");
+var import_chalk4 = __toESM(require("chalk"));
+var import_figlet2 = __toESM(require("figlet"));
+
+// package.json
+var version = "1.0.2";
+
+// bin/upload.ts
+var import_path5 = __toESM(require("path"));
+var import_chalk3 = __toESM(require("chalk"));
+var import_inquirer = __toESM(require("inquirer"));
+var import_figlet = __toESM(require("figlet"));
+
+// bin/utils/uploadToIpfs.ts
+var import_axios = __toESM(require("axios"));
+var import_fs_extra3 = __toESM(require("fs-extra"));
+var import_path4 = __toESM(require("path"));
+var import_form_data = __toESM(require("form-data"));
+var import_ora = __toESM(require("ora"));
+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 DIRECTORY_SIZE_LIMIT = parseInt("500", 10) * 1024 * 1024;
+function checkFileSizeLimit(filePath) {
+  const stats = import_fs.default.statSync(filePath);
+  return {
+    size: stats.size,
+    limit: FILE_SIZE_LIMIT,
+    exceeds: stats.size > FILE_SIZE_LIMIT
+  };
+}
+function checkDirectorySizeLimit(directoryPath) {
+  const totalSize = calculateDirectorySize(directoryPath);
+  return {
+    size: totalSize,
+    limit: DIRECTORY_SIZE_LIMIT,
+    exceeds: totalSize > DIRECTORY_SIZE_LIMIT
+  };
+}
+function calculateDirectorySize(directoryPath) {
+  let totalSize = 0;
+  const files = import_fs.default.readdirSync(directoryPath);
+  for (const file of files) {
+    const filePath = import_path.default.join(directoryPath, file);
+    const stats = import_fs.default.statSync(filePath);
+    if (stats.isFile()) {
+      totalSize += stats.size;
+    } else if (stats.isDirectory()) {
+      totalSize += calculateDirectorySize(filePath);
+    }
+  }
+  return totalSize;
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return bytes + " bytes";
+  else if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(2) + " KB";
+  else if (bytes < 1024 * 1024 * 1024) return (bytes / (1024 * 1024)).toFixed(2) + " MB";
+  else return (bytes / (1024 * 1024 * 1024)).toFixed(2) + " GB";
+}
+
+// bin/utils/history.ts
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_path2 = __toESM(require("path"));
+var import_os = __toESM(require("os"));
+var import_dayjs = __toESM(require("dayjs"));
+var import_chalk = __toESM(require("chalk"));
+var HISTORY_DIR = import_path2.default.join(import_os.default.homedir(), ".pinme");
+var HISTORY_FILE = import_path2.default.join(HISTORY_DIR, "upload-history.json");
+var ensureHistoryDir = () => {
+  if (!import_fs_extra.default.existsSync(HISTORY_DIR)) {
+    import_fs_extra.default.mkdirSync(HISTORY_DIR, { recursive: true });
+  }
+  if (!import_fs_extra.default.existsSync(HISTORY_FILE)) {
+    import_fs_extra.default.writeJsonSync(HISTORY_FILE, { uploads: [] });
+  }
+};
+var saveUploadHistory = (uploadData) => {
+  try {
+    ensureHistoryDir();
+    const history = import_fs_extra.default.readJsonSync(HISTORY_FILE);
+    const newRecord = {
+      timestamp: Date.now(),
+      date: (0, import_dayjs.default)().format("YYYY-MM-DD HH:mm:ss"),
+      path: uploadData.path,
+      filename: uploadData.filename || import_path2.default.basename(uploadData.path),
+      contentHash: uploadData.contentHash,
+      previewHash: uploadData.previewHash,
+      size: uploadData.size,
+      fileCount: uploadData.fileCount || 1,
+      type: uploadData.isDirectory ? "directory" : "file"
+    };
+    history.uploads.unshift(newRecord);
+    import_fs_extra.default.writeJsonSync(HISTORY_FILE, history, { spaces: 2 });
+    return true;
+  } catch (error) {
+    console.error(import_chalk.default.red(`Error saving upload history: ${error.message}`));
+    return false;
+  }
+};
+var getUploadHistory = (limit = 10) => {
+  try {
+    ensureHistoryDir();
+    const history = import_fs_extra.default.readJsonSync(HISTORY_FILE);
+    return history.uploads.slice(0, limit);
+  } catch (error) {
+    console.error(import_chalk.default.red(`Error reading upload history: ${error.message}`));
+    return [];
+  }
+};
+var displayUploadHistory = (limit = 10) => {
+  const history = getUploadHistory(limit);
+  if (history.length === 0) {
+    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(`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.dim("\u2500".repeat(80)));
+  });
+  const totalSize = history.reduce((sum, record) => sum + record.size, 0);
+  const totalFiles = history.reduce((sum, record) => sum + record.fileCount, 0);
+  console.log(import_chalk.default.bold(`Total Uploads: ${history.length}`));
+  console.log(import_chalk.default.bold(`Total Files: ${totalFiles}`));
+  console.log(import_chalk.default.bold(`Total Size: ${formatSize(totalSize)}`));
+};
+var clearUploadHistory = () => {
+  try {
+    ensureHistoryDir();
+    import_fs_extra.default.writeJsonSync(HISTORY_FILE, { uploads: [] });
+    console.log(import_chalk.default.green("Upload history cleared successfully."));
+    return true;
+  } catch (error) {
+    console.error(import_chalk.default.red(`Error clearing upload history: ${error.message}`));
+    return false;
+  }
+};
+
+// bin/utils/getDeviceId.ts
+var import_fs_extra2 = __toESM(require("fs-extra"));
+var import_path3 = __toESM(require("path"));
+var import_os2 = __toESM(require("os"));
+var import_uuid = require("uuid");
+function getDeviceId() {
+  const configDir = import_path3.default.join(import_os2.default.homedir(), ".pinme");
+  const configFile = import_path3.default.join(configDir, "device-id");
+  if (!import_fs_extra2.default.existsSync(configDir)) {
+    import_fs_extra2.default.mkdirSync(configDir, { recursive: true });
+  }
+  if (import_fs_extra2.default.existsSync(configFile)) {
+    return import_fs_extra2.default.readFileSync(configFile, "utf8").trim();
+  }
+  const deviceId = (0, import_uuid.v4)();
+  import_fs_extra2.default.writeFileSync(configFile, deviceId);
+  return deviceId;
+}
+
+// bin/utils/uploadToIpfs.ts
+var ipfsApiUrl = "https://ipfs.glitterprotocol.dev/api/v2";
+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");
+  }
+  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);
+    }
+  }
+  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)})`);
+  }
+  const formData = new import_form_data.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);
+  files.forEach((file) => {
+    formData.append("file", import_fs_extra3.default.createReadStream(file.path), {
+      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()
+    }
+  });
+  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;
+    }
+    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`));
+  }
+  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)})`);
+  }
+  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()
+    }
+  });
+  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;
+    }
+    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`));
+  }
+  return null;
+}
+async function uploadToIpfs_default(filePath) {
+  const deviceId = getDeviceId();
+  if (!deviceId) {
+    throw new Error("Device ID not found");
+  }
+  if (import_fs_extra3.default.statSync(filePath).isDirectory()) {
+    return {
+      contentHash: await uploadDirectory(filePath, deviceId) || "",
+      previewHash: null
+    };
+  } else {
+    return {
+      contentHash: await uploadFile(filePath, deviceId) || "",
+      previewHash: null
+    };
+  }
+}
+
+// bin/upload.ts
+var import_fs2 = __toESM(require("fs"));
+var import_crypto_js = __toESM(require("crypto-js"));
+var URL2 = "https://pinme.eth.limo/#/preview/";
+var secretKey = "pinme-secret-key";
+function encryptHash(hash, key) {
+  try {
+    if (!key) {
+      throw new Error("Secret key not found");
+    }
+    const encrypted = import_crypto_js.default.RC4.encrypt(hash, key).toString();
+    const urlSafe = encrypted.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+    return urlSafe;
+  } catch (error) {
+    console.error(`Encryption error: ${error.message}`);
+    return hash;
+  }
+}
+function checkPathSync(inputPath) {
+  try {
+    const absolutePath = import_path5.default.resolve(inputPath);
+    if (import_fs2.default.existsSync(absolutePath)) {
+      return absolutePath;
+    }
+    return null;
+  } catch (error) {
+    console.error(import_chalk3.default.red(`error checking path: ${error.message}`));
+    return null;
+  }
+}
+var upload_default = async (options) => {
+  try {
+    console.log(
+      import_figlet.default.textSync("PINME", {
+        font: "Shadow",
+        horizontalLayout: "default",
+        verticalLayout: "default",
+        width: 180,
+        whitespaceBreak: true
+      })
+    );
+    const argPath = process.argv[3];
+    if (argPath && !argPath.startsWith("-")) {
+      const absolutePath = checkPathSync(argPath);
+      if (!absolutePath) {
+        console.log(import_chalk3.default.red(`path ${argPath} does not exist`));
+        return;
+      }
+      console.log(import_chalk3.default.blue(`uploading ${absolutePath} to ipfs...`));
+      try {
+        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(`URL: ${URL2}${encryptedCID}`));
+        } else {
+          console.log(import_chalk3.default.red(`upload failed`));
+        }
+      } catch (error) {
+        console.error(import_chalk3.default.red(`error uploading: ${error.message}`));
+      }
+      return;
+    }
+    const answer = await import_inquirer.default.prompt([
+      {
+        type: "input",
+        name: "path",
+        message: "path to upload: "
+      }
+    ]);
+    if (answer.path) {
+      const absolutePath = checkPathSync(answer.path);
+      if (!absolutePath) {
+        console.log(import_chalk3.default.red(`path ${answer.path} does not exist`));
+        return;
+      }
+      console.log(import_chalk3.default.blue(`uploading ${absolutePath} to ipfs...`));
+      try {
+        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(`URL: ${URL2}${encryptedCID}`));
+        } else {
+          console.log(import_chalk3.default.red(`upload failed`));
+        }
+      } catch (error) {
+        console.error(import_chalk3.default.red(`error uploading: ${error.message}`));
+      }
+    }
+  } catch (error) {
+    console.error(import_chalk3.default.red(`error executing: ${error.message}`));
+    console.error(error.stack);
+  }
+};
+
+// bin/index.ts
+import_dotenv.default.config();
+function showBanner() {
+  console.log(
+    import_chalk4.default.cyan(
+      import_figlet2.default.textSync("Pinme", { horizontalLayout: "full" })
+    )
+  );
+  console.log(import_chalk4.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");
+program.command("upload").description("upload a file or directory to IPFS").action(() => upload_default());
+program.command("list").description("show upload history").option("-l, --limit <number>", "limit the number of records to show", parseInt).option("-c, --clear", "clear all upload history").action((options) => {
+  if (options.clear) {
+    clearUploadHistory();
+  } else {
+    displayUploadHistory(options.limit || 10);
+  }
+});
+program.command("ls").description("alias for 'list' command").option("-l, --limit <number>", "limit the number of records to show", parseInt).option("-c, --clear", "clear all upload history").action((options) => {
+  if (options.clear) {
+    clearUploadHistory();
+  } else {
+    displayUploadHistory(options.limit || 10);
+  }
+});
+program.command("help").description("display help information").action(() => {
+  showBanner();
+  program.help();
+});
+program.on("--help", () => {
+  console.log("");
+  console.log("Examples:");
+  console.log("  $ pinme upload");
+  console.log("  $ pinme list -l 5");
+  console.log("  $ pinme ls");
+  console.log("  $ pinme help");
+  console.log("");
+  console.log("For more information, visit: https://github.com/glitternetwork/pinme");
+});
+program.parse(process.argv);
+if (process.argv.length === 2) {
+  showBanner();
+  program.help();
+}

package/package.json

@@ -1,18 +1,15 @@
 {
   "name": "pinme",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "publishConfig": {
     "access": "public"
   },
-  "description": "Pinme",
+  "description": "Deploy Your Frontend In a Single Command",
   "main": "dist/index.js",
   "scripts": {
-    "prebuild": "mkdir -p dist/utils",
-    "build": "rollup -c",
-    "dev": "rollup -c -w",
-    "prepublishOnly": "npm run build",
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "build:debug": "rollup -c --debug"
+    "build": "node build.js",
+    "dev": "NODE_ENV=development node build.js",
+    "prepublishOnly": "npm run build"
   },
   "bin": {
     "pinme": "./dist/index.js"
@@ -20,11 +17,15 @@
   "files": [
     "dist"
   ],
-  "keywords": [],
-  "author": "Ted",
+  "keywords": [
+    "ipfs",
+    "cli",
+    "deploy",
+    "frontend"
+  ],
+  "author": "Glitter Protocol",
   "license": "MIT",
   "dependencies": {
-    "@pinata/sdk": "^2.1.0",
     "axios": "^1.3.2",
     "base-x": "^5.0.1",
     "bip39": "^3.1.0",
@@ -32,69 +33,29 @@
     "commander": "^11.1.0",
     "crypto-js": "^4.2.0",
     "dayjs": "^1.11.7",
-    "dotenv": "^16.3.1",
-    "download-git-repo": "^3.0.2",
     "ethers": "5.7.2",
     "figlet": "^1.7.0",
     "form-data": "^4.0.0",
     "fs-extra": "^11.2.0",
-    "i18next": "^22.4.9",
-    "i18next-browser-languagedetector": "^7.0.1",
     "inquirer": "^8.2.5",
-    "js-file-downloader": "^1.1.24",
-    "nanoid": "^4.0.1",
     "ora": "^3.2.0",
-    "rollup-plugin-visualizer": "^5.9.2",
     "uuid": "^9.0.0"
   },
   "devDependencies": {
-    "@babel/core": "^7.20.12",
-    "@babel/plugin-syntax-flow": "^7.14.5",
-    "@babel/plugin-transform-react-jsx": "^7.14.9",
-    "@esbuild-plugins/esm-externals": "^0.1.2",
-    "@esbuild-plugins/node-globals-polyfill": "^0.2.3",
-    "@esbuild-plugins/node-modules-polyfill": "^0.2.2",
-    "@rollup/plugin-babel": "^5.3.1",
     "@rollup/plugin-commonjs": "^22.0.2",
     "@rollup/plugin-json": "^4.1.0",
     "@rollup/plugin-node-resolve": "^14.1.0",
-    "@types/lodash": "^4.14.191",
-    "@types/node": "^16.11.7",
-    "@types/react": "^18.0.27",
-    "@types/react-dom": "^18.0.10",
-    "@types/react-router-dom": "^5.3.3",
-    "@vitejs/plugin-basic-ssl": "^1.0.1",
-    "@vitejs/plugin-react": "^3.1.0",
-    "autoprefixer": "^10.4.13",
-    "buffer": "^6.0.3",
-    "cssnano": "^5.1.14",
-    "cssnano-preset-advanced": "^5.3.9",
+    "dotenv": "^16.5.0",
+    "esbuild": "^0.25.2",
     "eslint": "^8.33.0",
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-config-prettier": "^8.6.0",
-    "eslint-config-react-app": "^7.0.1",
     "eslint-plugin-import": "^2.27.5",
     "eslint-plugin-prettier": "^4.2.1",
-    "eslint-plugin-react": "^7.32.2",
-    "less": "^4.1.3",
-    "postcss": "^8.4.21",
-    "postcss-import": "^15.1.0",
-    "postcss-px-to-viewport": "^1.1.1",
-    "postcss-url": "^10.1.3",
     "prettier": "^2.8.3",
     "rollup": "^2.79.1",
-    "rollup-plugin-commonjs": "^10.1.0",
     "rollup-plugin-copy": "^3.5.0",
-    "rollup-plugin-dotenv": "^0.5.1",
-    "rollup-plugin-json": "^4.0.0",
-    "rollup-plugin-node-polyfills": "^0.2.1",
-    "rollup-plugin-node-resolve": "^5.2.0",
-    "rollup-plugin-terser": "^7.0.2",
-    "typescript": "^4.9.5",
-    "vite": "^4.1.1",
-    "vite-plugin-compression": "^0.5.1",
-    "vite-plugin-rewrite-all": "^1.0.1",
-    "vite-plugin-svg-icons": "^2.0.1"
+    "rollup-plugin-terser": "^7.0.2"
   },
   "engines": {
     "node": ">= 14.18.0"