pinme 2.0.2-beta.4 → 2.0.2-beta.6

package/dist/index.js

@@ -96,9 +96,9 @@ var require_package = __commonJS({
 // 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 fs17 = require("fs");
-    var path18 = require("path");
-    var os6 = require("os");
+    var fs16 = require("fs");
+    var path17 = require("path");
+    var os5 = require("os");
     var crypto3 = require("crypto");
     var packageJson = require_package();
     var version2 = packageJson.version;
@@ -200,7 +200,7 @@ var require_main = __commonJS({
       if (options && options.path && options.path.length > 0) {
         if (Array.isArray(options.path)) {
           for (const filepath of options.path) {
-            if (fs17.existsSync(filepath)) {
+            if (fs16.existsSync(filepath)) {
               possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
             }
           }
@@ -208,15 +208,15 @@ var require_main = __commonJS({
           possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
         }
       } else {
-        possibleVaultPath = path18.resolve(process.cwd(), ".env.vault");
+        possibleVaultPath = path17.resolve(process.cwd(), ".env.vault");
       }
-      if (fs17.existsSync(possibleVaultPath)) {
+      if (fs16.existsSync(possibleVaultPath)) {
         return possibleVaultPath;
       }
       return null;
     }
     function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path18.join(os6.homedir(), envPath.slice(1)) : envPath;
+      return envPath[0] === "~" ? path17.join(os5.homedir(), envPath.slice(1)) : envPath;
     }
     function _configVault(options) {
       const debug = Boolean(options && options.debug);
@@ -232,7 +232,7 @@ var require_main = __commonJS({
       return { parsed };
     }
     function configDotenv(options) {
-      const dotenvPath = path18.resolve(process.cwd(), ".env");
+      const dotenvPath = path17.resolve(process.cwd(), ".env");
       let encoding = "utf8";
       const debug = Boolean(options && options.debug);
       if (options && options.encoding) {
@@ -255,13 +255,13 @@ var require_main = __commonJS({
       }
       let lastError;
       const parsedAll = {};
-      for (const path19 of optionPaths) {
+      for (const path18 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs17.readFileSync(path19, { encoding }));
+          const parsed = DotenvModule.parse(fs16.readFileSync(path18, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options);
         } catch (e) {
           if (debug) {
-            _debug(`Failed to load ${path19} ${e.message}`);
+            _debug(`Failed to load ${path18} ${e.message}`);
           }
           lastError = e;
         }
@@ -810,7 +810,7 @@ var require_has_flag = __commonJS({
 var require_supports_color = __commonJS({
   "node_modules/.pnpm/supports-color@5.5.0/node_modules/supports-color/index.js"(exports2, module2) {
     "use strict";
-    var os6 = require("os");
+    var os5 = require("os");
     var hasFlag = require_has_flag();
     var env = process.env;
     var forceColor;
@@ -848,7 +848,7 @@ var require_supports_color = __commonJS({
       }
       const min = forceColor ? 1 : 0;
       if (process.platform === "win32") {
-        const osRelease = os6.release().split(".");
+        const osRelease = os5.release().split(".");
         if (Number(process.versions.node.split(".")[0]) >= 8 && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -1523,10 +1523,10 @@ var import_chalk25 = __toESM(require("chalk"));
 var import_figlet5 = __toESM(require("figlet"));
 
 // package.json
-var version = "2.0.2-beta.4";
+var version = "2.0.2-beta.6";
 
 // bin/upload.ts
-var import_path7 = __toESM(require("path"));
+var import_path6 = __toESM(require("path"));
 var import_chalk5 = __toESM(require("chalk"));
 var import_inquirer = __toESM(require("inquirer"));
 var import_figlet = __toESM(require("figlet"));
@@ -1972,9 +1972,9 @@ function isVisitable(thing) {
 function removeBrackets(key) {
   return utils_default.endsWith(key, "[]") ? key.slice(0, -2) : key;
 }
-function renderKey(path18, key, dots) {
-  if (!path18) return key;
-  return path18.concat(key).map(function each(token, i) {
+function renderKey(path17, key, dots) {
+  if (!path17) return key;
+  return path17.concat(key).map(function each(token, i) {
     token = removeBrackets(token);
     return !dots && i ? "[" + token + "]" : token;
   }).join(dots ? "." : "");
@@ -2019,9 +2019,9 @@ function toFormData(obj, formData, options) {
     }
     return value;
   }
-  function defaultVisitor(value, key, path18) {
+  function defaultVisitor(value, key, path17) {
     let arr = value;
-    if (value && !path18 && typeof value === "object") {
+    if (value && !path17 && typeof value === "object") {
       if (utils_default.endsWith(key, "{}")) {
         key = metaTokens ? key : key.slice(0, -2);
         value = JSON.stringify(value);
@@ -2040,7 +2040,7 @@ function toFormData(obj, formData, options) {
     if (isVisitable(value)) {
       return true;
     }
-    formData.append(renderKey(path18, key, dots), convertValue(value));
+    formData.append(renderKey(path17, key, dots), convertValue(value));
     return false;
   }
   const stack = [];
@@ -2049,10 +2049,10 @@ function toFormData(obj, formData, options) {
     convertValue,
     isVisitable
   });
-  function build(value, path18) {
+  function build(value, path17) {
     if (utils_default.isUndefined(value)) return;
     if (stack.indexOf(value) !== -1) {
-      throw Error("Circular reference detected in " + path18.join("."));
+      throw Error("Circular reference detected in " + path17.join("."));
     }
     stack.push(value);
     utils_default.forEach(value, function each(el, key) {
@@ -2060,11 +2060,11 @@ function toFormData(obj, formData, options) {
         formData,
         el,
         utils_default.isString(key) ? key.trim() : key,
-        path18,
+        path17,
         exposedHelpers
       );
       if (result === true) {
-        build(el, path18 ? path18.concat(key) : [key]);
+        build(el, path17 ? path17.concat(key) : [key]);
       }
     });
     stack.pop();
@@ -2225,7 +2225,7 @@ var node_default = {
 // node_modules/.pnpm/axios@1.3.2/node_modules/axios/lib/helpers/toURLEncodedForm.js
 function toURLEncodedForm(data, options) {
   return toFormData_default(data, new node_default.classes.URLSearchParams(), Object.assign({
-    visitor: function(value, key, path18, helpers) {
+    visitor: function(value, key, path17, helpers) {
       if (node_default.isNode && utils_default.isBuffer(value)) {
         this.append(key, value.toString("base64"));
         return false;
@@ -2254,10 +2254,10 @@ function arrayToObject(arr) {
   return obj;
 }
 function formDataToJSON(formData) {
-  function buildPath(path18, value, target, index) {
-    let name = path18[index++];
+  function buildPath(path17, value, target, index) {
+    let name = path17[index++];
     const isNumericKey = Number.isFinite(+name);
-    const isLast = index >= path18.length;
+    const isLast = index >= path17.length;
     name = !name && utils_default.isArray(target) ? target.length : name;
     if (isLast) {
       if (utils_default.hasOwnProp(target, name)) {
@@ -2270,7 +2270,7 @@ function formDataToJSON(formData) {
     if (!target[name] || !utils_default.isObject(target[name])) {
       target[name] = [];
     }
-    const result = buildPath(path18, value, target[name], index);
+    const result = buildPath(path17, value, target[name], index);
     if (result && utils_default.isArray(target[name])) {
       target[name] = arrayToObject(target[name]);
     }
@@ -3332,9 +3332,9 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
       auth = urlUsername + ":" + urlPassword;
     }
     auth && headers.delete("authorization");
-    let path18;
+    let path17;
     try {
-      path18 = buildURL(
+      path17 = buildURL(
         parsed.pathname + parsed.search,
         config.params,
         config.paramsSerializer
@@ -3352,7 +3352,7 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
       false
     );
     const options = {
-      path: path18,
+      path: path17,
       method,
       headers: headers.toJSON(),
       agents: { http: config.httpAgent, https: config.httpsAgent },
@@ -3571,14 +3571,14 @@ var cookies_default = node_default.isStandardBrowserEnv ? (
   // Standard browser envs support document.cookie
   /* @__PURE__ */ function standardBrowserEnv() {
     return {
-      write: function write(name, value, expires, path18, domain, secure) {
+      write: function write(name, value, expires, path17, domain, secure) {
         const cookie = [];
         cookie.push(name + "=" + encodeURIComponent(value));
         if (utils_default.isNumber(expires)) {
           cookie.push("expires=" + new Date(expires).toGMTString());
         }
-        if (utils_default.isString(path18)) {
-          cookie.push("path=" + path18);
+        if (utils_default.isString(path17)) {
+          cookie.push("path=" + path17);
         }
         if (utils_default.isString(domain)) {
           cookie.push("domain=" + domain);
@@ -5263,44 +5263,25 @@ function validateDnsDomain(domain) {
 var import_crypto_js = __toESM(require("crypto-js"));
 
 // bin/utils/getDeviceId.ts
-var import_fs_extra3 = __toESM(require("fs-extra"));
-var import_path3 = __toESM(require("path"));
-var import_os3 = __toESM(require("os"));
-var import_uuid = require("uuid");
-
-// bin/utils/auth.ts
 var import_fs_extra2 = __toESM(require("fs-extra"));
-var import_os2 = __toESM(require("os"));
 var import_path2 = __toESM(require("path"));
-var CONFIG_DIR2 = import_path2.default.join(import_os2.default.homedir(), ".pinme");
-var AUTH_FILE2 = import_path2.default.join(CONFIG_DIR2, "auth.json");
-function getAuthConfig2() {
-  try {
-    if (!import_fs_extra2.default.existsSync(AUTH_FILE2)) return null;
-    const data = import_fs_extra2.default.readJsonSync(AUTH_FILE2);
-    if (!(data == null ? void 0 : data.address) || !(data == null ? void 0 : data.token)) return null;
-    return data;
-  } catch {
-    return null;
-  }
-}
-
-// bin/utils/getDeviceId.ts
+var import_os2 = __toESM(require("os"));
+var import_uuid = require("uuid");
 function getDeviceId() {
-  const configDir = import_path3.default.join(import_os3.default.homedir(), ".pinme");
-  const configFile = import_path3.default.join(configDir, "device-id");
-  if (!import_fs_extra3.default.existsSync(configDir)) {
-    import_fs_extra3.default.mkdirSync(configDir, { recursive: true });
+  const configDir = import_path2.default.join(import_os2.default.homedir(), ".pinme");
+  const configFile = import_path2.default.join(configDir, "device-id");
+  if (!import_fs_extra2.default.existsSync(configDir)) {
+    import_fs_extra2.default.mkdirSync(configDir, { recursive: true });
   }
-  if (import_fs_extra3.default.existsSync(configFile)) {
-    return import_fs_extra3.default.readFileSync(configFile, "utf8").trim();
+  if (import_fs_extra2.default.existsSync(configFile)) {
+    return import_fs_extra2.default.readFileSync(configFile, "utf8").trim();
   }
   const deviceId = (0, import_uuid.v4)();
-  import_fs_extra3.default.writeFileSync(configFile, deviceId);
+  import_fs_extra2.default.writeFileSync(configFile, deviceId);
   return deviceId;
 }
 function getUid() {
-  const auth = getAuthConfig2();
+  const auth = getAuthConfig();
   if (auth == null ? void 0 : auth.address) {
     return auth.address;
   }
@@ -5308,15 +5289,15 @@ function getUid() {
 }
 
 // bin/utils/uploadToIpfsSplit.ts
-var import_fs_extra5 = __toESM(require("fs-extra"));
-var import_path6 = __toESM(require("path"));
+var import_fs_extra4 = __toESM(require("fs-extra"));
+var import_path5 = __toESM(require("path"));
 var import_form_data2 = __toESM(require("form-data"));
 var import_ora = __toESM(require("ora"));
 var crypto2 = __toESM(require("crypto"));
 
 // bin/utils/uploadLimits.ts
 var import_fs = __toESM(require("fs"));
-var import_path4 = __toESM(require("path"));
+var import_path3 = __toESM(require("path"));
 var FILE_SIZE_LIMIT = parseInt("500", 10) * 1024 * 1024;
 var DIRECTORY_SIZE_LIMIT = parseInt("500", 10) * 1024 * 1024;
 function checkFileSizeLimit(filePath) {
@@ -5339,7 +5320,7 @@ function calculateDirectorySize(directoryPath) {
   let totalSize = 0;
   const files = import_fs.default.readdirSync(directoryPath);
   for (const file of files) {
-    const filePath = import_path4.default.join(directoryPath, file);
+    const filePath = import_path3.default.join(directoryPath, file);
     const stats = import_fs.default.statSync(filePath);
     if (stats.isFile()) {
       totalSize += stats.size;
@@ -5357,30 +5338,30 @@ function formatSize(bytes) {
 }
 
 // bin/utils/history.ts
-var import_fs_extra4 = __toESM(require("fs-extra"));
-var import_path5 = __toESM(require("path"));
-var import_os4 = __toESM(require("os"));
+var import_fs_extra3 = __toESM(require("fs-extra"));
+var import_path4 = __toESM(require("path"));
+var import_os3 = __toESM(require("os"));
 var import_dayjs = __toESM(require("dayjs"));
 var import_chalk4 = __toESM(require("chalk"));
-var HISTORY_DIR = import_path5.default.join(import_os4.default.homedir(), ".pinme");
-var HISTORY_FILE = import_path5.default.join(HISTORY_DIR, "upload-history.json");
+var HISTORY_DIR = import_path4.default.join(import_os3.default.homedir(), ".pinme");
+var HISTORY_FILE = import_path4.default.join(HISTORY_DIR, "upload-history.json");
 var ensureHistoryDir = () => {
-  if (!import_fs_extra4.default.existsSync(HISTORY_DIR)) {
-    import_fs_extra4.default.mkdirSync(HISTORY_DIR, { recursive: true });
+  if (!import_fs_extra3.default.existsSync(HISTORY_DIR)) {
+    import_fs_extra3.default.mkdirSync(HISTORY_DIR, { recursive: true });
   }
-  if (!import_fs_extra4.default.existsSync(HISTORY_FILE)) {
-    import_fs_extra4.default.writeJsonSync(HISTORY_FILE, { uploads: [] });
+  if (!import_fs_extra3.default.existsSync(HISTORY_FILE)) {
+    import_fs_extra3.default.writeJsonSync(HISTORY_FILE, { uploads: [] });
   }
 };
 var saveUploadHistory = (uploadData) => {
   try {
     ensureHistoryDir();
-    const history = import_fs_extra4.default.readJsonSync(HISTORY_FILE);
+    const history = import_fs_extra3.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_path5.default.basename(uploadData.path),
+      filename: uploadData.filename || import_path4.default.basename(uploadData.path),
       contentHash: uploadData.contentHash,
       previewHash: uploadData.previewHash,
       size: uploadData.size,
@@ -5389,7 +5370,7 @@ var saveUploadHistory = (uploadData) => {
       shortUrl: (uploadData == null ? void 0 : uploadData.shortUrl) || null
     };
     history.uploads.unshift(newRecord);
-    import_fs_extra4.default.writeJsonSync(HISTORY_FILE, history, { spaces: 2 });
+    import_fs_extra3.default.writeJsonSync(HISTORY_FILE, history, { spaces: 2 });
     return true;
   } catch (error) {
     console.error(import_chalk4.default.red(`Error saving upload history: ${error.message}`));
@@ -5399,7 +5380,7 @@ var saveUploadHistory = (uploadData) => {
 var getUploadHistory = (limit = 10) => {
   try {
     ensureHistoryDir();
-    const history = import_fs_extra4.default.readJsonSync(HISTORY_FILE);
+    const history = import_fs_extra3.default.readJsonSync(HISTORY_FILE);
     return history.uploads.slice(0, limit);
   } catch (error) {
     console.error(import_chalk4.default.red(`Error reading upload history: ${error.message}`));
@@ -5439,7 +5420,7 @@ var displayUploadHistory = (limit = 10) => {
 var clearUploadHistory = () => {
   try {
     ensureHistoryDir();
-    import_fs_extra4.default.writeJsonSync(HISTORY_FILE, { uploads: [] });
+    import_fs_extra3.default.writeJsonSync(HISTORY_FILE, { uploads: [] });
     console.log(import_chalk4.default.green("Upload history cleared successfully."));
     return true;
   } catch (error) {
@@ -5560,7 +5541,7 @@ var StepProgressBar = class {
 async function calculateMD5(filePath) {
   return new Promise((resolve, reject) => {
     const hash = crypto2.createHash("md5");
-    const stream4 = import_fs_extra5.default.createReadStream(filePath);
+    const stream4 = import_fs_extra4.default.createReadStream(filePath);
     stream4.on("data", hash.update.bind(hash));
     stream4.on("end", () => resolve(hash.digest("hex")));
     stream4.on("error", reject);
@@ -5569,20 +5550,20 @@ async function calculateMD5(filePath) {
 async function compressDirectory(sourcePath) {
   return new Promise((resolve, reject) => {
     const tempDir = require("os").tmpdir();
-    if (!import_fs_extra5.default.existsSync(tempDir)) {
-      import_fs_extra5.default.mkdirSync(tempDir, { recursive: true });
+    if (!import_fs_extra4.default.existsSync(tempDir)) {
+      import_fs_extra4.default.mkdirSync(tempDir, { recursive: true });
     }
-    const outputPath = import_path6.default.join(
+    const outputPath = import_path5.default.join(
       tempDir,
-      `pinme_${import_path6.default.basename(sourcePath)}_${Date.now()}.zip`
+      `pinme_${import_path5.default.basename(sourcePath)}_${Date.now()}.zip`
     );
-    const output = import_fs_extra5.default.createWriteStream(outputPath);
+    const output = import_fs_extra4.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_extra5.default.statSync(sourcePath);
+    const stats = import_fs_extra4.default.statSync(sourcePath);
     if (stats.isDirectory()) {
       const archive = require("archiver");
       const archiveStream = archive("zip", { zlib: { level: 9 } });
@@ -5591,29 +5572,40 @@ async function compressDirectory(sourcePath) {
       archiveStream.directory(sourcePath, false);
       archiveStream.finalize();
     } else {
-      const fileStream = import_fs_extra5.default.createReadStream(sourcePath);
+      const fileStream = import_fs_extra4.default.createReadStream(sourcePath);
       fileStream.pipe(gzip);
     }
   });
 }
-async function initChunkSession(filePath, deviceId, isDirectory = false) {
-  const stats = import_fs_extra5.default.statSync(filePath);
-  const fileName = import_path6.default.basename(filePath);
+async function initChunkSession(filePath, deviceId, options = {}, isDirectory = false) {
+  var _a2;
+  const stats = import_fs_extra4.default.statSync(filePath);
+  const fileName = import_path5.default.basename(filePath);
   const fileSize = stats.size;
   const md5 = await calculateMD5(filePath);
   try {
+    const projectName = (_a2 = options.projectName) == null ? void 0 : _a2.trim();
+    let authHeaders = {};
+    const requestBody = {
+      file_name: fileName,
+      file_size: fileSize,
+      md5,
+      is_directory: isDirectory,
+      uid: deviceId
+    };
+    if (projectName) {
+      requestBody.project_name = projectName;
+      authHeaders = getAuthHeaders();
+    }
     const response = await axios_default.post(
       `${IPFS_API_URL}/chunk/init`,
-      {
-        file_name: fileName,
-        file_size: fileSize,
-        md5,
-        is_directory: isDirectory,
-        uid: deviceId
-      },
+      requestBody,
       {
         timeout: TIMEOUT,
-        headers: { "Content-Type": "application/json" }
+        headers: {
+          "Content-Type": "application/json",
+          ...authHeaders
+        }
       }
     );
     const { code, msg, data } = response.data;
@@ -5699,7 +5691,7 @@ async function delayWithAbortCheck(delay, signal) {
   });
 }
 async function uploadFileChunks(filePath, sessionId, totalChunks, chunkSize, deviceId, progressBar) {
-  const fileData = import_fs_extra5.default.readFileSync(filePath);
+  const fileData = import_fs_extra4.default.readFileSync(filePath);
   const abortController = new AbortController();
   let completedCount = 0;
   let hasFatalError = false;
@@ -5864,13 +5856,13 @@ async function uploadDirectoryInChunks(directoryPath, deviceId, options = {}) {
       )} (size: ${formatSize(sizeCheck.size)})`
     );
   }
-  const progressBar = new StepProgressBar(import_path6.default.basename(directoryPath), true);
+  const progressBar = new StepProgressBar(import_path5.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);
+    const sessionInfo = await initChunkSession(compressedPath, deviceId, options, true);
     progressBar.completeStep();
     progressBar.startStep(2, "Chunk upload");
     await uploadFileChunks(
@@ -5893,12 +5885,12 @@ async function uploadDirectoryInChunks(directoryPath, deviceId, options = {}) {
     const result = await monitorChunkProgress(traceId, deviceId, options, progressBar);
     progressBar.completeStep();
     try {
-      import_fs_extra5.default.unlinkSync(compressedPath);
+      import_fs_extra4.default.unlinkSync(compressedPath);
     } catch (error) {
     }
     const uploadData = {
       path: directoryPath,
-      filename: import_path6.default.basename(directoryPath),
+      filename: import_path5.default.basename(directoryPath),
       contentHash: (result == null ? void 0 : result.hash) || "unknown",
       size: sizeCheck.size,
       fileCount: 0,
@@ -5925,11 +5917,11 @@ async function uploadFileInChunks(filePath, deviceId, options = {}) {
       )} (size: ${formatSize(sizeCheck.size)})`
     );
   }
-  const fileName = import_path6.default.basename(filePath);
+  const fileName = import_path5.default.basename(filePath);
   const progressBar = new StepProgressBar(fileName, false);
   try {
     progressBar.startStep(0, "Initializing session");
-    const sessionInfo = await initChunkSession(filePath, deviceId, false);
+    const sessionInfo = await initChunkSession(filePath, deviceId, options, false);
     progressBar.completeStep();
     progressBar.startStep(1, "Chunk upload");
     await uploadFileChunks(
@@ -5973,13 +5965,14 @@ async function uploadFileInChunks(filePath, deviceId, options = {}) {
   }
 }
 async function uploadToIpfsSplit_default(filePath, options = {}) {
-  const deviceId = getUid();
-  if (!deviceId) {
-    throw new Error("Device ID not found");
+  var _a2;
+  const uid = ((_a2 = options.uid) == null ? void 0 : _a2.trim()) || getUid();
+  if (!uid) {
+    throw new Error("Upload uid not found");
   }
   try {
-    const isDirectory = import_fs_extra5.default.statSync(filePath).isDirectory();
-    const result = isDirectory ? await uploadDirectoryInChunks(filePath, deviceId, options) : await uploadFileInChunks(filePath, deviceId, options);
+    const isDirectory = import_fs_extra4.default.statSync(filePath).isDirectory();
+    const result = isDirectory ? await uploadDirectoryInChunks(filePath, uid, options) : await uploadFileInChunks(filePath, uid, options);
     if (result == null ? void 0 : result.hash) {
       return {
         contentHash: result.hash,
@@ -6018,9 +6011,9 @@ function formatShortUrl(shortUrl) {
   }
   return `https://${normalized}.pinit.eth.limo`;
 }
-function resolveUploadUrls(contentHash, shortUrl) {
-  const uid = getUid();
-  const encryptedCID = encryptHash(contentHash, APP_CONFIG.secretKey, uid);
+function resolveUploadUrls(contentHash, shortUrl, uid) {
+  const resolvedUid = (uid == null ? void 0 : uid.trim()) || getUid();
+  const encryptedCID = encryptHash(contentHash, APP_CONFIG.secretKey, resolvedUid);
   const managementUrl = `${APP_CONFIG.ipfsPreviewUrl}${encryptedCID}`;
   const publicUrl = formatShortUrl(shortUrl) || managementUrl;
   return {
@@ -6031,12 +6024,13 @@ function resolveUploadUrls(contentHash, shortUrl) {
 async function uploadPath(targetPath, options = {}) {
   const result = await uploadToIpfsSplit_default(targetPath, {
     importAsCar: options.importAsCar,
-    projectName: options.projectName
+    projectName: options.projectName,
+    uid: options.uid
   });
   if (!(result == null ? void 0 : result.contentHash)) {
     throw new Error("Upload failed: no content hash returned");
   }
-  const urls = resolveUploadUrls(result.contentHash, result.shortUrl);
+  const urls = resolveUploadUrls(result.contentHash, result.shortUrl, options.uid);
   return {
     contentHash: result.contentHash,
     shortUrl: result.shortUrl,
@@ -6049,7 +6043,7 @@ async function uploadPath(targetPath, options = {}) {
 checkNodeVersion();
 function checkPathSync(inputPath) {
   try {
-    const absolutePath = import_path7.default.resolve(inputPath);
+    const absolutePath = import_path6.default.resolve(inputPath);
     if (import_fs2.default.existsSync(absolutePath)) {
       return absolutePath;
     }
@@ -6141,13 +6135,10 @@ var upload_default = async (options) => {
     const domainArg = getDomainFromArgs();
     const dnsArg = getDnsFromArgs();
     const needsAuth = !!domainArg || dnsArg;
-    let authConfig = null;
-    if (needsAuth) {
-      authConfig = getAuthConfig();
-      if (!authConfig) {
-        console.log(import_chalk5.default.red("Please login first. Run: pinme set-appkey <AppKey>"));
-        return;
-      }
+    const authConfig = getAuthConfig();
+    if (needsAuth && !authConfig) {
+      console.log(import_chalk5.default.red("Please login first. Run: pinme set-appkey <AppKey>"));
+      return;
     }
     const argPath = process.argv[3];
     if (argPath && !argPath.startsWith("-")) {
@@ -6202,7 +6193,8 @@ var upload_default = async (options) => {
       let result;
       try {
         result = await uploadPath(absolutePath, {
-          projectName: APP_CONFIG.pinmeProjectName
+          projectName: APP_CONFIG.pinmeProjectName,
+          uid: authConfig == null ? void 0 : authConfig.address
         });
       } catch (error) {
         console.error(import_chalk5.default.red(`Upload error: ${error.message}`));
@@ -6295,7 +6287,8 @@ var upload_default = async (options) => {
       let result;
       try {
         result = await uploadPath(absolutePath, {
-          projectName: APP_CONFIG.pinmeProjectName
+          projectName: APP_CONFIG.pinmeProjectName,
+          uid: authConfig == null ? void 0 : authConfig.address
         });
       } catch (error) {
         console.error(import_chalk5.default.red(`Upload error: ${error.message}`));
@@ -6336,7 +6329,7 @@ var upload_default = async (options) => {
 };
 
 // bin/importCar.ts
-var import_path8 = __toESM(require("path"));
+var import_path7 = __toESM(require("path"));
 var import_chalk6 = __toESM(require("chalk"));
 var import_inquirer2 = __toESM(require("inquirer"));
 var import_figlet2 = __toESM(require("figlet"));
@@ -6359,7 +6352,7 @@ function encryptHash2(contentHash, key, uid) {
 }
 function checkPathSync2(inputPath) {
   try {
-    const absolutePath = import_path8.default.resolve(inputPath);
+    const absolutePath = import_path7.default.resolve(inputPath);
     if (import_fs3.default.existsSync(absolutePath)) {
       return absolutePath;
     }
@@ -6413,7 +6406,10 @@ var importCar_default = async (options) => {
       }
       console.log(import_chalk6.default.blue(`importing ${absolutePath} to ipfs as CAR...`));
       try {
-        const result = await uploadPath(absolutePath, { importAsCar: true });
+        const result = await uploadPath(absolutePath, {
+          importAsCar: true,
+          uid: getUid2()
+        });
         if (result) {
           const uid = getUid2();
           const encryptedCID = encryptHash2(result.contentHash, APP_CONFIG.secretKey, uid);
@@ -6464,7 +6460,10 @@ var importCar_default = async (options) => {
       }
       console.log(import_chalk6.default.blue(`importing ${absolutePath} to ipfs as CAR...`));
       try {
-        const result = await uploadPath(absolutePath, { importAsCar: true });
+        const result = await uploadPath(absolutePath, {
+          importAsCar: true,
+          uid: getUid2()
+        });
         if (result) {
           const uid = getUid2();
           const encryptedCID = encryptHash2(result.contentHash, APP_CONFIG.secretKey, uid);
@@ -6499,7 +6498,7 @@ var importCar_default = async (options) => {
 };
 
 // bin/exportCar.ts
-var import_path9 = __toESM(require("path"));
+var import_path8 = __toESM(require("path"));
 var import_chalk7 = __toESM(require("chalk"));
 var import_inquirer3 = __toESM(require("inquirer"));
 var import_figlet3 = __toESM(require("figlet"));
@@ -6639,14 +6638,14 @@ var exportCar_default = async () => {
       ]);
       outputDir = answer.output.trim() || currentDir;
     }
-    outputDir = import_path9.default.resolve(outputDir);
+    outputDir = import_path8.default.resolve(outputDir);
     if (!import_fs4.default.existsSync(outputDir)) {
       import_fs4.default.mkdirSync(outputDir, { recursive: true });
     } else if (!import_fs4.default.statSync(outputDir).isDirectory()) {
       console.log(import_chalk7.default.red(`Error: ${outputDir} exists but is not a directory.`));
       return;
     }
-    const finalOutputPath = import_path9.default.join(outputDir, `${cid}.car`);
+    const finalOutputPath = import_path8.default.join(outputDir, `${cid}.car`);
     if (import_fs4.default.existsSync(finalOutputPath)) {
       const answer = await import_inquirer3.default.prompt([
         {
@@ -7075,7 +7074,7 @@ async function walletBalanceCmd() {
 }
 
 // bin/bind.ts
-var import_path10 = __toESM(require("path"));
+var import_path9 = __toESM(require("path"));
 var import_chalk15 = __toESM(require("chalk"));
 var import_inquirer7 = __toESM(require("inquirer"));
 function parseArgs() {
@@ -7174,9 +7173,9 @@ async function bindCmd() {
       }
       throw e;
     }
-    const absolutePath = import_path10.default.resolve(targetPath);
+    const absolutePath = import_path9.default.resolve(targetPath);
     console.log(import_chalk15.default.blue(`Uploading: ${absolutePath}`));
-    const up = await uploadPath(absolutePath);
+    const up = await uploadPath(absolutePath, { uid: authConfig.address });
     if (!(up == null ? void 0 : up.contentHash)) {
       console.log(import_chalk15.default.red("Upload failed, binding aborted."));
       return;
@@ -7251,19 +7250,19 @@ Login failed: ${(e == null ? void 0 : e.message) || e}`));
 
 // bin/create.ts
 var import_chalk19 = __toESM(require("chalk"));
-var import_fs_extra7 = __toESM(require("fs-extra"));
-var import_path12 = __toESM(require("path"));
+var import_fs_extra6 = __toESM(require("fs-extra"));
+var import_path11 = __toESM(require("path"));
 var import_inquirer8 = __toESM(require("inquirer"));
 var import_child_process3 = require("child_process");
 
 // bin/utils/installProjectDependencies.ts
-var import_fs_extra6 = __toESM(require("fs-extra"));
-var import_os5 = __toESM(require("os"));
-var import_path11 = __toESM(require("path"));
+var import_fs_extra5 = __toESM(require("fs-extra"));
+var import_os4 = __toESM(require("os"));
+var import_path10 = __toESM(require("path"));
 var import_chalk17 = __toESM(require("chalk"));
 var import_child_process2 = require("child_process");
 function makeTempCacheDir() {
-  return import_fs_extra6.default.mkdtempSync(import_path11.default.join(import_os5.default.tmpdir(), "pinme-npm-cache-"));
+  return import_fs_extra5.default.mkdtempSync(import_path10.default.join(import_os4.default.tmpdir(), "pinme-npm-cache-"));
 }
 function runInstall(cwd, cacheDir) {
   (0, import_child_process2.execFileSync)("npm", ["install", "--cache", cacheDir, "--no-audit", "--no-fund"], {
@@ -7290,7 +7289,7 @@ function installProjectDependencies(cwd) {
     } catch (error) {
       lastError = error;
     } finally {
-      import_fs_extra6.default.removeSync(cacheDir);
+      import_fs_extra5.default.removeSync(cacheDir);
     }
   }
   throw lastError;
@@ -7473,7 +7472,7 @@ ${configExport}
 `;
 }
 function resolveExtractedTemplateDir(extractDir) {
-  const entries = import_fs_extra7.default.readdirSync(extractDir, { withFileTypes: true });
+  const entries = import_fs_extra6.default.readdirSync(extractDir, { withFileTypes: true });
   const templateDir = entries.find((entry) => entry.isDirectory() && entry.name.startsWith(`${TEMPLATE_REPO_NAME}-`));
   if (!templateDir) {
     throw createConfigError("Downloaded template archive structure is invalid.", [
@@ -7481,10 +7480,10 @@ function resolveExtractedTemplateDir(extractDir) {
       `Template branch: ${TEMPLATE_BRANCH}`
     ]);
   }
-  return import_path12.default.join(extractDir, templateDir.name);
+  return import_path11.default.join(extractDir, templateDir.name);
 }
 function updateFrontendUrlInConfig(configPath, frontendUrl) {
-  let config = import_fs_extra7.default.readFileSync(configPath, "utf-8");
+  let config = import_fs_extra6.default.readFileSync(configPath, "utf-8");
   if (config.includes("frontend_url")) {
     config = config.replace(
       /frontend_url\s*=\s*"[^"]*"/,
@@ -7497,7 +7496,7 @@ function updateFrontendUrlInConfig(configPath, frontendUrl) {
 `
     );
   }
-  import_fs_extra7.default.writeFileSync(configPath, config);
+  import_fs_extra6.default.writeFileSync(configPath, config);
 }
 async function createCmd(options) {
   var _a2, _b;
@@ -7527,8 +7526,8 @@ async function createCmd(options) {
       ]);
       projectName = answers.projectName;
     }
-    const targetDir = import_path12.default.join(PROJECT_DIR, projectName);
-    if (import_fs_extra7.default.existsSync(targetDir) && !options.force) {
+    const targetDir = import_path11.default.join(PROJECT_DIR, projectName);
+    if (import_fs_extra6.default.existsSync(targetDir) && !options.force) {
       console.log(import_chalk19.default.yellow(`
 Directory "${projectName}" already exists.`));
       const answers = await import_inquirer8.default.prompt([
@@ -7543,7 +7542,7 @@ Directory "${projectName}" already exists.`));
         console.log(import_chalk19.default.gray("Cancelled."));
         process.exit(0);
       }
-      import_fs_extra7.default.removeSync(targetDir);
+      import_fs_extra6.default.removeSync(targetDir);
     }
     console.log(import_chalk19.default.blue("\n1. Creating worker and database..."));
     const apiUrl = getPinmeApiUrl("/create_worker");
@@ -7578,8 +7577,8 @@ Directory "${projectName}" already exists.`));
       ]);
     }
     console.log(import_chalk19.default.blue("\n2. Downloading template from repository..."));
-    const zipPath = import_path12.default.join(PROJECT_DIR, "template.zip");
-    const extractDir = import_path12.default.join(PROJECT_DIR, `.pinme-template-${Date.now()}`);
+    const zipPath = import_path11.default.join(PROJECT_DIR, "template.zip");
+    const extractDir = import_path11.default.join(PROJECT_DIR, `.pinme-template-${Date.now()}`);
     const templateZipUrl = getTemplateZipUrl(TEMPLATE_BRANCH);
     let downloadSuccess = false;
     console.log(import_chalk19.default.gray(`   Template branch: ${TEMPLATE_BRANCH}`));
@@ -7589,14 +7588,14 @@ Directory "${projectName}" already exists.`));
         (0, import_child_process3.execSync)(`curl -L --retry 3 --retry-delay 2 -o "${zipPath}" "${templateZipUrl}"`, {
           stdio: "inherit"
         });
-        if (!import_fs_extra7.default.existsSync(zipPath) || import_fs_extra7.default.statSync(zipPath).size < 100) {
+        if (!import_fs_extra6.default.existsSync(zipPath) || import_fs_extra6.default.statSync(zipPath).size < 100) {
           throw new Error("Downloaded file is too small or empty");
         }
         downloadSuccess = true;
       } catch (downloadError) {
         console.log(import_chalk19.default.yellow(`   Attempt ${attempt} failed: ${downloadError.message}`));
-        if (import_fs_extra7.default.existsSync(zipPath)) {
-          import_fs_extra7.default.removeSync(zipPath);
+        if (import_fs_extra6.default.existsSync(zipPath)) {
+          import_fs_extra6.default.removeSync(zipPath);
         }
         if (attempt === 3) {
           throw new Error(`Failed to download template after 3 attempts: ${downloadError.message}`);
@@ -7604,32 +7603,32 @@ Directory "${projectName}" already exists.`));
       }
     }
     try {
-      import_fs_extra7.default.ensureDirSync(extractDir);
+      import_fs_extra6.default.ensureDirSync(extractDir);
       (0, import_child_process3.execSync)(`unzip -o "${zipPath}" -d "${extractDir}"`, {
         stdio: "inherit"
       });
       const subDir = resolveExtractedTemplateDir(extractDir);
-      import_fs_extra7.default.copySync(subDir, targetDir);
-      import_fs_extra7.default.removeSync(zipPath);
-      import_fs_extra7.default.removeSync(extractDir);
-      const nodeModulesPath = import_path12.default.join(targetDir, "node_modules");
-      const packageLockPath = import_path12.default.join(targetDir, "package-lock.json");
-      if (import_fs_extra7.default.existsSync(nodeModulesPath)) {
+      import_fs_extra6.default.copySync(subDir, targetDir);
+      import_fs_extra6.default.removeSync(zipPath);
+      import_fs_extra6.default.removeSync(extractDir);
+      const nodeModulesPath = import_path11.default.join(targetDir, "node_modules");
+      const packageLockPath = import_path11.default.join(targetDir, "package-lock.json");
+      if (import_fs_extra6.default.existsSync(nodeModulesPath)) {
         console.log(import_chalk19.default.gray("   Removing existing node_modules..."));
-        import_fs_extra7.default.removeSync(nodeModulesPath);
+        import_fs_extra6.default.removeSync(nodeModulesPath);
       }
-      if (import_fs_extra7.default.existsSync(packageLockPath)) {
+      if (import_fs_extra6.default.existsSync(packageLockPath)) {
         console.log(import_chalk19.default.gray("   Removing existing package-lock.json..."));
-        import_fs_extra7.default.removeSync(packageLockPath);
-      }
-      const frontendNodeModules = import_path12.default.join(targetDir, "frontend", "node_modules");
-      const backendNodeModules = import_path12.default.join(targetDir, "backend", "node_modules");
-      const frontendPackageLock = import_path12.default.join(targetDir, "frontend", "package-lock.json");
-      const backendPackageLock = import_path12.default.join(targetDir, "backend", "package-lock.json");
-      if (import_fs_extra7.default.existsSync(frontendNodeModules)) import_fs_extra7.default.removeSync(frontendNodeModules);
-      if (import_fs_extra7.default.existsSync(backendNodeModules)) import_fs_extra7.default.removeSync(backendNodeModules);
-      if (import_fs_extra7.default.existsSync(frontendPackageLock)) import_fs_extra7.default.removeSync(frontendPackageLock);
-      if (import_fs_extra7.default.existsSync(backendPackageLock)) import_fs_extra7.default.removeSync(backendPackageLock);
+        import_fs_extra6.default.removeSync(packageLockPath);
+      }
+      const frontendNodeModules = import_path11.default.join(targetDir, "frontend", "node_modules");
+      const backendNodeModules = import_path11.default.join(targetDir, "backend", "node_modules");
+      const frontendPackageLock = import_path11.default.join(targetDir, "frontend", "package-lock.json");
+      const backendPackageLock = import_path11.default.join(targetDir, "backend", "package-lock.json");
+      if (import_fs_extra6.default.existsSync(frontendNodeModules)) import_fs_extra6.default.removeSync(frontendNodeModules);
+      if (import_fs_extra6.default.existsSync(backendNodeModules)) import_fs_extra6.default.removeSync(backendNodeModules);
+      if (import_fs_extra6.default.existsSync(frontendPackageLock)) import_fs_extra6.default.removeSync(frontendPackageLock);
+      if (import_fs_extra6.default.existsSync(backendPackageLock)) import_fs_extra6.default.removeSync(backendPackageLock);
       console.log(import_chalk19.default.green(`   Template downloaded to: ${targetDir}`));
     } catch (error) {
       throw createCommandError("template extraction", `unzip -o "${zipPath}" -d "${PROJECT_DIR}"`, error, [
@@ -7637,58 +7636,58 @@ Directory "${projectName}" already exists.`));
       ]);
     }
     console.log(import_chalk19.default.blue("\n3. Updating configuration..."));
-    const configPath = import_path12.default.join(targetDir, "pinme.toml");
-    const config = import_fs_extra7.default.readFileSync(configPath, "utf-8");
+    const configPath = import_path11.default.join(targetDir, "pinme.toml");
+    const config = import_fs_extra6.default.readFileSync(configPath, "utf-8");
     let updatedConfig = config.replace(
       /project_name = ".*"/,
       `project_name = "${workerData.project_name}"`
     );
-    import_fs_extra7.default.writeFileSync(configPath, updatedConfig);
+    import_fs_extra6.default.writeFileSync(configPath, updatedConfig);
     console.log(import_chalk19.default.green(`   Updated pinme.toml`));
     console.log(import_chalk19.default.gray(`   metadata: ${workerData.metadata}`));
-    const backendDir = import_path12.default.join(targetDir, "backend");
-    if (import_fs_extra7.default.existsSync(backendDir) && workerData.metadata) {
+    const backendDir = import_path11.default.join(targetDir, "backend");
+    if (import_fs_extra6.default.existsSync(backendDir) && workerData.metadata) {
       const metadataContent = typeof workerData.metadata === "string" ? workerData.metadata : JSON.stringify(workerData.metadata, null, 2);
-      import_fs_extra7.default.writeFileSync(
-        import_path12.default.join(backendDir, "metadata.json"),
+      import_fs_extra6.default.writeFileSync(
+        import_path11.default.join(backendDir, "metadata.json"),
         metadataContent
       );
       console.log(import_chalk19.default.green(`   Saved metadata.json`));
     }
-    const wranglerPath = import_path12.default.join(backendDir, "wrangler.toml");
-    if (import_fs_extra7.default.existsSync(wranglerPath) && workerData.api_key) {
-      let wranglerContent = import_fs_extra7.default.readFileSync(wranglerPath, "utf-8");
+    const wranglerPath = import_path11.default.join(backendDir, "wrangler.toml");
+    if (import_fs_extra6.default.existsSync(wranglerPath) && workerData.api_key) {
+      let wranglerContent = import_fs_extra6.default.readFileSync(wranglerPath, "utf-8");
       wranglerContent = wranglerContent.replace(
         /^name = ".*"$/m,
         `name = "${workerData.project_name}"`
       );
-      import_fs_extra7.default.writeFileSync(wranglerPath, wranglerContent);
+      import_fs_extra6.default.writeFileSync(wranglerPath, wranglerContent);
       console.log(import_chalk19.default.green(`   Updated backend/wrangler.toml API_KEY`));
     }
-    const frontendConfigPath = import_path12.default.join(targetDir, "frontend", "src", "utils", "config.ts");
+    const frontendConfigPath = import_path11.default.join(targetDir, "frontend", "src", "utils", "config.ts");
     if (workerData.public_client_config) {
-      const frontendConfigContent = import_fs_extra7.default.existsSync(frontendConfigPath) ? import_fs_extra7.default.readFileSync(frontendConfigPath, "utf-8") : "";
-      import_fs_extra7.default.ensureDirSync(import_path12.default.dirname(frontendConfigPath));
-      import_fs_extra7.default.writeFileSync(
+      const frontendConfigContent = import_fs_extra6.default.existsSync(frontendConfigPath) ? import_fs_extra6.default.readFileSync(frontendConfigPath, "utf-8") : "";
+      import_fs_extra6.default.ensureDirSync(import_path11.default.dirname(frontendConfigPath));
+      import_fs_extra6.default.writeFileSync(
         frontendConfigPath,
         injectPublicClientConfigIntoFile(frontendConfigContent, workerData.public_client_config)
       );
       console.log(import_chalk19.default.green(`   Updated frontend/src/utils/config.ts public_client_config`));
     }
-    const envExamplePath = import_path12.default.join(targetDir, "frontend", ".env.example");
-    const envPath = import_path12.default.join(targetDir, "frontend", ".env");
-    if (import_fs_extra7.default.existsSync(envExamplePath)) {
-      let envContent = import_fs_extra7.default.readFileSync(envExamplePath, "utf-8");
+    const envExamplePath = import_path11.default.join(targetDir, "frontend", ".env.example");
+    const envPath = import_path11.default.join(targetDir, "frontend", ".env");
+    if (import_fs_extra6.default.existsSync(envExamplePath)) {
+      let envContent = import_fs_extra6.default.readFileSync(envExamplePath, "utf-8");
       envContent = envContent.replace(/your-project/g, workerData.project_name);
       envContent = envContent.replace(
         /^VITE_API_URL=.*$/m,
         `VITE_API_URL=${workerData.api_domain}`
       );
-      import_fs_extra7.default.writeFileSync(envPath, envContent);
+      import_fs_extra6.default.writeFileSync(envPath, envContent);
       console.log(import_chalk19.default.green(`   Created frontend/.env file`));
       console.log(import_chalk19.default.gray(`   VITE_API_URL: ${workerData.api_domain}`));
     }
-    let pinmeConfig = import_fs_extra7.default.readFileSync(configPath, "utf-8");
+    let pinmeConfig = import_fs_extra6.default.readFileSync(configPath, "utf-8");
     if (pinmeConfig.includes("api_url")) {
       pinmeConfig = pinmeConfig.replace(
         /api_url\s*=\s*"[^"]*"/,
@@ -7705,7 +7704,7 @@ Directory "${projectName}" already exists.`));
       }
       pinmeConfig = newLines.join("\n");
     }
-    import_fs_extra7.default.writeFileSync(configPath, pinmeConfig);
+    import_fs_extra6.default.writeFileSync(configPath, pinmeConfig);
     console.log(import_chalk19.default.green(`   Updated pinme.toml with api_url`));
     console.log(import_chalk19.default.blue("\n4. Installing dependencies..."));
     try {
@@ -7761,26 +7760,26 @@ Directory "${projectName}" already exists.`));
         "Fix the build error shown above, then rerun `pinme create`."
       ]);
     }
-    const distWorkerDir = import_path12.default.join(targetDir, "dist-worker");
-    const workerJsPath = import_path12.default.join(distWorkerDir, "worker.js");
-    if (!import_fs_extra7.default.existsSync(distWorkerDir) || !import_fs_extra7.default.existsSync(workerJsPath)) {
+    const distWorkerDir = import_path11.default.join(targetDir, "dist-worker");
+    const workerJsPath = import_path11.default.join(distWorkerDir, "worker.js");
+    if (!import_fs_extra6.default.existsSync(distWorkerDir) || !import_fs_extra6.default.existsSync(workerJsPath)) {
       throw createConfigError("Built worker output not found: `dist-worker/worker.js`.", [
         "Make sure `npm run build:worker` completed successfully."
       ]);
     }
     const modulePaths = [];
-    const files = import_fs_extra7.default.readdirSync(distWorkerDir);
+    const files = import_fs_extra6.default.readdirSync(distWorkerDir);
     for (const file of files) {
       if (file.endsWith(".js") && file !== "worker.js") {
-        modulePaths.push(import_path12.default.join(distWorkerDir, file));
+        modulePaths.push(import_path11.default.join(distWorkerDir, file));
       }
     }
-    const sqlDir = import_path12.default.join(targetDir, "db");
+    const sqlDir = import_path11.default.join(targetDir, "db");
     const sqlFiles = [];
-    if (import_fs_extra7.default.existsSync(sqlDir)) {
-      const sqlFileNames = import_fs_extra7.default.readdirSync(sqlDir).filter((f) => f.endsWith(".sql")).sort();
+    if (import_fs_extra6.default.existsSync(sqlDir)) {
+      const sqlFileNames = import_fs_extra6.default.readdirSync(sqlDir).filter((f) => f.endsWith(".sql")).sort();
       for (const filename of sqlFileNames) {
-        sqlFiles.push(import_path12.default.join(sqlDir, filename));
+        sqlFiles.push(import_path11.default.join(sqlDir, filename));
         console.log(import_chalk19.default.gray(`   Including SQL: ${filename}`));
       }
     }
@@ -7795,20 +7794,20 @@ Directory "${projectName}" already exists.`));
       formData.append("metadata", new Blob2([metadataContent], {
         type: "application/json"
       }), "metadata.json");
-      const workerCode = import_fs_extra7.default.readFileSync(workerJsPath, "utf-8");
+      const workerCode = import_fs_extra6.default.readFileSync(workerJsPath, "utf-8");
       formData.append("worker.js", new Blob2([workerCode], {
         type: "application/javascript+module"
       }), "worker.js");
       for (const modulePath of modulePaths) {
-        const filename = import_path12.default.basename(modulePath);
-        const content = import_fs_extra7.default.readFileSync(modulePath, "utf-8");
+        const filename = import_path11.default.basename(modulePath);
+        const content = import_fs_extra6.default.readFileSync(modulePath, "utf-8");
         formData.append(filename, new Blob2([content], {
           type: "application/javascript+module"
         }), filename);
       }
       for (const sqlFile of sqlFiles) {
-        const filename = import_path12.default.basename(sqlFile);
-        const content = import_fs_extra7.default.readFileSync(sqlFile, "utf-8");
+        const filename = import_path11.default.basename(sqlFile);
+        const content = import_fs_extra6.default.readFileSync(sqlFile, "utf-8");
         formData.append("sql_file", new Blob2([content], {
           type: "application/sql"
         }), filename);
@@ -7841,8 +7840,8 @@ Directory "${projectName}" already exists.`));
       ]);
     }
     console.log(import_chalk19.default.blue("\n7. Building frontend..."));
-    const frontendDir = import_path12.default.join(targetDir, "frontend");
-    if (import_fs_extra7.default.existsSync(frontendDir)) {
+    const frontendDir = import_path11.default.join(targetDir, "frontend");
+    if (import_fs_extra6.default.existsSync(frontendDir)) {
       try {
         (0, import_child_process3.execSync)("npm run build:frontend", {
           cwd: targetDir,
@@ -7856,12 +7855,13 @@ Directory "${projectName}" already exists.`));
       }
       console.log(import_chalk19.default.blue("   Uploading to IPFS..."));
       try {
-        const uploadResult = await uploadPath(import_path12.default.join(frontendDir, "dist"), {
-          projectName: workerData.project_name
+        const uploadResult = await uploadPath(import_path11.default.join(frontendDir, "dist"), {
+          projectName: workerData.project_name,
+          uid: headers["token-address"]
         });
         console.log(import_chalk19.default.green(`   Frontend uploaded to IPFS: ${uploadResult.publicUrl}`));
         updateFrontendUrlInConfig(
-          import_path12.default.join(targetDir, "pinme.toml"),
+          import_path11.default.join(targetDir, "pinme.toml"),
           uploadResult.publicUrl
         );
         console.log(import_chalk19.default.green("   Updated pinme.toml with frontend URL"));
@@ -7887,31 +7887,31 @@ Next steps:`));
 
 // bin/save.ts
 var import_chalk20 = __toESM(require("chalk"));
-var import_fs_extra8 = __toESM(require("fs-extra"));
-var import_path13 = __toESM(require("path"));
+var import_fs_extra7 = __toESM(require("fs-extra"));
+var import_path12 = __toESM(require("path"));
 var import_child_process4 = require("child_process");
 var PROJECT_DIR2 = process.cwd();
 function loadConfig() {
-  const configPath = import_path13.default.join(PROJECT_DIR2, "pinme.toml");
-  if (!import_fs_extra8.default.existsSync(configPath)) {
+  const configPath = import_path12.default.join(PROJECT_DIR2, "pinme.toml");
+  if (!import_fs_extra7.default.existsSync(configPath)) {
     throw createConfigError("`pinme.toml` not found in the current directory.", [
       "Run this command from the Pinme project root.",
       "If the project has not been initialized yet, create or restore `pinme.toml` first."
     ]);
   }
-  const configContent = import_fs_extra8.default.readFileSync(configPath, "utf-8");
+  const configContent = import_fs_extra7.default.readFileSync(configPath, "utf-8");
   const projectNameMatch = configContent.match(/project_name\s*=\s*"([^"]+)"/);
   return {
     project_name: (projectNameMatch == null ? void 0 : projectNameMatch[1]) || ""
   };
 }
 function getMetadata() {
-  const metadataPath = import_path13.default.join(PROJECT_DIR2, "backend", "metadata.json");
-  if (!import_fs_extra8.default.existsSync(metadataPath)) {
+  const metadataPath = import_path12.default.join(PROJECT_DIR2, "backend", "metadata.json");
+  if (!import_fs_extra7.default.existsSync(metadataPath)) {
     console.log(import_chalk20.default.yellow("   Warning: metadata.json not found, using empty metadata"));
     return {};
   }
-  return import_fs_extra8.default.readJsonSync(metadataPath);
+  return import_fs_extra7.default.readJsonSync(metadataPath);
 }
 function buildWorker() {
   console.log(import_chalk20.default.blue("Building worker..."));
@@ -7972,34 +7972,34 @@ function installDependencies() {
   }
 }
 function getBuiltWorker() {
-  const distWorkerDir = import_path13.default.join(PROJECT_DIR2, "dist-worker");
-  if (!import_fs_extra8.default.existsSync(distWorkerDir)) {
+  const distWorkerDir = import_path12.default.join(PROJECT_DIR2, "dist-worker");
+  if (!import_fs_extra7.default.existsSync(distWorkerDir)) {
     throw createConfigError("Built worker output not found: `dist-worker/`.", [
       "Make sure `npm run build:worker` completed successfully."
     ]);
   }
-  const workerJsPath = import_path13.default.join(distWorkerDir, "worker.js");
-  if (!import_fs_extra8.default.existsSync(workerJsPath)) {
+  const workerJsPath = import_path12.default.join(distWorkerDir, "worker.js");
+  if (!import_fs_extra7.default.existsSync(workerJsPath)) {
     throw createConfigError("Built worker entry file not found: `dist-worker/worker.js`.", [
       "Check the worker build output and bundler config."
     ]);
   }
   const modulePaths = [];
-  const files = import_fs_extra8.default.readdirSync(distWorkerDir);
+  const files = import_fs_extra7.default.readdirSync(distWorkerDir);
   for (const file of files) {
     if (file.endsWith(".js") && file !== "worker.js") {
-      modulePaths.push(import_path13.default.join(distWorkerDir, file));
+      modulePaths.push(import_path12.default.join(distWorkerDir, file));
     }
   }
   return { workerJsPath, modulePaths };
 }
 function getSqlFiles() {
-  const sqlDir = import_path13.default.join(PROJECT_DIR2, "db");
-  if (!import_fs_extra8.default.existsSync(sqlDir)) {
+  const sqlDir = import_path12.default.join(PROJECT_DIR2, "db");
+  if (!import_fs_extra7.default.existsSync(sqlDir)) {
     return [];
   }
-  const files = import_fs_extra8.default.readdirSync(sqlDir).filter((f) => f.endsWith(".sql")).sort();
-  return files.map((f) => import_path13.default.join(sqlDir, f));
+  const files = import_fs_extra7.default.readdirSync(sqlDir).filter((f) => f.endsWith(".sql")).sort();
+  return files.map((f) => import_path12.default.join(sqlDir, f));
 }
 async function saveWorker(workerJsPath, modulePaths, sqlFiles, metadata, projectName) {
   var _a2, _b;
@@ -8019,20 +8019,20 @@ async function saveWorker(workerJsPath, modulePaths, sqlFiles, metadata, project
     formData.append("metadata", new Blob2([JSON.stringify(metadata)], {
       type: "application/json"
     }), "metadata.json");
-    const workerCode = import_fs_extra8.default.readFileSync(workerJsPath, "utf-8");
+    const workerCode = import_fs_extra7.default.readFileSync(workerJsPath, "utf-8");
     formData.append("worker.js", new Blob2([workerCode], {
       type: "application/javascript+module"
     }), "worker.js");
     for (const modulePath of modulePaths) {
-      const filename = import_path13.default.basename(modulePath);
-      const content = import_fs_extra8.default.readFileSync(modulePath, "utf-8");
+      const filename = import_path12.default.basename(modulePath);
+      const content = import_fs_extra7.default.readFileSync(modulePath, "utf-8");
       formData.append(filename, new Blob2([content], {
         type: "application/javascript+module"
       }), filename);
     }
     for (const sqlFile of sqlFiles) {
-      const filename = import_path13.default.basename(sqlFile);
-      const content = import_fs_extra8.default.readFileSync(sqlFile, "utf-8");
+      const filename = import_path12.default.basename(sqlFile);
+      const content = import_fs_extra7.default.readFileSync(sqlFile, "utf-8");
       formData.append("sql_file", new Blob2([content], {
         type: "application/sql"
       }), filename);
@@ -8082,7 +8082,7 @@ function buildFrontend() {
   }
 }
 function updateFrontendUrlInConfig2(configPath, frontendUrl) {
-  let config = import_fs_extra8.default.readFileSync(configPath, "utf-8");
+  let config = import_fs_extra7.default.readFileSync(configPath, "utf-8");
   if (config.includes("frontend_url")) {
     config = config.replace(
       /frontend_url\s*=\s*"[^"]*"/,
@@ -8095,16 +8095,18 @@ function updateFrontendUrlInConfig2(configPath, frontendUrl) {
 `
     );
   }
-  import_fs_extra8.default.writeFileSync(configPath, config);
+  import_fs_extra7.default.writeFileSync(configPath, config);
 }
 async function deployFrontend(projectName) {
   console.log(import_chalk20.default.blue("Deploying frontend to IPFS..."));
   try {
-    const uploadResult = await uploadPath(import_path13.default.join(PROJECT_DIR2, "frontend", "dist"), {
-      projectName
+    const headers = getAuthHeaders();
+    const uploadResult = await uploadPath(import_path12.default.join(PROJECT_DIR2, "frontend", "dist"), {
+      projectName,
+      uid: headers["token-address"]
     });
     console.log(import_chalk20.default.green(`Frontend deployed to IPFS: ${uploadResult.publicUrl}`));
-    updateFrontendUrlInConfig2(import_path13.default.join(PROJECT_DIR2, "pinme.toml"), uploadResult.publicUrl);
+    updateFrontendUrlInConfig2(import_path12.default.join(PROJECT_DIR2, "pinme.toml"), uploadResult.publicUrl);
     console.log(import_chalk20.default.green("Updated pinme.toml with frontend URL"));
   } catch (error) {
     throw createCommandError("frontend deploy", "upload frontend/dist", error, [
@@ -8120,11 +8122,11 @@ async function saveCmd(options) {
         "Run `pinme login` and retry."
       ]);
     }
-    const projectDir = options.projectName || options.name ? import_path13.default.join(PROJECT_DIR2, options.projectName || options.name) : PROJECT_DIR2;
-    const tokenFileSrc = import_path13.default.join(PROJECT_DIR2, ".token.json");
-    const tokenFileDst = import_path13.default.join(projectDir, ".token.json");
-    if (import_fs_extra8.default.existsSync(tokenFileSrc) && !import_fs_extra8.default.existsSync(tokenFileDst)) {
-      import_fs_extra8.default.copySync(tokenFileSrc, tokenFileDst);
+    const projectDir = options.projectName || options.name ? import_path12.default.join(PROJECT_DIR2, options.projectName || options.name) : PROJECT_DIR2;
+    const tokenFileSrc = import_path12.default.join(PROJECT_DIR2, ".token.json");
+    const tokenFileDst = import_path12.default.join(projectDir, ".token.json");
+    if (import_fs_extra7.default.existsSync(tokenFileSrc) && !import_fs_extra7.default.existsSync(tokenFileDst)) {
+      import_fs_extra7.default.copySync(tokenFileSrc, tokenFileDst);
     }
     console.log(import_chalk20.default.blue("Deploying to platform...\n"));
     console.log(import_chalk20.default.gray(`Project dir: ${PROJECT_DIR2}`));
@@ -8161,36 +8163,36 @@ async function saveCmd(options) {
 
 // bin/updateDb.ts
 var import_chalk21 = __toESM(require("chalk"));
-var import_fs_extra9 = __toESM(require("fs-extra"));
-var import_path14 = __toESM(require("path"));
+var import_fs_extra8 = __toESM(require("fs-extra"));
+var import_path13 = __toESM(require("path"));
 var PROJECT_DIR3 = process.cwd();
 function loadConfig2() {
-  const configPath = import_path14.default.join(PROJECT_DIR3, "pinme.toml");
-  if (!import_fs_extra9.default.existsSync(configPath)) {
+  const configPath = import_path13.default.join(PROJECT_DIR3, "pinme.toml");
+  if (!import_fs_extra8.default.existsSync(configPath)) {
     throw createConfigError("`pinme.toml` not found in the current directory.", [
       "Run this command from the Pinme project root."
     ]);
   }
-  const configContent = import_fs_extra9.default.readFileSync(configPath, "utf-8");
+  const configContent = import_fs_extra8.default.readFileSync(configPath, "utf-8");
   const projectNameMatch = configContent.match(/project_name\s*=\s*"([^"]+)"/);
   return {
     project_name: (projectNameMatch == null ? void 0 : projectNameMatch[1]) || ""
   };
 }
 function getSqlFiles2() {
-  const sqlDir = import_path14.default.join(PROJECT_DIR3, "db");
-  if (!import_fs_extra9.default.existsSync(sqlDir)) {
+  const sqlDir = import_path13.default.join(PROJECT_DIR3, "db");
+  if (!import_fs_extra8.default.existsSync(sqlDir)) {
     throw createConfigError("SQL directory not found: `db/`.", [
       "Create a `db/` directory and add at least one `.sql` migration file."
     ]);
   }
-  const files = import_fs_extra9.default.readdirSync(sqlDir).filter((f) => f.endsWith(".sql")).sort();
+  const files = import_fs_extra8.default.readdirSync(sqlDir).filter((f) => f.endsWith(".sql")).sort();
   if (files.length === 0) {
     throw createConfigError("No `.sql` files were found in `db/`.", [
       "Add one or more migration files before running `pinme update-db`."
     ]);
   }
-  return files.map((f) => import_path14.default.join(sqlDir, f));
+  return files.map((f) => import_path13.default.join(sqlDir, f));
 }
 async function updateDb(sqlFiles, projectName) {
   console.log(import_chalk21.default.blue("Importing SQL files to database..."));
@@ -8205,8 +8207,8 @@ async function updateDb(sqlFiles, projectName) {
     const formData = new FormData4();
     let totalSize = 0;
     for (const sqlFile of sqlFiles) {
-      const filename = import_path14.default.basename(sqlFile);
-      const content = import_fs_extra9.default.readFileSync(sqlFile);
+      const filename = import_path13.default.basename(sqlFile);
+      const content = import_fs_extra8.default.readFileSync(sqlFile);
       totalSize += content.length;
       if (totalSize > 10 * 1024 * 1024) {
         throw createConfigError("Total SQL payload exceeds the 10MB platform limit.", [
@@ -8261,11 +8263,11 @@ async function updateDbCmd(options) {
         "Run `pinme login` and retry."
       ]);
     }
-    const projectDir = (options == null ? void 0 : options.projectName) || (options == null ? void 0 : options.name) ? import_path14.default.join(PROJECT_DIR3, options.projectName || options.name) : PROJECT_DIR3;
-    const tokenFileSrc = import_path14.default.join(PROJECT_DIR3, ".token.json");
-    const tokenFileDst = import_path14.default.join(projectDir, ".token.json");
-    if (import_fs_extra9.default.existsSync(tokenFileSrc) && !import_fs_extra9.default.existsSync(tokenFileDst)) {
-      import_fs_extra9.default.copySync(tokenFileSrc, tokenFileDst);
+    const projectDir = (options == null ? void 0 : options.projectName) || (options == null ? void 0 : options.name) ? import_path13.default.join(PROJECT_DIR3, options.projectName || options.name) : PROJECT_DIR3;
+    const tokenFileSrc = import_path13.default.join(PROJECT_DIR3, ".token.json");
+    const tokenFileDst = import_path13.default.join(projectDir, ".token.json");
+    if (import_fs_extra8.default.existsSync(tokenFileSrc) && !import_fs_extra8.default.existsSync(tokenFileDst)) {
+      import_fs_extra8.default.copySync(tokenFileSrc, tokenFileDst);
     }
     console.log(import_chalk21.default.blue("Importing SQL to database...\n"));
     console.log(import_chalk21.default.gray(`Project dir: ${PROJECT_DIR3}`));
@@ -8290,31 +8292,31 @@ async function updateDbCmd(options) {
 
 // bin/updateWorker.ts
 var import_chalk22 = __toESM(require("chalk"));
-var import_fs_extra10 = __toESM(require("fs-extra"));
-var import_path15 = __toESM(require("path"));
+var import_fs_extra9 = __toESM(require("fs-extra"));
+var import_path14 = __toESM(require("path"));
 var import_child_process5 = require("child_process");
 var PROJECT_DIR4 = process.cwd();
 function loadConfig3() {
-  const configPath = import_path15.default.join(PROJECT_DIR4, "pinme.toml");
-  if (!import_fs_extra10.default.existsSync(configPath)) {
+  const configPath = import_path14.default.join(PROJECT_DIR4, "pinme.toml");
+  if (!import_fs_extra9.default.existsSync(configPath)) {
     throw createConfigError("`pinme.toml` not found in the current directory.", [
       "Run this command from the Pinme project root."
     ]);
   }
-  const configContent = import_fs_extra10.default.readFileSync(configPath, "utf-8");
+  const configContent = import_fs_extra9.default.readFileSync(configPath, "utf-8");
   const projectNameMatch = configContent.match(/project_name\s*=\s*"([^"]+)"/);
   return {
     project_name: (projectNameMatch == null ? void 0 : projectNameMatch[1]) || ""
   };
 }
 function getMetadata2() {
-  const metadataPath = import_path15.default.join(PROJECT_DIR4, "backend", "metadata.json");
-  if (!import_fs_extra10.default.existsSync(metadataPath)) {
+  const metadataPath = import_path14.default.join(PROJECT_DIR4, "backend", "metadata.json");
+  if (!import_fs_extra9.default.existsSync(metadataPath)) {
     throw createConfigError("`backend/metadata.json` not found.", [
       "Create `backend/metadata.json` or restore it from the project template."
     ]);
   }
-  return import_fs_extra10.default.readJsonSync(metadataPath);
+  return import_fs_extra9.default.readJsonSync(metadataPath);
 }
 function buildWorker2() {
   console.log(import_chalk22.default.blue("Building worker..."));
@@ -8331,23 +8333,23 @@ function buildWorker2() {
   }
 }
 function getBuiltWorker2() {
-  const distWorkerDir = import_path15.default.join(PROJECT_DIR4, "dist-worker");
-  if (!import_fs_extra10.default.existsSync(distWorkerDir)) {
+  const distWorkerDir = import_path14.default.join(PROJECT_DIR4, "dist-worker");
+  if (!import_fs_extra9.default.existsSync(distWorkerDir)) {
     throw createConfigError("Built worker output not found: `dist-worker/`.", [
       "Make sure `npm run build:worker` completed successfully."
     ]);
   }
-  const workerJsPath = import_path15.default.join(distWorkerDir, "worker.js");
-  if (!import_fs_extra10.default.existsSync(workerJsPath)) {
+  const workerJsPath = import_path14.default.join(distWorkerDir, "worker.js");
+  if (!import_fs_extra9.default.existsSync(workerJsPath)) {
     throw createConfigError("Built worker entry file not found: `dist-worker/worker.js`.", [
       "Check the worker build output and bundler config."
     ]);
   }
   const modulePaths = [];
-  const files = import_fs_extra10.default.readdirSync(distWorkerDir);
+  const files = import_fs_extra9.default.readdirSync(distWorkerDir);
   for (const file of files) {
     if (file.endsWith(".js") && file !== "worker.js") {
-      modulePaths.push(import_path15.default.join(distWorkerDir, file));
+      modulePaths.push(import_path14.default.join(distWorkerDir, file));
     }
   }
   return { workerJsPath, modulePaths };
@@ -8368,13 +8370,13 @@ async function updateWorker(workerJsPath, modulePaths, metadata, projectName) {
     formData.append("metadata", new Blob2([JSON.stringify(metadata)], {
       type: "application/json"
     }), "metadata.json");
-    const workerCode = import_fs_extra10.default.readFileSync(workerJsPath, "utf-8");
+    const workerCode = import_fs_extra9.default.readFileSync(workerJsPath, "utf-8");
     formData.append("worker.js", new Blob2([workerCode], {
       type: "application/javascript+module"
     }), "worker.js");
     for (const modulePath of modulePaths) {
-      const filename = import_path15.default.basename(modulePath);
-      const content = import_fs_extra10.default.readFileSync(modulePath, "utf-8");
+      const filename = import_path14.default.basename(modulePath);
+      const content = import_fs_extra9.default.readFileSync(modulePath, "utf-8");
       formData.append(filename, new Blob2([content], {
         type: "application/javascript+module"
       }), filename);
@@ -8436,11 +8438,11 @@ async function updateWorkerCmd(options) {
         "Run `pinme login` and retry."
       ]);
     }
-    const projectDir = (options == null ? void 0 : options.projectName) || (options == null ? void 0 : options.name) ? import_path15.default.join(PROJECT_DIR4, options.projectName || options.name) : PROJECT_DIR4;
-    const tokenFileSrc = import_path15.default.join(PROJECT_DIR4, ".token.json");
-    const tokenFileDst = import_path15.default.join(projectDir, ".token.json");
-    if (import_fs_extra10.default.existsSync(tokenFileSrc) && !import_fs_extra10.default.existsSync(tokenFileDst)) {
-      import_fs_extra10.default.copySync(tokenFileSrc, tokenFileDst);
+    const projectDir = (options == null ? void 0 : options.projectName) || (options == null ? void 0 : options.name) ? import_path14.default.join(PROJECT_DIR4, options.projectName || options.name) : PROJECT_DIR4;
+    const tokenFileSrc = import_path14.default.join(PROJECT_DIR4, ".token.json");
+    const tokenFileDst = import_path14.default.join(projectDir, ".token.json");
+    if (import_fs_extra9.default.existsSync(tokenFileSrc) && !import_fs_extra9.default.existsSync(tokenFileDst)) {
+      import_fs_extra9.default.copySync(tokenFileSrc, tokenFileDst);
     }
     console.log(import_chalk22.default.blue("Updating worker...\n"));
     console.log(import_chalk22.default.gray(`Project dir: ${PROJECT_DIR4}`));
@@ -8470,18 +8472,18 @@ async function updateWorkerCmd(options) {
 
 // bin/updateWeb.ts
 var import_chalk23 = __toESM(require("chalk"));
-var import_fs_extra11 = __toESM(require("fs-extra"));
-var import_path16 = __toESM(require("path"));
+var import_fs_extra10 = __toESM(require("fs-extra"));
+var import_path15 = __toESM(require("path"));
 var import_child_process6 = require("child_process");
 var PROJECT_DIR5 = process.cwd();
 function loadConfig4() {
-  const configPath = import_path16.default.join(PROJECT_DIR5, "pinme.toml");
-  if (!import_fs_extra11.default.existsSync(configPath)) {
+  const configPath = import_path15.default.join(PROJECT_DIR5, "pinme.toml");
+  if (!import_fs_extra10.default.existsSync(configPath)) {
     throw createConfigError("`pinme.toml` not found in the current directory.", [
       "Run this command from the Pinme project root."
     ]);
   }
-  const configContent = import_fs_extra11.default.readFileSync(configPath, "utf-8");
+  const configContent = import_fs_extra10.default.readFileSync(configPath, "utf-8");
   const projectNameMatch = configContent.match(/project_name\s*=\s*"([^"]+)"/);
   return {
     project_name: (projectNameMatch == null ? void 0 : projectNameMatch[1]) || ""
@@ -8504,8 +8506,10 @@ function buildFrontend2() {
 async function deployFrontend2(projectName) {
   console.log(import_chalk23.default.blue("Deploying frontend to IPFS..."));
   try {
-    const uploadResult = await uploadPath(import_path16.default.join(PROJECT_DIR5, "frontend", "dist"), {
-      projectName
+    const headers = getAuthHeaders();
+    const uploadResult = await uploadPath(import_path15.default.join(PROJECT_DIR5, "frontend", "dist"), {
+      projectName,
+      uid: headers["token-address"]
     });
     console.log(import_chalk23.default.green(`Frontend deployed to IPFS: ${uploadResult.publicUrl}`));
   } catch (error) {
@@ -8522,11 +8526,11 @@ async function updateWebCmd(options) {
         "Run `pinme login` and retry."
       ]);
     }
-    const projectDir = (options == null ? void 0 : options.projectName) || (options == null ? void 0 : options.name) ? import_path16.default.join(PROJECT_DIR5, options.projectName || options.name) : PROJECT_DIR5;
-    const tokenFileSrc = import_path16.default.join(PROJECT_DIR5, ".token.json");
-    const tokenFileDst = import_path16.default.join(projectDir, ".token.json");
-    if (import_fs_extra11.default.existsSync(tokenFileSrc) && !import_fs_extra11.default.existsSync(tokenFileDst)) {
-      import_fs_extra11.default.copySync(tokenFileSrc, tokenFileDst);
+    const projectDir = (options == null ? void 0 : options.projectName) || (options == null ? void 0 : options.name) ? import_path15.default.join(PROJECT_DIR5, options.projectName || options.name) : PROJECT_DIR5;
+    const tokenFileSrc = import_path15.default.join(PROJECT_DIR5, ".token.json");
+    const tokenFileDst = import_path15.default.join(projectDir, ".token.json");
+    if (import_fs_extra10.default.existsSync(tokenFileSrc) && !import_fs_extra10.default.existsSync(tokenFileDst)) {
+      import_fs_extra10.default.copySync(tokenFileSrc, tokenFileDst);
     }
     console.log(import_chalk23.default.blue("Updating web (frontend)...\n"));
     console.log(import_chalk23.default.gray(`Project dir: ${PROJECT_DIR5}`));
@@ -8552,14 +8556,14 @@ async function updateWebCmd(options) {
 // bin/delete.ts
 var import_chalk24 = __toESM(require("chalk"));
 var import_inquirer9 = __toESM(require("inquirer"));
-var import_fs_extra12 = __toESM(require("fs-extra"));
-var import_path17 = __toESM(require("path"));
+var import_fs_extra11 = __toESM(require("fs-extra"));
+var import_path16 = __toESM(require("path"));
 function getProjectName() {
-  const configPath = import_path17.default.join(process.cwd(), "pinme.toml");
-  if (!import_fs_extra12.default.existsSync(configPath)) {
+  const configPath = import_path16.default.join(process.cwd(), "pinme.toml");
+  if (!import_fs_extra11.default.existsSync(configPath)) {
     return null;
   }
-  const config = import_fs_extra12.default.readFileSync(configPath, "utf-8");
+  const config = import_fs_extra11.default.readFileSync(configPath, "utf-8");
   const match = config.match(/project_name\s*=\s*"([^"]+)"/);
   return (match == null ? void 0 : match[1]) || null;
 }