pinme 2.0.0 → 2.0.1-beta.2

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 fs16 = require("fs");
-    var path17 = require("path");
-    var os5 = require("os");
+    var fs17 = require("fs");
+    var path18 = require("path");
+    var os6 = 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 (fs16.existsSync(filepath)) {
+            if (fs17.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 = path17.resolve(process.cwd(), ".env.vault");
+        possibleVaultPath = path18.resolve(process.cwd(), ".env.vault");
       }
-      if (fs16.existsSync(possibleVaultPath)) {
+      if (fs17.existsSync(possibleVaultPath)) {
         return possibleVaultPath;
       }
       return null;
     }
     function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path17.join(os5.homedir(), envPath.slice(1)) : envPath;
+      return envPath[0] === "~" ? path18.join(os6.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 = path17.resolve(process.cwd(), ".env");
+      const dotenvPath = path18.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 path18 of optionPaths) {
+      for (const path19 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs16.readFileSync(path18, { encoding }));
+          const parsed = DotenvModule.parse(fs17.readFileSync(path19, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options);
         } catch (e) {
           if (debug) {
-            _debug(`Failed to load ${path18} ${e.message}`);
+            _debug(`Failed to load ${path19} ${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 os5 = require("os");
+    var os6 = 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 = os5.release().split(".");
+        const osRelease = os6.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;
         }
@@ -1519,11 +1519,11 @@ function checkNodeVersion() {
 
 // bin/index.ts
 var import_commander = require("commander");
-var import_chalk23 = __toESM(require("chalk"));
+var import_chalk24 = __toESM(require("chalk"));
 var import_figlet5 = __toESM(require("figlet"));
 
 // package.json
-var version = "2.0.0";
+var version = "2.0.1-beta.2";
 
 // bin/upload.ts
 var import_path7 = __toESM(require("path"));
@@ -1968,9 +1968,9 @@ function isVisitable(thing) {
 function removeBrackets(key) {
   return utils_default.endsWith(key, "[]") ? key.slice(0, -2) : key;
 }
-function renderKey(path17, key, dots) {
-  if (!path17) return key;
-  return path17.concat(key).map(function each(token, i) {
+function renderKey(path18, key, dots) {
+  if (!path18) return key;
+  return path18.concat(key).map(function each(token, i) {
     token = removeBrackets(token);
     return !dots && i ? "[" + token + "]" : token;
   }).join(dots ? "." : "");
@@ -2015,9 +2015,9 @@ function toFormData(obj, formData, options) {
     }
     return value;
   }
-  function defaultVisitor(value, key, path17) {
+  function defaultVisitor(value, key, path18) {
     let arr = value;
-    if (value && !path17 && typeof value === "object") {
+    if (value && !path18 && typeof value === "object") {
       if (utils_default.endsWith(key, "{}")) {
         key = metaTokens ? key : key.slice(0, -2);
         value = JSON.stringify(value);
@@ -2036,7 +2036,7 @@ function toFormData(obj, formData, options) {
     if (isVisitable(value)) {
       return true;
     }
-    formData.append(renderKey(path17, key, dots), convertValue(value));
+    formData.append(renderKey(path18, key, dots), convertValue(value));
     return false;
   }
   const stack = [];
@@ -2045,10 +2045,10 @@ function toFormData(obj, formData, options) {
     convertValue,
     isVisitable
   });
-  function build(value, path17) {
+  function build(value, path18) {
     if (utils_default.isUndefined(value)) return;
     if (stack.indexOf(value) !== -1) {
-      throw Error("Circular reference detected in " + path17.join("."));
+      throw Error("Circular reference detected in " + path18.join("."));
     }
     stack.push(value);
     utils_default.forEach(value, function each(el, key) {
@@ -2056,11 +2056,11 @@ function toFormData(obj, formData, options) {
         formData,
         el,
         utils_default.isString(key) ? key.trim() : key,
-        path17,
+        path18,
         exposedHelpers
       );
       if (result === true) {
-        build(el, path17 ? path17.concat(key) : [key]);
+        build(el, path18 ? path18.concat(key) : [key]);
       }
     });
     stack.pop();
@@ -2221,7 +2221,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, path17, helpers) {
+    visitor: function(value, key, path18, helpers) {
       if (node_default.isNode && utils_default.isBuffer(value)) {
         this.append(key, value.toString("base64"));
         return false;
@@ -2250,10 +2250,10 @@ function arrayToObject(arr) {
   return obj;
 }
 function formDataToJSON(formData) {
-  function buildPath(path17, value, target, index) {
-    let name = path17[index++];
+  function buildPath(path18, value, target, index) {
+    let name = path18[index++];
     const isNumericKey = Number.isFinite(+name);
-    const isLast = index >= path17.length;
+    const isLast = index >= path18.length;
     name = !name && utils_default.isArray(target) ? target.length : name;
     if (isLast) {
       if (utils_default.hasOwnProp(target, name)) {
@@ -2266,7 +2266,7 @@ function formDataToJSON(formData) {
     if (!target[name] || !utils_default.isObject(target[name])) {
       target[name] = [];
     }
-    const result = buildPath(path17, value, target[name], index);
+    const result = buildPath(path18, value, target[name], index);
     if (result && utils_default.isArray(target[name])) {
       target[name] = arrayToObject(target[name]);
     }
@@ -3328,9 +3328,9 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
       auth = urlUsername + ":" + urlPassword;
     }
     auth && headers.delete("authorization");
-    let path17;
+    let path18;
     try {
-      path17 = buildURL(
+      path18 = buildURL(
         parsed.pathname + parsed.search,
         config.params,
         config.paramsSerializer
@@ -3348,7 +3348,7 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
       false
     );
     const options = {
-      path: path17,
+      path: path18,
       method,
       headers: headers.toJSON(),
       agents: { http: config.httpAgent, https: config.httpsAgent },
@@ -3567,14 +3567,14 @@ var cookies_default = node_default.isStandardBrowserEnv ? (
   // Standard browser envs support document.cookie
   /* @__PURE__ */ function standardBrowserEnv() {
     return {
-      write: function write(name, value, expires, path17, domain, secure) {
+      write: function write(name, value, expires, path18, 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(path17)) {
-          cookie.push("path=" + path17);
+        if (utils_default.isString(path18)) {
+          cookie.push("path=" + path18);
         }
         if (utils_default.isString(domain)) {
           cookie.push("domain=" + domain);
@@ -7140,14 +7140,54 @@ Login failed: ${(e == null ? void 0 : e.message) || e}`));
 }
 
 // bin/create.ts
-var import_chalk17 = __toESM(require("chalk"));
+var import_chalk18 = __toESM(require("chalk"));
+var import_fs_extra7 = __toESM(require("fs-extra"));
+var import_path12 = __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_inquirer8 = __toESM(require("inquirer"));
+var import_chalk16 = __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-"));
+}
+function runInstall(cwd, cacheDir) {
+  (0, import_child_process2.execFileSync)("npm", ["install", "--cache", cacheDir, "--no-audit", "--no-fund"], {
+    cwd,
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      npm_config_cache: cacheDir,
+      npm_config_audit: "false",
+      npm_config_fund: "false"
+    }
+  });
+}
+function installProjectDependencies(cwd) {
+  let lastError;
+  for (let attempt = 1; attempt <= 2; attempt += 1) {
+    const cacheDir = makeTempCacheDir();
+    try {
+      if (attempt > 1) {
+        console.log(import_chalk16.default.yellow("   Retrying dependency install with a fresh npm cache..."));
+      }
+      runInstall(cwd, cacheDir);
+      return;
+    } catch (error) {
+      lastError = error;
+    } finally {
+      import_fs_extra6.default.removeSync(cacheDir);
+    }
+  }
+  throw lastError;
+}
 
 // bin/utils/cliError.ts
-var import_chalk16 = __toESM(require("chalk"));
+var import_chalk17 = __toESM(require("chalk"));
 var CliError = class extends Error {
   stage;
   details;
@@ -7278,18 +7318,18 @@ function normalizeCliError(error, fallbackSummary, suggestions = []) {
 }
 function printCliError(error, fallbackSummary) {
   const cliError = normalizeCliError(error, fallbackSummary);
-  console.error(import_chalk16.default.red(`
+  console.error(import_chalk17.default.red(`
 Error: ${cliError.message}`));
   if (cliError.stage) {
-    console.error(import_chalk16.default.gray(`Stage: ${cliError.stage}`));
+    console.error(import_chalk17.default.gray(`Stage: ${cliError.stage}`));
   }
   for (const detail of cliError.details) {
-    console.error(import_chalk16.default.gray(detail));
+    console.error(import_chalk17.default.gray(detail));
   }
   if (cliError.suggestions.length > 0) {
-    console.error(import_chalk16.default.yellow("\nNext steps:"));
+    console.error(import_chalk17.default.yellow("\nNext steps:"));
     for (const suggestion of cliError.suggestions) {
-      console.error(import_chalk16.default.yellow(`- ${suggestion}`));
+      console.error(import_chalk17.default.yellow(`- ${suggestion}`));
     }
   }
 }
@@ -7300,6 +7340,7 @@ var API_BASE = "https://pinme.dev/api/v4";
 var TEMPLATE_REPO = "glitternetwork/pinme-worker-template";
 var TEMPLATE_ZIP_URL = `https://github.com/${TEMPLATE_REPO}/archive/refs/heads/main.zip`;
 async function createCmd(options) {
+  var _a, _b;
   try {
     const headers = getAuthHeaders();
     if (!headers["authentication-tokens"] || !headers["token-address"]) {
@@ -7307,7 +7348,7 @@ async function createCmd(options) {
         "Run `pinme login` and retry."
       ]);
     }
-    console.log(import_chalk17.default.blue("Creating new project from template...\n"));
+    console.log(import_chalk18.default.blue("Creating new project from template...\n"));
     let projectName = options.name;
     if (!projectName) {
       const answers = await import_inquirer8.default.prompt([
@@ -7326,9 +7367,9 @@ async function createCmd(options) {
       ]);
       projectName = answers.projectName;
     }
-    const targetDir = import_path11.default.join(PROJECT_DIR, projectName);
-    if (import_fs_extra6.default.existsSync(targetDir) && !options.force) {
-      console.log(import_chalk17.default.yellow(`
+    const targetDir = import_path12.default.join(PROJECT_DIR, projectName);
+    if (import_fs_extra7.default.existsSync(targetDir) && !options.force) {
+      console.log(import_chalk18.default.yellow(`
 Directory "${projectName}" already exists.`));
       const answers = await import_inquirer8.default.prompt([
         {
@@ -7339,16 +7380,16 @@ Directory "${projectName}" already exists.`));
         }
       ]);
       if (!answers.overwrite) {
-        console.log(import_chalk17.default.gray("Cancelled."));
+        console.log(import_chalk18.default.gray("Cancelled."));
         process.exit(0);
       }
-      import_fs_extra6.default.removeSync(targetDir);
+      import_fs_extra7.default.removeSync(targetDir);
     }
-    console.log(import_chalk17.default.blue("\n1. Creating worker and database..."));
+    console.log(import_chalk18.default.blue("\n1. Creating worker and database..."));
     const apiUrl = `${API_BASE}/create_worker`;
-    console.log(import_chalk17.default.gray(`API URL: ${apiUrl}`));
+    console.log(import_chalk18.default.gray(`API URL: ${apiUrl}`));
     const normalizedProjectName = projectName.toLowerCase();
-    console.log(import_chalk17.default.gray(`Project name: ${normalizedProjectName}`));
+    console.log(import_chalk18.default.gray(`Project name: ${normalizedProjectName}`));
     let workerData;
     try {
       const response = await axios_default.post(apiUrl, {
@@ -7367,33 +7408,32 @@ Directory "${projectName}" already exists.`));
         ]);
       }
       workerData = data.data;
-      console.log(import_chalk17.default.gray(`   API Response: ${JSON.stringify(workerData)}`));
-      console.log(import_chalk17.default.green(`   API Domain: ${workerData.api_domain}`));
-      console.log(import_chalk17.default.green(`   Project Name: ${workerData.project_name}`));
-      console.log(import_chalk17.default.green(`   D1 UUID: ${workerData.uuid}`));
+      console.log(import_chalk18.default.gray(`   API Response: ${JSON.stringify(workerData)}`));
+      console.log(import_chalk18.default.green(`   API Domain: ${workerData.api_domain}`));
+      console.log(import_chalk18.default.green(`   Project Name: ${workerData.project_name}`));
     } catch (error) {
       throw createApiError("project creation", error, [
         `Project name: ${normalizedProjectName}`,
         `Endpoint: ${apiUrl}`
       ]);
     }
-    console.log(import_chalk17.default.blue("\n2. Downloading template from repository..."));
-    const zipPath = import_path11.default.join(PROJECT_DIR, "template.zip");
+    console.log(import_chalk18.default.blue("\n2. Downloading template from repository..."));
+    const zipPath = import_path12.default.join(PROJECT_DIR, "template.zip");
     let downloadSuccess = false;
     for (let attempt = 1; attempt <= 3 && !downloadSuccess; attempt++) {
       try {
-        console.log(import_chalk17.default.gray(`   Download attempt ${attempt}/3...`));
-        (0, import_child_process2.execSync)(`curl -L --retry 3 --retry-delay 2 -o "${zipPath}" "${TEMPLATE_ZIP_URL}"`, {
+        console.log(import_chalk18.default.gray(`   Download attempt ${attempt}/3...`));
+        (0, import_child_process3.execSync)(`curl -L --retry 3 --retry-delay 2 -o "${zipPath}" "${TEMPLATE_ZIP_URL}"`, {
           stdio: "inherit"
         });
-        if (!import_fs_extra6.default.existsSync(zipPath) || import_fs_extra6.default.statSync(zipPath).size < 100) {
+        if (!import_fs_extra7.default.existsSync(zipPath) || import_fs_extra7.default.statSync(zipPath).size < 100) {
           throw new Error("Downloaded file is too small or empty");
         }
         downloadSuccess = true;
       } catch (downloadError) {
-        console.log(import_chalk17.default.yellow(`   Attempt ${attempt} failed: ${downloadError.message}`));
-        if (import_fs_extra6.default.existsSync(zipPath)) {
-          import_fs_extra6.default.removeSync(zipPath);
+        console.log(import_chalk18.default.yellow(`   Attempt ${attempt} failed: ${downloadError.message}`));
+        if (import_fs_extra7.default.existsSync(zipPath)) {
+          import_fs_extra7.default.removeSync(zipPath);
         }
         if (attempt === 3) {
           throw new Error(`Failed to download template after 3 attempts: ${downloadError.message}`);
@@ -7401,113 +7441,295 @@ Directory "${projectName}" already exists.`));
       }
     }
     try {
-      (0, import_child_process2.execSync)(`unzip -o "${zipPath}" -d "${PROJECT_DIR}"`, {
+      (0, import_child_process3.execSync)(`unzip -o "${zipPath}" -d "${PROJECT_DIR}"`, {
         stdio: "inherit"
       });
-      const subDir = import_path11.default.join(PROJECT_DIR, "pinme-worker-template-main");
-      if (import_fs_extra6.default.existsSync(subDir)) {
-        import_fs_extra6.default.copySync(subDir, targetDir);
-        import_fs_extra6.default.removeSync(subDir);
-      }
-      import_fs_extra6.default.removeSync(zipPath);
-      console.log(import_chalk17.default.green(`   Template downloaded to: ${targetDir}`));
+      const subDir = import_path12.default.join(PROJECT_DIR, "pinme-worker-template-main");
+      if (import_fs_extra7.default.existsSync(subDir)) {
+        import_fs_extra7.default.copySync(subDir, targetDir);
+        import_fs_extra7.default.removeSync(subDir);
+      }
+      import_fs_extra7.default.removeSync(zipPath);
+      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)) {
+        console.log(import_chalk18.default.gray("   Removing existing node_modules..."));
+        import_fs_extra7.default.removeSync(nodeModulesPath);
+      }
+      if (import_fs_extra7.default.existsSync(packageLockPath)) {
+        console.log(import_chalk18.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);
+      console.log(import_chalk18.default.green(`   Template downloaded to: ${targetDir}`));
     } catch (error) {
       throw createCommandError("template extraction", `unzip -o "${zipPath}" -d "${PROJECT_DIR}"`, error, [
         "Check whether `unzip` is available and the downloaded template archive is valid."
       ]);
     }
-    console.log(import_chalk17.default.blue("\n3. Updating configuration..."));
-    const configPath = import_path11.default.join(targetDir, "pinme.toml");
-    const config = import_fs_extra6.default.readFileSync(configPath, "utf-8");
+    console.log(import_chalk18.default.blue("\n3. Updating configuration..."));
+    const configPath = import_path12.default.join(targetDir, "pinme.toml");
+    const config = import_fs_extra7.default.readFileSync(configPath, "utf-8");
     let updatedConfig = config.replace(
       /project_name = ".*"/,
       `project_name = "${workerData.project_name}"`
     );
-    import_fs_extra6.default.writeFileSync(configPath, updatedConfig);
-    console.log(import_chalk17.default.green(`   Updated pinme.toml`));
-    console.log(import_chalk17.default.gray(`   metadata: ${workerData.metadata}`));
-    console.log(import_chalk17.default.gray(`   VITE_API_URL: ${workerData.api_domain}`));
-    const backendDir = import_path11.default.join(targetDir, "backend");
-    if (import_fs_extra6.default.existsSync(backendDir) && workerData.metadata) {
+    import_fs_extra7.default.writeFileSync(configPath, updatedConfig);
+    console.log(import_chalk18.default.green(`   Updated pinme.toml`));
+    console.log(import_chalk18.default.gray(`   metadata: ${workerData.metadata}`));
+    const backendDir = import_path12.default.join(targetDir, "backend");
+    if (import_fs_extra7.default.existsSync(backendDir) && workerData.metadata) {
       const metadataContent = typeof workerData.metadata === "string" ? workerData.metadata : JSON.stringify(workerData.metadata, null, 2);
-      import_fs_extra6.default.writeFileSync(
-        import_path11.default.join(backendDir, "metadata.json"),
+      import_fs_extra7.default.writeFileSync(
+        import_path12.default.join(backendDir, "metadata.json"),
         metadataContent
       );
-      console.log(import_chalk17.default.green(`   Saved metadata.json`));
+      console.log(import_chalk18.default.green(`   Saved metadata.json`));
     }
-    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");
+    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");
       wranglerContent = wranglerContent.replace(
         /^name = ".*"$/m,
         `name = "${workerData.project_name}"`
       );
-      import_fs_extra6.default.writeFileSync(wranglerPath, wranglerContent);
-      console.log(import_chalk17.default.green(`   Updated backend/wrangler.toml API_KEY`));
+      import_fs_extra7.default.writeFileSync(wranglerPath, wranglerContent);
+      console.log(import_chalk18.default.green(`   Updated backend/wrangler.toml API_KEY`));
     }
-    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");
+    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");
       envContent = envContent.replace(/your-project/g, workerData.project_name);
       envContent = envContent.replace(
         /^VITE_API_URL=.*$/m,
         `VITE_API_URL=${workerData.api_domain}`
       );
-      import_fs_extra6.default.writeFileSync(envPath, envContent);
-      console.log(import_chalk17.default.green(`   Created frontend/.env file`));
+      import_fs_extra7.default.writeFileSync(envPath, envContent);
+      console.log(import_chalk18.default.green(`   Created frontend/.env file`));
+      console.log(import_chalk18.default.gray(`   VITE_API_URL: ${workerData.api_domain}`));
+    }
+    let pinmeConfig = import_fs_extra7.default.readFileSync(configPath, "utf-8");
+    if (pinmeConfig.includes("api_url")) {
+      pinmeConfig = pinmeConfig.replace(
+        /api_url\s*=\s*"[^"]*"/,
+        `api_url = "${workerData.api_domain}"`
+      );
+    } else {
+      const lines = pinmeConfig.split("\n");
+      const newLines = [];
+      for (const line of lines) {
+        newLines.push(line);
+        if (line.trim().startsWith("project_name")) {
+          newLines.push(`api_url = "${workerData.api_domain}"`);
+        }
+      }
+      pinmeConfig = newLines.join("\n");
+    }
+    import_fs_extra7.default.writeFileSync(configPath, pinmeConfig);
+    console.log(import_chalk18.default.green(`   Updated pinme.toml with api_url`));
+    console.log(import_chalk18.default.blue("\n4. Installing dependencies..."));
+    try {
+      installProjectDependencies(targetDir);
+      console.log(import_chalk18.default.green("   Project dependencies installed"));
+    } catch (error) {
+      const errorMsg = error.message || "";
+      if (errorMsg.includes("EACCES") || errorMsg.includes("EPERM") || errorMsg.includes("permission denied")) {
+        throw createCommandError("project dependency install", "npm install", error, [
+          "Permission error detected. Here are some solutions:",
+          "",
+          "Option 1: Fix npm permissions (Recommended)",
+          "  mkdir -p ~/.npm-global",
+          "  npm config set prefix ~/.npm-global",
+          "  Then add ~/.npm-global/bin to your PATH in ~/.bashrc or ~/.zshrc",
+          "",
+          "Option 2: Use npx to avoid global installs",
+          "  npx npm install",
+          "",
+          "Option 3: Check if you have write permissions",
+          "  ls -la " + targetDir,
+          "",
+          "For more help: https://docs.npmjs.com/resolving-eacces-permissions-errors-when-installing-packages-globally"
+        ]);
+      }
+      if (errorMsg.includes("ENOTFOUND") || errorMsg.includes("ETIMEDOUT") || errorMsg.includes("network")) {
+        throw createCommandError("project dependency install", "npm install", error, [
+          "Network error detected. Please check:",
+          "  1. Internet connection is available",
+          "  2. npm registry is accessible (https://registry.npmjs.org)",
+          "  3. Try using a mirror: npm config set registry https://registry.npmmirror.com"
+        ]);
+      }
+      throw createCommandError("project dependency install", "npm install", error, [
+        "Dependency installation failed.",
+        "Check network connectivity and npm registry availability.",
+        "Inspect the generated workspace `package.json` files for dependency conflicts.",
+        "",
+        "If this is a permission issue, try:",
+        "  sudo chown -R $(whoami) ~/.npm",
+        "  sudo chown -R $(whoami) " + targetDir + "/node_modules"
+      ]);
     }
-    console.log(import_chalk17.default.blue("\n4. Building frontend..."));
+    console.log(import_chalk18.default.blue("\n5. Building backend worker..."));
     try {
-      (0, import_child_process2.execSync)("npm install", {
+      (0, import_child_process3.execSync)("npm run build:worker", {
         cwd: targetDir,
         stdio: "inherit"
       });
-      console.log(import_chalk17.default.green("   Project dependencies installed"));
+      console.log(import_chalk18.default.green("   Worker built"));
     } catch (error) {
-      throw createCommandError("project dependency install", "npm install", error, [
-        "Check network connectivity and npm registry availability.",
-        "Inspect the generated workspace `package.json` files for dependency conflicts."
+      throw createCommandError("worker build", "npm run build:worker", error, [
+        "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)) {
+      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);
+    for (const file of files) {
+      if (file.endsWith(".js") && file !== "worker.js") {
+        modulePaths.push(import_path12.default.join(distWorkerDir, file));
+      }
+    }
+    const sqlDir = import_path12.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();
+      for (const filename of sqlFileNames) {
+        sqlFiles.push(import_path12.default.join(sqlDir, filename));
+        console.log(import_chalk18.default.gray(`   Including SQL: ${filename}`));
+      }
+    }
+    console.log(import_chalk18.default.blue("\n6. Deploying backend worker..."));
+    const saveApiUrl = `${API_BASE}/save_worker?project_name=${encodeURIComponent(workerData.project_name)}`;
+    console.log(import_chalk18.default.gray(`   API URL: ${saveApiUrl}`));
+    try {
+      const FormData4 = (await import("formdata-node")).FormData;
+      const Blob2 = (await import("formdata-node")).Blob;
+      const formData = new FormData4();
+      const metadataContent = typeof workerData.metadata === "string" ? workerData.metadata : JSON.stringify(workerData.metadata, null, 2);
+      formData.append("metadata", new Blob2([metadataContent], {
+        type: "application/json"
+      }), "metadata.json");
+      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_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_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);
+      }
+      const response = await axios_default.put(saveApiUrl, formData, {
+        headers: { ...headers },
+        timeout: 12e4
+      });
+      if (response.data) {
+        console.log(import_chalk18.default.green("   Worker deployed"));
+        if ((_b = (_a = response.data) == null ? void 0 : _a.data) == null ? void 0 : _b.sql_results) {
+          for (const result of response.data.data.sql_results) {
+            console.log(import_chalk18.default.gray(`   SQL ${result.filename}: ${result.status}`));
+          }
+        }
+      } else {
+        throw createApiError("worker save", { response: { data: response.data } }, [
+          `Project: ${workerData.project_name}`,
+          `Endpoint: ${saveApiUrl}`
+        ], [
+          "Verify the project exists and your account has permission to update it."
+        ]);
+      }
+    } catch (error) {
+      throw createApiError("worker save", error, [
+        `Project: ${workerData.project_name}`,
+        `Endpoint: ${saveApiUrl}`
+      ], [
+        "Check whether backend metadata, SQL files, or worker bundle contains invalid content."
       ]);
     }
-    const frontendDir = import_path11.default.join(targetDir, "frontend");
-    if (import_fs_extra6.default.existsSync(frontendDir)) {
+    console.log(import_chalk18.default.blue("\n7. Building frontend..."));
+    const frontendDir = import_path12.default.join(targetDir, "frontend");
+    if (import_fs_extra7.default.existsSync(frontendDir)) {
       try {
-        (0, import_child_process2.execSync)("npm run build:frontend", {
+        (0, import_child_process3.execSync)("npm run build:frontend", {
           cwd: targetDir,
           stdio: "inherit"
         });
-        console.log(import_chalk17.default.green("   Frontend built"));
+        console.log(import_chalk18.default.green("   Frontend built"));
       } catch (error) {
         throw createCommandError("frontend build", "npm run build:frontend", error, [
           "Fix the frontend build error shown above, then rerun `pinme create`."
         ]);
       }
-      console.log(import_chalk17.default.blue("   Uploading to IPFS..."));
+      console.log(import_chalk18.default.blue("   Uploading to IPFS..."));
+      let frontendUrl = "";
       try {
-        (0, import_child_process2.execSync)("pinme upload ./dist", {
+        const uploadOutput = (0, import_child_process3.execSync)("pinme upload ./dist", {
           cwd: frontendDir,
-          stdio: "inherit",
+          encoding: "utf-8",
           env: {
             ...process.env,
             PINME_PROJECT_NAME: workerData.project_name
           }
         });
-        console.log(import_chalk17.default.green("   Frontend uploaded to IPFS"));
+        console.log(uploadOutput);
+        const urlMatch = uploadOutput.match(/https:\/\/[\w-]+\.pinme\.dev/);
+        if (urlMatch) {
+          frontendUrl = urlMatch[0];
+          console.log(import_chalk18.default.green(`   Frontend uploaded to IPFS: ${frontendUrl}`));
+          const configPath2 = import_path12.default.join(targetDir, "pinme.toml");
+          let config2 = import_fs_extra7.default.readFileSync(configPath2, "utf-8");
+          if (config2.includes("frontend_url")) {
+            config2 = config2.replace(
+              /frontend_url\s*=\s*"[^"]*"/,
+              `frontend_url = "${frontendUrl}"`
+            );
+          } else {
+            config2 = config2.replace(
+              /(project_name\s*=\s*"[^"]*"\n)/,
+              `$1frontend_url = "${frontendUrl}"
+`
+            );
+          }
+          import_fs_extra7.default.writeFileSync(configPath2, config2);
+          console.log(import_chalk18.default.green("   Updated pinme.toml with frontend URL"));
+        } else {
+          console.log(import_chalk18.default.green("   Frontend uploaded to IPFS"));
+        }
       } catch (error) {
-        console.log(import_chalk17.default.yellow("   Warning: IPFS upload failed, you can upload manually later"));
+        console.log(import_chalk18.default.yellow("   Warning: IPFS upload failed, you can upload manually later"));
       }
     }
-    console.log(import_chalk17.default.green("\nProject created successfully."));
-    console.log(import_chalk17.default.gray(`
+    console.log(import_chalk18.default.green("\nProject created successfully."));
+    console.log(import_chalk18.default.gray(`
 Project Details:`));
-    console.log(import_chalk17.default.gray(`   API Domain: ${workerData.api_domain}`));
-    console.log(import_chalk17.default.gray(`   Project Name: ${workerData.project_name}`));
-    console.log(import_chalk17.default.gray(`
+    console.log(import_chalk18.default.gray(`   API Domain: ${workerData.api_domain}`));
+    console.log(import_chalk18.default.gray(`   Project Name: ${workerData.project_name}`));
+    console.log(import_chalk18.default.gray(`
 Next steps:`));
-    console.log(import_chalk17.default.gray(`   cd ${projectName}`));
-    console.log(import_chalk17.default.gray(`   pinme save`));
+    console.log(import_chalk18.default.gray(`   cd ${projectName}`));
+    console.log(import_chalk18.default.gray(`   pinme save`));
     process.exit(0);
   } catch (error) {
     printCliError(error, "Project creation failed.");
@@ -7516,42 +7738,42 @@ Next steps:`));
 }
 
 // bin/save.ts
-var import_chalk18 = __toESM(require("chalk"));
-var import_fs_extra7 = __toESM(require("fs-extra"));
-var import_path12 = __toESM(require("path"));
-var import_child_process3 = require("child_process");
+var import_chalk19 = __toESM(require("chalk"));
+var import_fs_extra8 = __toESM(require("fs-extra"));
+var import_path13 = __toESM(require("path"));
+var import_child_process4 = require("child_process");
 var PROJECT_DIR2 = process.cwd();
 var API_BASE2 = "https://pinme.dev/api/v4";
 function loadConfig() {
-  const configPath = import_path12.default.join(PROJECT_DIR2, "pinme.toml");
-  if (!import_fs_extra7.default.existsSync(configPath)) {
+  const configPath = import_path13.default.join(PROJECT_DIR2, "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.",
       "If the project has not been initialized yet, create or restore `pinme.toml` first."
     ]);
   }
-  const configContent = import_fs_extra7.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 getMetadata() {
-  const metadataPath = import_path12.default.join(PROJECT_DIR2, "backend", "metadata.json");
-  if (!import_fs_extra7.default.existsSync(metadataPath)) {
-    console.log(import_chalk18.default.yellow("   Warning: metadata.json not found, using empty metadata"));
+  const metadataPath = import_path13.default.join(PROJECT_DIR2, "backend", "metadata.json");
+  if (!import_fs_extra8.default.existsSync(metadataPath)) {
+    console.log(import_chalk19.default.yellow("   Warning: metadata.json not found, using empty metadata"));
     return {};
   }
-  return import_fs_extra7.default.readJsonSync(metadataPath);
+  return import_fs_extra8.default.readJsonSync(metadataPath);
 }
 function buildWorker() {
-  console.log(import_chalk18.default.blue("Building worker..."));
+  console.log(import_chalk19.default.blue("Building worker..."));
   try {
-    (0, import_child_process3.execSync)("npm run build:worker", {
+    (0, import_child_process4.execSync)("npm run build:worker", {
       cwd: PROJECT_DIR2,
       stdio: "inherit"
     });
-    console.log(import_chalk18.default.green("Worker built"));
+    console.log(import_chalk19.default.green("Worker built"));
   } catch (error) {
     throw createCommandError("worker build", "npm run build:worker", error, [
       "Fix the build error shown above, then rerun `pinme save`."
@@ -7559,61 +7781,90 @@ function buildWorker() {
   }
 }
 function installDependencies() {
-  console.log(import_chalk18.default.blue("Installing dependencies..."));
+  console.log(import_chalk19.default.blue("Installing dependencies..."));
   try {
-    (0, import_child_process3.execSync)("npm install", {
-      cwd: PROJECT_DIR2,
-      stdio: "inherit"
-    });
-    console.log(import_chalk18.default.green("Project dependencies installed"));
+    installProjectDependencies(PROJECT_DIR2);
+    console.log(import_chalk19.default.green("Project dependencies installed"));
   } catch (error) {
+    const errorMsg = error.message || "";
+    if (errorMsg.includes("EACCES") || errorMsg.includes("EPERM") || errorMsg.includes("permission denied")) {
+      throw createCommandError("project dependency install", "npm install", error, [
+        "Permission error detected. Here are some solutions:",
+        "",
+        "Option 1: Fix npm permissions (Recommended)",
+        "  mkdir -p ~/.npm-global",
+        "  npm config set prefix ~/.npm-global",
+        "  Then add ~/.npm-global/bin to your PATH in ~/.bashrc or ~/.zshrc",
+        "",
+        "Option 2: Use npx to avoid global installs",
+        "  npx npm install",
+        "",
+        "Option 3: Check if you have write permissions",
+        "  ls -la " + PROJECT_DIR2,
+        "",
+        "For more help: https://docs.npmjs.com/resolving-eacces-permissions-errors-when-installing-packages-globally"
+      ]);
+    }
+    if (errorMsg.includes("ENOTFOUND") || errorMsg.includes("ETIMEDOUT") || errorMsg.includes("network")) {
+      throw createCommandError("project dependency install", "npm install", error, [
+        "Network error detected. Please check:",
+        "  1. Internet connection is available",
+        "  2. npm registry is accessible (https://registry.npmjs.org)",
+        "  3. Try using a mirror: npm config set registry https://registry.npmmirror.com"
+      ]);
+    }
     throw createCommandError("project dependency install", "npm install", error, [
+      "Dependency installation failed.",
       "Check network connectivity and npm registry availability.",
-      "If `package-lock.json` is stale or conflicted, resolve that before retrying."
+      "If `package-lock.json` is stale or conflicted, resolve that before retrying.",
+      "",
+      "If this is a permission issue, try:",
+      "  sudo chown -R $(whoami) ~/.npm",
+      "  sudo chown -R $(whoami) " + PROJECT_DIR2 + "/node_modules"
     ]);
   }
 }
 function getBuiltWorker() {
-  const distWorkerDir = import_path12.default.join(PROJECT_DIR2, "dist-worker");
-  if (!import_fs_extra7.default.existsSync(distWorkerDir)) {
+  const distWorkerDir = import_path13.default.join(PROJECT_DIR2, "dist-worker");
+  if (!import_fs_extra8.default.existsSync(distWorkerDir)) {
     throw createConfigError("Built worker output not found: `dist-worker/`.", [
       "Make sure `npm run build:worker` completed successfully."
     ]);
   }
-  const workerJsPath = import_path12.default.join(distWorkerDir, "worker.js");
-  if (!import_fs_extra7.default.existsSync(workerJsPath)) {
+  const workerJsPath = import_path13.default.join(distWorkerDir, "worker.js");
+  if (!import_fs_extra8.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_extra7.default.readdirSync(distWorkerDir);
+  const files = import_fs_extra8.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_path13.default.join(distWorkerDir, file));
     }
   }
   return { workerJsPath, modulePaths };
 }
 function getSqlFiles() {
-  const sqlDir = import_path12.default.join(PROJECT_DIR2, "db");
-  if (!import_fs_extra7.default.existsSync(sqlDir)) {
+  const sqlDir = import_path13.default.join(PROJECT_DIR2, "db");
+  if (!import_fs_extra8.default.existsSync(sqlDir)) {
     return [];
   }
-  const files = import_fs_extra7.default.readdirSync(sqlDir).filter((f) => f.endsWith(".sql")).sort();
-  return files.map((f) => import_path12.default.join(sqlDir, f));
+  const files = import_fs_extra8.default.readdirSync(sqlDir).filter((f) => f.endsWith(".sql")).sort();
+  return files.map((f) => import_path13.default.join(sqlDir, f));
 }
 async function saveWorker(workerJsPath, modulePaths, sqlFiles, metadata, projectName) {
   var _a, _b;
-  console.log(import_chalk18.default.blue("Saving worker to platform..."));
-  console.log(import_chalk18.default.gray(`Project: ${projectName}`));
-  console.log(import_chalk18.default.gray(`workerJsPath: ${workerJsPath}`));
-  console.log(import_chalk18.default.gray(`modulePaths: ${modulePaths}`));
-  console.log(import_chalk18.default.gray(`sqlFiles: ${sqlFiles}`));
-  console.log(import_chalk18.default.gray(`metadata: ${metadata}`));
+  console.log(import_chalk19.default.blue("Saving worker to platform..."));
+  console.log(import_chalk19.default.gray(`Project: ${projectName}`));
+  console.log(import_chalk19.default.gray(`workerJsPath: ${workerJsPath}`));
+  console.log(import_chalk19.default.gray(`modulePaths: ${modulePaths}`));
+  console.log(import_chalk19.default.gray(`sqlFiles: ${sqlFiles}`));
+  console.log(import_chalk19.default.gray(`metadata: ${metadata}`));
   const apiUrl = `${API_BASE2}/save_worker?project_name=${encodeURIComponent(projectName)}`;
   const headers = getAuthHeaders();
-  console.log(import_chalk18.default.gray(`API URL: ${apiUrl}`));
+  console.log(import_chalk19.default.gray(`API URL: ${apiUrl}`));
   try {
     const FormData4 = (await import("formdata-node")).FormData;
     const Blob2 = (await import("formdata-node")).Blob;
@@ -7621,35 +7872,35 @@ 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_extra7.default.readFileSync(workerJsPath, "utf-8");
+    const workerCode = import_fs_extra8.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_path13.default.basename(modulePath);
+      const content = import_fs_extra8.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_path13.default.basename(sqlFile);
+      const content = import_fs_extra8.default.readFileSync(sqlFile, "utf-8");
       formData.append("sql_file", new Blob2([content], {
         type: "application/sql"
       }), filename);
-      console.log(import_chalk18.default.gray(`   Including SQL: ${filename}`));
+      console.log(import_chalk19.default.gray(`   Including SQL: ${filename}`));
     }
     const response = await axios_default.put(apiUrl, formData, {
       headers: { ...headers },
       timeout: 12e4
     });
-    console.log(import_chalk18.default.gray(`   Response: ${JSON.stringify(response.data)}`));
+    console.log(import_chalk19.default.gray(`   Response: ${JSON.stringify(response.data)}`));
     if (response.data) {
-      console.log(import_chalk18.default.green("Worker saved"));
+      console.log(import_chalk19.default.green("Worker saved"));
       if ((_b = (_a = response.data) == null ? void 0 : _a.data) == null ? void 0 : _b.sql_results) {
         for (const result of response.data.data.sql_results) {
-          console.log(import_chalk18.default.gray(`   SQL ${result.filename}: ${result.status}`));
+          console.log(import_chalk19.default.gray(`   SQL ${result.filename}: ${result.status}`));
         }
       }
     } else {
@@ -7670,13 +7921,13 @@ async function saveWorker(workerJsPath, modulePaths, sqlFiles, metadata, project
   }
 }
 function buildFrontend() {
-  console.log(import_chalk18.default.blue("Building frontend..."));
+  console.log(import_chalk19.default.blue("Building frontend..."));
   try {
-    (0, import_child_process3.execSync)("npm run build:frontend", {
+    (0, import_child_process4.execSync)("npm run build:frontend", {
       cwd: PROJECT_DIR2,
       stdio: "inherit"
     });
-    console.log(import_chalk18.default.green("Frontend built"));
+    console.log(import_chalk19.default.green("Frontend built"));
   } catch (error) {
     throw createCommandError("frontend build", "npm run build:frontend", error, [
       "Fix the frontend build error shown above, then rerun `pinme save`."
@@ -7684,17 +7935,40 @@ function buildFrontend() {
   }
 }
 function deployFrontend(projectName) {
-  console.log(import_chalk18.default.blue("Deploying frontend to IPFS..."));
+  console.log(import_chalk19.default.blue("Deploying frontend to IPFS..."));
   try {
-    (0, import_child_process3.execSync)("pinme upload ./frontend/dist", {
+    const uploadOutput = (0, import_child_process4.execSync)("pinme upload ./frontend/dist", {
       cwd: PROJECT_DIR2,
-      stdio: "inherit",
+      encoding: "utf-8",
       env: {
         ...process.env,
         PINME_PROJECT_NAME: projectName
       }
     });
-    console.log(import_chalk18.default.green("Frontend deployed to IPFS"));
+    console.log(uploadOutput);
+    const urlMatch = uploadOutput.match(/https:\/\/[\w-]+\.pinme\.dev/);
+    if (urlMatch) {
+      const frontendUrl = urlMatch[0];
+      console.log(import_chalk19.default.green(`Frontend deployed to IPFS: ${frontendUrl}`));
+      const configPath = import_path13.default.join(PROJECT_DIR2, "pinme.toml");
+      let config = import_fs_extra8.default.readFileSync(configPath, "utf-8");
+      if (config.includes("frontend_url")) {
+        config = config.replace(
+          /frontend_url\s*=\s*"[^"]*"/,
+          `frontend_url = "${frontendUrl}"`
+        );
+      } else {
+        config = config.replace(
+          /(project_name\s*=\s*"[^"]*"\n)/,
+          `$1frontend_url = "${frontendUrl}"
+`
+        );
+      }
+      import_fs_extra8.default.writeFileSync(configPath, config);
+      console.log(import_chalk19.default.green("Updated pinme.toml with frontend URL"));
+    } else {
+      console.log(import_chalk19.default.green("Frontend deployed to IPFS"));
+    }
   } catch (error) {
     throw createCommandError("frontend deploy", "pinme upload ./frontend/dist", error, [
       "Make sure `frontend/dist` exists and `pinme upload` works in this environment."
@@ -7709,14 +7983,14 @@ async function saveCmd(options) {
         "Run `pinme login` and retry."
       ]);
     }
-    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);
+    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);
     }
-    console.log(import_chalk18.default.blue("Deploying to platform...\n"));
-    console.log(import_chalk18.default.gray(`Project dir: ${PROJECT_DIR2}`));
+    console.log(import_chalk19.default.blue("Deploying to platform...\n"));
+    console.log(import_chalk19.default.gray(`Project dir: ${PROJECT_DIR2}`));
     const config = loadConfig();
     const projectName = config.project_name;
     if (!projectName) {
@@ -7724,23 +7998,23 @@ async function saveCmd(options) {
         'Set `project_name = "your-project-name"` in `pinme.toml`.'
       ]);
     }
-    console.log(import_chalk18.default.gray(`Project: ${projectName}`));
+    console.log(import_chalk19.default.gray(`Project: ${projectName}`));
     const apiUrl = `${API_BASE2}/save_worker?project_name=${encodeURIComponent(projectName)}`;
-    console.log(import_chalk18.default.gray(`API URL: ${apiUrl}`));
-    console.log(import_chalk18.default.blue("\n--- Backend ---"));
+    console.log(import_chalk19.default.gray(`API URL: ${apiUrl}`));
+    console.log(import_chalk19.default.blue("\n--- Backend ---"));
     installDependencies();
     buildWorker();
     const metadata = getMetadata();
     const { workerJsPath, modulePaths } = getBuiltWorker();
-    console.log(import_chalk18.default.gray(`Worker JS: ${workerJsPath}`));
-    console.log(import_chalk18.default.gray(`Module paths: ${JSON.stringify(modulePaths)}`));
+    console.log(import_chalk19.default.gray(`Worker JS: ${workerJsPath}`));
+    console.log(import_chalk19.default.gray(`Module paths: ${JSON.stringify(modulePaths)}`));
     const sqlFiles = getSqlFiles();
-    console.log(import_chalk18.default.gray(`SQL files: ${JSON.stringify(sqlFiles)}`));
+    console.log(import_chalk19.default.gray(`SQL files: ${JSON.stringify(sqlFiles)}`));
     await saveWorker(workerJsPath, modulePaths, sqlFiles, metadata, projectName);
-    console.log(import_chalk18.default.blue("\n--- Frontend ---"));
+    console.log(import_chalk19.default.blue("\n--- Frontend ---"));
     buildFrontend();
     deployFrontend(projectName);
-    console.log(import_chalk18.default.green("\nDeployment complete."));
+    console.log(import_chalk19.default.green("\nDeployment complete."));
     process.exit(0);
   } catch (error) {
     printCliError(error, "Save failed.");
@@ -7749,54 +8023,54 @@ async function saveCmd(options) {
 }
 
 // bin/updateDb.ts
-var import_chalk19 = __toESM(require("chalk"));
-var import_fs_extra8 = __toESM(require("fs-extra"));
-var import_path13 = __toESM(require("path"));
+var import_chalk20 = __toESM(require("chalk"));
+var import_fs_extra9 = __toESM(require("fs-extra"));
+var import_path14 = __toESM(require("path"));
 var PROJECT_DIR3 = process.cwd();
 var API_BASE3 = "https://pinme.dev/api/v4";
 function loadConfig2() {
-  const configPath = import_path13.default.join(PROJECT_DIR3, "pinme.toml");
-  if (!import_fs_extra8.default.existsSync(configPath)) {
+  const configPath = import_path14.default.join(PROJECT_DIR3, "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_extra8.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 getSqlFiles2() {
-  const sqlDir = import_path13.default.join(PROJECT_DIR3, "db");
-  if (!import_fs_extra8.default.existsSync(sqlDir)) {
+  const sqlDir = import_path14.default.join(PROJECT_DIR3, "db");
+  if (!import_fs_extra9.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_extra8.default.readdirSync(sqlDir).filter((f) => f.endsWith(".sql")).sort();
+  const files = import_fs_extra9.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_path13.default.join(sqlDir, f));
+  return files.map((f) => import_path14.default.join(sqlDir, f));
 }
 async function updateDb(sqlFiles, projectName) {
-  console.log(import_chalk19.default.blue("Importing SQL files to database..."));
-  console.log(import_chalk19.default.gray(`Project: ${projectName}`));
-  console.log(import_chalk19.default.gray(`SQL files: ${sqlFiles.length}`));
+  console.log(import_chalk20.default.blue("Importing SQL files to database..."));
+  console.log(import_chalk20.default.gray(`Project: ${projectName}`));
+  console.log(import_chalk20.default.gray(`SQL files: ${sqlFiles.length}`));
   const apiUrl = `${API_BASE3}/update_db?project_name=${encodeURIComponent(projectName)}`;
   const headers = getAuthHeaders();
-  console.log(import_chalk19.default.gray(`API URL: ${apiUrl}`));
+  console.log(import_chalk20.default.gray(`API URL: ${apiUrl}`));
   try {
     const FormData4 = (await import("formdata-node")).FormData;
     const Blob2 = (await import("formdata-node")).Blob;
     const formData = new FormData4();
     let totalSize = 0;
     for (const sqlFile of sqlFiles) {
-      const filename = import_path13.default.basename(sqlFile);
-      const content = import_fs_extra8.default.readFileSync(sqlFile);
+      const filename = import_path14.default.basename(sqlFile);
+      const content = import_fs_extra9.default.readFileSync(sqlFile);
       totalSize += content.length;
       if (totalSize > 10 * 1024 * 1024) {
         throw createConfigError("Total SQL payload exceeds the 10MB platform limit.", [
@@ -7806,24 +8080,24 @@ async function updateDb(sqlFiles, projectName) {
       formData.append("file", new Blob2([content], {
         type: "application/sql"
       }), filename);
-      console.log(import_chalk19.default.gray(`   Including: ${filename} (${content.length} bytes)`));
+      console.log(import_chalk20.default.gray(`   Including: ${filename} (${content.length} bytes)`));
     }
     const response = await axios_default.post(apiUrl, formData, {
       headers: { ...headers },
       timeout: 12e4
     });
-    console.log(import_chalk19.default.gray(`   Response: ${JSON.stringify(response.data)}`));
+    console.log(import_chalk20.default.gray(`   Response: ${JSON.stringify(response.data)}`));
     if (response.data.code === 200) {
-      console.log(import_chalk19.default.green("SQL files imported successfully!"));
+      console.log(import_chalk20.default.green("SQL files imported successfully!"));
       const results = response.data.data.results;
       for (const result of results) {
         if (result.status === "complete") {
-          console.log(import_chalk19.default.green(`   COMPLETE ${result.filename}: ${result.num_queries} queries, ${result.duration}ms`));
+          console.log(import_chalk20.default.green(`   COMPLETE ${result.filename}: ${result.num_queries} queries, ${result.duration}ms`));
           if (result.changes !== void 0) {
-            console.log(import_chalk19.default.gray(`     Changes: ${result.changes}, Read: ${result.rows_read}, Written: ${result.rows_written}`));
+            console.log(import_chalk20.default.gray(`     Changes: ${result.changes}, Read: ${result.rows_read}, Written: ${result.rows_written}`));
           }
         } else if (result.status === "error") {
-          console.log(import_chalk19.default.red(`   ERROR ${result.filename}: ${result.error}`));
+          console.log(import_chalk20.default.red(`   ERROR ${result.filename}: ${result.error}`));
         }
       }
     } else {
@@ -7851,14 +8125,14 @@ async function updateDbCmd(options) {
         "Run `pinme login` and retry."
       ]);
     }
-    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);
+    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);
     }
-    console.log(import_chalk19.default.blue("Importing SQL to database...\n"));
-    console.log(import_chalk19.default.gray(`Project dir: ${PROJECT_DIR3}`));
+    console.log(import_chalk20.default.blue("Importing SQL to database...\n"));
+    console.log(import_chalk20.default.gray(`Project dir: ${PROJECT_DIR3}`));
     const config = loadConfig2();
     const projectName = config.project_name;
     if (!projectName) {
@@ -7866,11 +8140,11 @@ async function updateDbCmd(options) {
         'Set `project_name = "your-project-name"` in `pinme.toml`.'
       ]);
     }
-    console.log(import_chalk19.default.gray(`Project: ${projectName}`));
+    console.log(import_chalk20.default.gray(`Project: ${projectName}`));
     const sqlFiles = getSqlFiles2();
-    console.log(import_chalk19.default.gray(`Found ${sqlFiles.length} SQL file(s) in db`));
+    console.log(import_chalk20.default.gray(`Found ${sqlFiles.length} SQL file(s) in db`));
     await updateDb(sqlFiles, projectName);
-    console.log(import_chalk19.default.green("\nDatabase update complete."));
+    console.log(import_chalk20.default.green("\nDatabase update complete."));
     process.exit(0);
   } catch (error) {
     printCliError(error, "Database update failed.");
@@ -7879,42 +8153,42 @@ async function updateDbCmd(options) {
 }
 
 // bin/updateWorker.ts
-var import_chalk20 = __toESM(require("chalk"));
-var import_fs_extra9 = __toESM(require("fs-extra"));
-var import_path14 = __toESM(require("path"));
-var import_child_process4 = require("child_process");
+var import_chalk21 = __toESM(require("chalk"));
+var import_fs_extra10 = __toESM(require("fs-extra"));
+var import_path15 = __toESM(require("path"));
+var import_child_process5 = require("child_process");
 var PROJECT_DIR4 = process.cwd();
 var API_BASE4 = "https://pinme.dev/api/v4";
 function loadConfig3() {
-  const configPath = import_path14.default.join(PROJECT_DIR4, "pinme.toml");
-  if (!import_fs_extra9.default.existsSync(configPath)) {
+  const configPath = import_path15.default.join(PROJECT_DIR4, "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_extra9.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]) || ""
   };
 }
 function getMetadata2() {
-  const metadataPath = import_path14.default.join(PROJECT_DIR4, "backend", "metadata.json");
-  if (!import_fs_extra9.default.existsSync(metadataPath)) {
+  const metadataPath = import_path15.default.join(PROJECT_DIR4, "backend", "metadata.json");
+  if (!import_fs_extra10.default.existsSync(metadataPath)) {
     throw createConfigError("`backend/metadata.json` not found.", [
       "Create `backend/metadata.json` or restore it from the project template."
     ]);
   }
-  return import_fs_extra9.default.readJsonSync(metadataPath);
+  return import_fs_extra10.default.readJsonSync(metadataPath);
 }
 function buildWorker2() {
-  console.log(import_chalk20.default.blue("Building worker..."));
+  console.log(import_chalk21.default.blue("Building worker..."));
   try {
-    (0, import_child_process4.execSync)("npm run build:worker", {
+    (0, import_child_process5.execSync)("npm run build:worker", {
       cwd: PROJECT_DIR4,
       stdio: "inherit"
     });
-    console.log(import_chalk20.default.green("Worker built"));
+    console.log(import_chalk21.default.green("Worker built"));
   } catch (error) {
     throw createCommandError("worker build", "npm run build:worker", error, [
       "Fix the build error shown above, then rerun `pinme update-worker`."
@@ -7922,36 +8196,36 @@ function buildWorker2() {
   }
 }
 function getBuiltWorker2() {
-  const distWorkerDir = import_path14.default.join(PROJECT_DIR4, "dist-worker");
-  if (!import_fs_extra9.default.existsSync(distWorkerDir)) {
+  const distWorkerDir = import_path15.default.join(PROJECT_DIR4, "dist-worker");
+  if (!import_fs_extra10.default.existsSync(distWorkerDir)) {
     throw createConfigError("Built worker output not found: `dist-worker/`.", [
       "Make sure `npm run build:worker` completed successfully."
     ]);
   }
-  const workerJsPath = import_path14.default.join(distWorkerDir, "worker.js");
-  if (!import_fs_extra9.default.existsSync(workerJsPath)) {
+  const workerJsPath = import_path15.default.join(distWorkerDir, "worker.js");
+  if (!import_fs_extra10.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_extra9.default.readdirSync(distWorkerDir);
+  const files = import_fs_extra10.default.readdirSync(distWorkerDir);
   for (const file of files) {
     if (file.endsWith(".js") && file !== "worker.js") {
-      modulePaths.push(import_path14.default.join(distWorkerDir, file));
+      modulePaths.push(import_path15.default.join(distWorkerDir, file));
     }
   }
   return { workerJsPath, modulePaths };
 }
 async function updateWorker(workerJsPath, modulePaths, metadata, projectName) {
-  console.log(import_chalk20.default.blue("Updating worker on platform..."));
-  console.log(import_chalk20.default.gray(`Project: ${projectName}`));
-  console.log(import_chalk20.default.gray(`workerJsPath: ${workerJsPath}`));
-  console.log(import_chalk20.default.gray(`modulePaths: ${modulePaths}`));
-  console.log(import_chalk20.default.gray(`metadata: ${metadata}`));
+  console.log(import_chalk21.default.blue("Updating worker on platform..."));
+  console.log(import_chalk21.default.gray(`Project: ${projectName}`));
+  console.log(import_chalk21.default.gray(`workerJsPath: ${workerJsPath}`));
+  console.log(import_chalk21.default.gray(`modulePaths: ${modulePaths}`));
+  console.log(import_chalk21.default.gray(`metadata: ${metadata}`));
   const apiUrl = `${API_BASE4}/update_worker?project_name=${encodeURIComponent(projectName)}`;
   const headers = getAuthHeaders();
-  console.log(import_chalk20.default.gray(`API URL: ${apiUrl}`));
+  console.log(import_chalk21.default.gray(`API URL: ${apiUrl}`));
   try {
     const FormData4 = (await import("formdata-node")).FormData;
     const Blob2 = (await import("formdata-node")).Blob;
@@ -7959,13 +8233,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_extra9.default.readFileSync(workerJsPath, "utf-8");
+    const workerCode = import_fs_extra10.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_path14.default.basename(modulePath);
-      const content = import_fs_extra9.default.readFileSync(modulePath, "utf-8");
+      const filename = import_path15.default.basename(modulePath);
+      const content = import_fs_extra10.default.readFileSync(modulePath, "utf-8");
       formData.append(filename, new Blob2([content], {
         type: "application/javascript+module"
       }), filename);
@@ -7974,33 +8248,33 @@ async function updateWorker(workerJsPath, modulePaths, metadata, projectName) {
       headers: { ...headers },
       timeout: 12e4
     });
-    console.log(import_chalk20.default.gray(`   Response: ${JSON.stringify(response.data)}`));
+    console.log(import_chalk21.default.gray(`   Response: ${JSON.stringify(response.data)}`));
     if (response.data) {
-      console.log(import_chalk20.default.green("Worker updated"));
+      console.log(import_chalk21.default.green("Worker updated"));
       const data = response.data.data;
       if (data.worker_id) {
-        console.log(import_chalk20.default.gray(`   Worker ID: ${data.worker_id}`));
+        console.log(import_chalk21.default.gray(`   Worker ID: ${data.worker_id}`));
       }
       if (data.deployment_id) {
-        console.log(import_chalk20.default.gray(`   Deployment ID: ${data.deployment_id}`));
+        console.log(import_chalk21.default.gray(`   Deployment ID: ${data.deployment_id}`));
       }
       if (data.entry_point) {
-        console.log(import_chalk20.default.gray(`   Entry Point: ${data.entry_point}`));
+        console.log(import_chalk21.default.gray(`   Entry Point: ${data.entry_point}`));
       }
       if (data.created_on) {
-        console.log(import_chalk20.default.gray(`   Created: ${data.created_on}`));
+        console.log(import_chalk21.default.gray(`   Created: ${data.created_on}`));
       }
       if (data.modified_on) {
-        console.log(import_chalk20.default.gray(`   Modified: ${data.modified_on}`));
+        console.log(import_chalk21.default.gray(`   Modified: ${data.modified_on}`));
       }
       if (data.startup_time_ms !== void 0) {
-        console.log(import_chalk20.default.gray(`   Startup Time: ${data.startup_time_ms}ms`));
+        console.log(import_chalk21.default.gray(`   Startup Time: ${data.startup_time_ms}ms`));
       }
       if (data.has_modules !== void 0) {
-        console.log(import_chalk20.default.gray(`   Has Modules: ${data.has_modules}`));
+        console.log(import_chalk21.default.gray(`   Has Modules: ${data.has_modules}`));
       }
       if (data.domain) {
-        console.log(import_chalk20.default.gray(`   Domain: ${data.domain}`));
+        console.log(import_chalk21.default.gray(`   Domain: ${data.domain}`));
       }
     } else {
       throw createApiError("worker update", { response: { data: response.data } }, [
@@ -8027,14 +8301,14 @@ async function updateWorkerCmd(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_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);
+    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);
     }
-    console.log(import_chalk20.default.blue("Updating worker...\n"));
-    console.log(import_chalk20.default.gray(`Project dir: ${PROJECT_DIR4}`));
+    console.log(import_chalk21.default.blue("Updating worker...\n"));
+    console.log(import_chalk21.default.gray(`Project dir: ${PROJECT_DIR4}`));
     const config = loadConfig3();
     const projectName = config.project_name;
     if (!projectName) {
@@ -8042,16 +8316,16 @@ async function updateWorkerCmd(options) {
         'Set `project_name = "your-project-name"` in `pinme.toml`.'
       ]);
     }
-    console.log(import_chalk20.default.gray(`Project: ${projectName}`));
-    console.log(import_chalk20.default.blue("\n--- Worker Update ---"));
+    console.log(import_chalk21.default.gray(`Project: ${projectName}`));
+    console.log(import_chalk21.default.blue("\n--- Worker Update ---"));
     buildWorker2();
     const metadata = getMetadata2();
     const { workerJsPath, modulePaths } = getBuiltWorker2();
-    console.log(import_chalk20.default.gray(`Worker JS: ${workerJsPath}`));
-    console.log(import_chalk20.default.gray(`Module paths: ${JSON.stringify(modulePaths)}`));
-    console.log(import_chalk20.default.gray(`SQL files: ignored (not processed for update_worker)`));
+    console.log(import_chalk21.default.gray(`Worker JS: ${workerJsPath}`));
+    console.log(import_chalk21.default.gray(`Module paths: ${JSON.stringify(modulePaths)}`));
+    console.log(import_chalk21.default.gray(`SQL files: ignored (not processed for update_worker)`));
     await updateWorker(workerJsPath, modulePaths, metadata, projectName);
-    console.log(import_chalk20.default.green("\nWorker update complete."));
+    console.log(import_chalk21.default.green("\nWorker update complete."));
     process.exit(0);
   } catch (error) {
     printCliError(error, "Worker update failed.");
@@ -8060,32 +8334,32 @@ async function updateWorkerCmd(options) {
 }
 
 // bin/updateWeb.ts
-var import_chalk21 = __toESM(require("chalk"));
-var import_fs_extra10 = __toESM(require("fs-extra"));
-var import_path15 = __toESM(require("path"));
-var import_child_process5 = require("child_process");
+var import_chalk22 = __toESM(require("chalk"));
+var import_fs_extra11 = __toESM(require("fs-extra"));
+var import_path16 = __toESM(require("path"));
+var import_child_process6 = require("child_process");
 var PROJECT_DIR5 = process.cwd();
 function loadConfig4() {
-  const configPath = import_path15.default.join(PROJECT_DIR5, "pinme.toml");
-  if (!import_fs_extra10.default.existsSync(configPath)) {
+  const configPath = import_path16.default.join(PROJECT_DIR5, "pinme.toml");
+  if (!import_fs_extra11.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_extra11.default.readFileSync(configPath, "utf-8");
   const projectNameMatch = configContent.match(/project_name\s*=\s*"([^"]+)"/);
   return {
     project_name: (projectNameMatch == null ? void 0 : projectNameMatch[1]) || ""
   };
 }
 function buildFrontend2() {
-  console.log(import_chalk21.default.blue("Building frontend..."));
+  console.log(import_chalk22.default.blue("Building frontend..."));
   try {
-    (0, import_child_process5.execSync)("npm run build:frontend", {
+    (0, import_child_process6.execSync)("npm run build:frontend", {
       cwd: PROJECT_DIR5,
       stdio: "inherit"
     });
-    console.log(import_chalk21.default.green("Frontend built"));
+    console.log(import_chalk22.default.green("Frontend built"));
   } catch (error) {
     throw createCommandError("frontend build", "npm run build:frontend", error, [
       "Fix the frontend build error shown above, then rerun `pinme update-web`."
@@ -8093,9 +8367,9 @@ function buildFrontend2() {
   }
 }
 function deployFrontend2(projectName) {
-  console.log(import_chalk21.default.blue("Deploying frontend to IPFS..."));
+  console.log(import_chalk22.default.blue("Deploying frontend to IPFS..."));
   try {
-    (0, import_child_process5.execSync)("pinme upload ./frontend/dist", {
+    (0, import_child_process6.execSync)("pinme upload ./frontend/dist", {
       cwd: PROJECT_DIR5,
       stdio: "inherit",
       env: {
@@ -8103,7 +8377,7 @@ function deployFrontend2(projectName) {
         PINME_PROJECT_NAME: projectName
       }
     });
-    console.log(import_chalk21.default.green("Frontend deployed to IPFS"));
+    console.log(import_chalk22.default.green("Frontend deployed to IPFS"));
   } catch (error) {
     throw createCommandError("frontend deploy", "pinme upload ./frontend/dist", error, [
       "Make sure `frontend/dist` exists and `pinme upload` can run successfully."
@@ -8118,14 +8392,14 @@ async function updateWebCmd(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_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);
+    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);
     }
-    console.log(import_chalk21.default.blue("Updating web (frontend)...\n"));
-    console.log(import_chalk21.default.gray(`Project dir: ${PROJECT_DIR5}`));
+    console.log(import_chalk22.default.blue("Updating web (frontend)...\n"));
+    console.log(import_chalk22.default.gray(`Project dir: ${PROJECT_DIR5}`));
     const config = loadConfig4();
     const projectName = config.project_name;
     if (!projectName) {
@@ -8133,11 +8407,11 @@ async function updateWebCmd(options) {
         'Set `project_name = "your-project-name"` in `pinme.toml`.'
       ]);
     }
-    console.log(import_chalk21.default.gray(`Project: ${projectName}`));
-    console.log(import_chalk21.default.blue("\n--- Frontend Update ---"));
+    console.log(import_chalk22.default.gray(`Project: ${projectName}`));
+    console.log(import_chalk22.default.blue("\n--- Frontend Update ---"));
     buildFrontend2();
     deployFrontend2(projectName);
-    console.log(import_chalk21.default.green("\nWeb update complete."));
+    console.log(import_chalk22.default.green("\nWeb update complete."));
     process.exit(0);
   } catch (error) {
     printCliError(error, "Web update failed.");
@@ -8146,17 +8420,17 @@ async function updateWebCmd(options) {
 }
 
 // bin/delete.ts
-var import_chalk22 = __toESM(require("chalk"));
+var import_chalk23 = __toESM(require("chalk"));
 var import_inquirer9 = __toESM(require("inquirer"));
-var import_fs_extra11 = __toESM(require("fs-extra"));
-var import_path16 = __toESM(require("path"));
+var import_fs_extra12 = __toESM(require("fs-extra"));
+var import_path17 = __toESM(require("path"));
 var API_BASE5 = "https://pinme.dev/api/v4";
 function getProjectName() {
-  const configPath = import_path16.default.join(process.cwd(), "pinme.toml");
-  if (!import_fs_extra11.default.existsSync(configPath)) {
+  const configPath = import_path17.default.join(process.cwd(), "pinme.toml");
+  if (!import_fs_extra12.default.existsSync(configPath)) {
     return null;
   }
-  const config = import_fs_extra11.default.readFileSync(configPath, "utf-8");
+  const config = import_fs_extra12.default.readFileSync(configPath, "utf-8");
   const match = config.match(/project_name\s*=\s*"([^"]+)"/);
   return (match == null ? void 0 : match[1]) || null;
 }
@@ -8165,23 +8439,23 @@ async function deleteCmd(options) {
   try {
     const headers = getAuthHeaders();
     if (!headers["authentication-tokens"] || !headers["token-address"]) {
-      console.log(import_chalk22.default.yellow("\n\u26A0\uFE0F  You are not logged in."));
-      console.log(import_chalk22.default.gray("Please run: pinme login"));
+      console.log(import_chalk23.default.yellow("\n\u26A0\uFE0F  You are not logged in."));
+      console.log(import_chalk23.default.gray("Please run: pinme login"));
       process.exit(1);
     }
-    console.log(import_chalk22.default.blue("Deleting project...\n"));
+    console.log(import_chalk23.default.blue("Deleting project...\n"));
     let projectName = options.name || getProjectName();
     if (!projectName) {
-      console.log(import_chalk22.default.red("\n\u274C Error: Cannot find project name."));
-      console.log(import_chalk22.default.yellow("   Please make sure you are in the project directory."));
-      console.log(import_chalk22.default.gray("   The project directory should contain a pinme.toml file."));
-      console.log(import_chalk22.default.gray("\n   Or specify the project name:"));
-      console.log(import_chalk22.default.gray("   cd /path/to/your-project"));
-      console.log(import_chalk22.default.gray("   pinme delete"));
+      console.log(import_chalk23.default.red("\n\u274C Error: Cannot find project name."));
+      console.log(import_chalk23.default.yellow("   Please make sure you are in the project directory."));
+      console.log(import_chalk23.default.gray("   The project directory should contain a pinme.toml file."));
+      console.log(import_chalk23.default.gray("\n   Or specify the project name:"));
+      console.log(import_chalk23.default.gray("   cd /path/to/your-project"));
+      console.log(import_chalk23.default.gray("   pinme delete"));
       process.exit(1);
     }
-    console.log(import_chalk22.default.gray(`Project: ${projectName}`));
-    console.log(import_chalk22.default.gray(`Directory: ${process.cwd()}`));
+    console.log(import_chalk23.default.gray(`Project: ${projectName}`));
+    console.log(import_chalk23.default.gray(`Directory: ${process.cwd()}`));
     if (!options.force) {
       const answers = await import_inquirer9.default.prompt([
         {
@@ -8192,14 +8466,14 @@ async function deleteCmd(options) {
         }
       ]);
       if (!answers.confirm) {
-        console.log(import_chalk22.default.gray("Cancelled."));
+        console.log(import_chalk23.default.gray("Cancelled."));
         process.exit(0);
       }
     }
-    console.log(import_chalk22.default.blue("Deleting project on platform..."));
+    console.log(import_chalk23.default.blue("Deleting project on platform..."));
     const apiUrl = `${API_BASE5}/delete_project`;
-    console.log(import_chalk22.default.gray(`API URL: ${apiUrl}`));
-    console.log(import_chalk22.default.gray(`Project name: ${projectName}`));
+    console.log(import_chalk23.default.gray(`API URL: ${apiUrl}`));
+    console.log(import_chalk23.default.gray(`Project name: ${projectName}`));
     const response = await axios_default.post(apiUrl, {
       project_name: projectName
     }, {
@@ -8210,31 +8484,31 @@ async function deleteCmd(options) {
     }).catch((error) => {
       var _a2, _b2;
       if (error.response) {
-        console.log(import_chalk22.default.red(`   Response status: ${(_a2 = error.response) == null ? void 0 : _a2.status}`));
-        console.log(import_chalk22.default.red(`   Response data: ${JSON.stringify((_b2 = error.response) == null ? void 0 : _b2.data)}`));
+        console.log(import_chalk23.default.red(`   Response status: ${(_a2 = error.response) == null ? void 0 : _a2.status}`));
+        console.log(import_chalk23.default.red(`   Response data: ${JSON.stringify((_b2 = error.response) == null ? void 0 : _b2.data)}`));
       } else {
-        console.log(import_chalk22.default.red("No Response"));
+        console.log(import_chalk23.default.red("No Response"));
       }
       throw error;
     });
     const data = response.data;
     if (data.code === 200) {
-      console.log(import_chalk22.default.green("\n\u2705 Project deleted successfully!"));
-      console.log(import_chalk22.default.gray(`
+      console.log(import_chalk23.default.green("\n\u2705 Project deleted successfully!"));
+      console.log(import_chalk23.default.gray(`
 Project: ${data.data.project_name}`));
-      console.log(import_chalk22.default.gray(`   Domain deleted: ${data.data.domain_deleted ? "\u2705" : "\u274C"}`));
-      console.log(import_chalk22.default.gray(`   Worker deleted: ${data.data.worker_deleted ? "\u2705" : "\u274C"}`));
-      console.log(import_chalk22.default.gray(`   Database deleted: ${data.data.database_deleted ? "\u2705" : "\u274C"}`));
-      console.log(import_chalk22.default.gray("\nLocal files are kept unchanged."));
+      console.log(import_chalk23.default.gray(`   Domain deleted: ${data.data.domain_deleted ? "\u2705" : "\u274C"}`));
+      console.log(import_chalk23.default.gray(`   Worker deleted: ${data.data.worker_deleted ? "\u2705" : "\u274C"}`));
+      console.log(import_chalk23.default.gray(`   Database deleted: ${data.data.database_deleted ? "\u2705" : "\u274C"}`));
+      console.log(import_chalk23.default.gray("\nLocal files are kept unchanged."));
     } else {
       const errorMsg = (data == null ? void 0 : data.msg) || "Failed to delete project";
       throw new Error(errorMsg);
     }
     process.exit(0);
   } catch (error) {
-    console.log(import_chalk22.default.red(error));
+    console.log(import_chalk23.default.red(error));
     const errorMsg = ((_b = (_a = error.response) == null ? void 0 : _a.data) == null ? void 0 : _b.msg) || error.message || "Failed to delete project";
-    console.error(import_chalk22.default.red(`
+    console.error(import_chalk23.default.red(`
 \u274C Error: ${errorMsg}`));
     process.exit(1);
   }
@@ -8245,9 +8519,9 @@ import_dotenv.default.config();
 checkNodeVersion();
 function showBanner() {
   console.log(
-    import_chalk23.default.cyan(import_figlet5.default.textSync("Pinme", { horizontalLayout: "full" }))
+    import_chalk24.default.cyan(import_figlet5.default.textSync("Pinme", { horizontalLayout: "full" }))
   );
-  console.log(import_chalk23.default.cyan("A command-line tool for uploading files to IPFS\n"));
+  console.log(import_chalk24.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");