pinme 2.0.4 → 2.0.5

package/dist/index.js

@@ -103,9 +103,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;
@@ -207,7 +207,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`;
             }
           }
@@ -215,15 +215,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);
@@ -239,7 +239,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) {
@@ -262,13 +262,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;
         }
@@ -828,9 +828,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 ? "." : "");
@@ -872,9 +872,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);
@@ -893,7 +893,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 = [];
@@ -902,10 +902,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) {
@@ -913,11 +913,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();
@@ -1137,7 +1137,7 @@ var init_platform = __esm({
 // 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;
@@ -1174,10 +1174,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)) {
@@ -1190,7 +1190,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]);
     }
@@ -2165,7 +2165,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;
@@ -2203,7 +2203,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;
         }
@@ -3516,9 +3516,9 @@ var init_http = __esm({
           auth = urlUsername + ":" + urlPassword;
         }
         auth && headers.delete("authorization");
-        let path17;
+        let path18;
         try {
-          path17 = buildURL(
+          path18 = buildURL(
             parsed.pathname + parsed.search,
             config.params,
             config.paramsSerializer
@@ -3536,7 +3536,7 @@ var init_http = __esm({
           false
         );
         const options = {
-          path: path17,
+          path: path18,
           method,
           headers: headers.toJSON(),
           agents: { http: config.httpAgent, https: config.httpsAgent },
@@ -3763,14 +3763,14 @@ var init_cookies = __esm({
       // 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);
@@ -5707,10 +5707,11 @@ async function getRootDomain(forceRefresh = false) {
 }
 async function checkDomainAvailable(domainName) {
   var _a2, _b;
-  if (isDnsDomain(domainName))
+  if (isDnsDomain(domainName)) {
     return await {
       is_valid: true
     };
+  }
   const client = createPinmeApiClient();
   const configured = APP_CONFIG.pinmeCheckDomainPath;
   const fallbacks = [configured];
@@ -5977,14 +5978,14 @@ var import_chalk26 = __toESM(require("chalk"));
 var import_figlet5 = __toESM(require("figlet"));
 
 // package.json
-var version = "2.0.4";
+var version = "2.0.5";
 
 // bin/upload.ts
-var import_path6 = __toESM(require("path"));
+var import_path7 = __toESM(require("path"));
 var import_chalk7 = __toESM(require("chalk"));
 var import_inquirer = __toESM(require("inquirer"));
 var import_figlet = __toESM(require("figlet"));
-var import_fs2 = __toESM(require("fs"));
+var import_fs3 = __toESM(require("fs"));
 init_pinmeApi();
 init_webLogin();
 init_config();
@@ -6024,7 +6025,7 @@ function getUid() {
 // bin/utils/uploadToIpfsSplit.ts
 init_axios2();
 var import_fs_extra4 = __toESM(require("fs-extra"));
-var import_path5 = __toESM(require("path"));
+var import_path6 = __toESM(require("path"));
 var import_form_data2 = __toESM(require("form-data"));
 var import_ora = __toESM(require("ora"));
 var crypto2 = __toESM(require("crypto"));
@@ -6076,13 +6077,326 @@ init_cliError();
 
 // bin/utils/history.ts
 var import_fs_extra3 = __toESM(require("fs-extra"));
-var import_path4 = __toESM(require("path"));
-var import_os3 = __toESM(require("os"));
+var import_path5 = __toESM(require("path"));
+var import_os4 = __toESM(require("os"));
 var import_dayjs = __toESM(require("dayjs"));
 var import_chalk5 = __toESM(require("chalk"));
 init_pinmeApi();
-var HISTORY_DIR = import_path4.default.join(import_os3.default.homedir(), ".pinme");
-var HISTORY_FILE = import_path4.default.join(HISTORY_DIR, "upload-history.json");
+
+// bin/utils/tracker.ts
+var import_os3 = __toESM(require("os"));
+var import_fs2 = __toESM(require("fs"));
+var import_path4 = __toESM(require("path"));
+var import_child_process2 = require("child_process");
+var REQUEST_TIMEOUT_MS = 1500;
+var DEFAULT_GATEWAY = "https://pinme.dev";
+var DEFAULT_PRODUCT = "pinme-cli";
+var ACTION_OVERRIDES = {
+  cli_login_success: "success",
+  cli_login_failed: "fail",
+  appkey_set_success: "success",
+  appkey_set_failed: "fail",
+  appkey_shown_success: "view",
+  appkey_shown_failed: "fail",
+  my_domains_success: "view",
+  my_domains_failed: "fail",
+  wallet_balance_success: "view",
+  wallet_balance_failed: "fail",
+  upload_history_viewed: "view",
+  upload_history_cleared: "click",
+  upload_history_failed: "fail"
+};
+var TRACK_CHILD_SCRIPT = `
+const rawUrl = process.argv[1];
+if (!rawUrl) process.exit(0);
+try {
+  const transport = rawUrl.startsWith('https:') ? require('https') : require('http');
+  const req = transport.get(rawUrl, {
+    headers: {
+      'User-Agent': 'Pinme-CLI-Tracker'
+    }
+  }, (res) => {
+    res.resume();
+    res.on('end', () => process.exit(0));
+  });
+  req.setTimeout(${REQUEST_TIMEOUT_MS}, () => req.destroy());
+  req.on('error', () => process.exit(0));
+  req.on('close', () => process.exit(0));
+} catch (_) {
+  process.exit(0);
+}
+`;
+function trimTrailingSlash2(value) {
+  return value.replace(/\/+$/, "");
+}
+function shouldDisableTracking() {
+  return process.env.PINME_TRACKING_DISABLED === "1" || process.env.DO_NOT_TRACK === "1";
+}
+function sanitizeTrackValue(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  return String(value).trim().slice(0, 200);
+}
+function getTrackErrorReason(error) {
+  var _a2, _b, _c, _d, _e;
+  const candidate = ((_b = (_a2 = error == null ? void 0 : error.response) == null ? void 0 : _a2.data) == null ? void 0 : _b.msg) || ((_d = (_c = error == null ? void 0 : error.response) == null ? void 0 : _c.data) == null ? void 0 : _d.message) || (error == null ? void 0 : error.message) || ((_e = error == null ? void 0 : error.toString) == null ? void 0 : _e.call(error)) || "unknown_error";
+  return sanitizeTrackValue(candidate) || "unknown_error";
+}
+function resolveTrackAction(event, data = {}) {
+  const explicitAction = data.a;
+  if (typeof explicitAction === "string" && explicitAction.trim()) {
+    return explicitAction.trim();
+  }
+  if (ACTION_OVERRIDES[event]) {
+    return ACTION_OVERRIDES[event];
+  }
+  if (event.endsWith("_success")) {
+    return "success";
+  }
+  if (event.endsWith("_failed") || event.endsWith("_fail")) {
+    return "fail";
+  }
+  if (event.includes("click") || event.includes("copied")) {
+    return "click";
+  }
+  if (event.includes("exposure")) {
+    return "exposure";
+  }
+  if (event.includes("view")) {
+    return "view";
+  }
+  if (event.endsWith("_started") || event.endsWith("_submit")) {
+    return "submit";
+  }
+  return "view";
+}
+var cachedProjectContext = null;
+var cachedProjectContextCwd = null;
+function resolveProjectContext() {
+  const cwd = process.cwd();
+  if (cachedProjectContext && cachedProjectContextCwd === cwd) {
+    return cachedProjectContext;
+  }
+  const context = {};
+  const configPath = import_path4.default.join(cwd, "pinme.toml");
+  if (import_fs2.default.existsSync(configPath)) {
+    try {
+      const configContent = import_fs2.default.readFileSync(configPath, "utf8");
+      const projectNameMatch = configContent.match(
+        /project_name\s*=\s*"([^"]+)"/
+      );
+      context.projectName = sanitizeTrackValue(projectNameMatch == null ? void 0 : projectNameMatch[1]) || sanitizeTrackValue(process.env.PINME_PROJECT_NAME);
+      context.projectDir = sanitizeTrackValue(import_path4.default.basename(cwd));
+    } catch (_) {
+      context.projectName = sanitizeTrackValue(process.env.PINME_PROJECT_NAME);
+    }
+  } else {
+    context.projectName = sanitizeTrackValue(process.env.PINME_PROJECT_NAME);
+  }
+  cachedProjectContext = context;
+  cachedProjectContextCwd = cwd;
+  return context;
+}
+function getPathKind(pathValue) {
+  try {
+    const stat = import_fs2.default.statSync(pathValue);
+    if (stat.isDirectory()) {
+      return "directory";
+    }
+    if (stat.isFile()) {
+      return "file";
+    }
+  } catch (_) {
+    return "unknown";
+  }
+  return "unknown";
+}
+var Tracker = class _Tracker {
+  static instance;
+  gateway;
+  product;
+  source;
+  disabled;
+  constructor(gateway, product) {
+    this.gateway = trimTrailingSlash2(
+      gateway || process.env.PINME_TRACKER_GATEWAY || DEFAULT_GATEWAY
+    );
+    this.product = product || DEFAULT_PRODUCT;
+    this.source = sanitizeTrackValue(process.env.PINME_TRACK_SOURCE);
+    this.disabled = shouldDisableTracking();
+  }
+  static getInstance(gateway, product) {
+    if (!_Tracker.instance) {
+      _Tracker.instance = new _Tracker(gateway, product);
+    }
+    return _Tracker.instance;
+  }
+  trackEvent(event, page, data = {}) {
+    if (this.disabled || !this.gateway) {
+      return Promise.resolve();
+    }
+    try {
+      const payload = this.buildPayload(event, page, data);
+      const params = new URLSearchParams(payload).toString();
+      const url2 = `${this.gateway}/track.gif?${params}`;
+      this.dispatch(url2);
+    } catch (_) {
+    }
+    return Promise.resolve();
+  }
+  buildPayload(event, page, data) {
+    const projectContext = resolveProjectContext();
+    const action = resolveTrackAction(event, data);
+    const payload = {
+      ...data,
+      u: getUid(),
+      s: this.source,
+      pd: this.product,
+      p: page,
+      a: action,
+      ev: event,
+      event,
+      project_name: projectContext.projectName,
+      project_dir: projectContext.projectDir,
+      cli_version: version,
+      node_version: process.version,
+      os: import_os3.default.platform(),
+      arch: import_os3.default.arch()
+    };
+    const filtered = {};
+    for (const [key, value] of Object.entries(payload)) {
+      const normalized = sanitizeTrackValue(value);
+      if (normalized) {
+        filtered[key] = normalized;
+      }
+    }
+    return filtered;
+  }
+  dispatch(url2) {
+    const child = (0, import_child_process2.spawn)(process.execPath, ["-e", TRACK_CHILD_SCRIPT, url2], {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true
+    });
+    child.unref();
+  }
+};
+var tracker = Tracker.getInstance();
+var tracker_default = tracker;
+
+// bin/utils/trackerEvents.ts
+var TRACK_PAGES = {
+  auth: "cli_auth",
+  login: "cli_login",
+  upload: "cli_upload",
+  import: "cli_import",
+  export: "cli_export",
+  remove: "cli_remove",
+  domain: "cli_domain",
+  wallet: "cli_wallet",
+  project: "cli_project",
+  deploy: "cli_deploy"
+};
+var TRACK_EVENTS = {
+  cliLoginSuccess: "cli_login_success",
+  cliLoginFailed: "cli_login_failed",
+  appKeySetSuccess: "appkey_set_success",
+  appKeySetFailed: "appkey_set_failed",
+  logoutSuccess: "logout_success",
+  logoutFailed: "logout_failed",
+  uploadSuccess: "upload_success",
+  uploadFailed: "upload_failed",
+  importSuccess: "import_success",
+  importFailed: "import_failed",
+  exportSuccess: "export_success",
+  exportFailed: "export_failed",
+  removeSuccess: "remove_success",
+  removeFailed: "remove_failed",
+  domainBindSuccess: "domain_bind_success",
+  domainBindFailed: "domain_bind_failed",
+  myDomainsSuccess: "my_domains_success",
+  myDomainsFailed: "my_domains_failed",
+  walletBalanceSuccess: "wallet_balance_success",
+  walletBalanceFailed: "wallet_balance_failed",
+  projectCreateSuccess: "project_create_success",
+  projectCreateFailed: "project_create_failed",
+  projectSaveSuccess: "project_save_success",
+  projectSaveFailed: "project_save_failed",
+  projectUpdateDbSuccess: "project_update_db_success",
+  projectUpdateDbFailed: "project_update_db_failed",
+  projectUpdateWorkerSuccess: "project_update_worker_success",
+  projectUpdateWorkerFailed: "project_update_worker_failed",
+  projectDeleteSuccess: "project_delete_success",
+  projectDeleteFailed: "project_delete_failed",
+  projectUpdateWebSuccess: "project_update_web_success",
+  projectUpdateWebFailed: "project_update_web_failed",
+  appKeyShownSuccess: "appkey_shown_success",
+  appKeyShownFailed: "appkey_shown_failed",
+  uploadHistoryViewed: "upload_history_viewed",
+  uploadHistoryCleared: "upload_history_cleared",
+  uploadHistoryFailed: "upload_history_failed"
+};
+var TRACK_ACTIONS = {
+  init: "init",
+  click: "click",
+  view: "view",
+  exposure: "exposure",
+  submit: "submit",
+  success: "success",
+  fail: "fail"
+};
+function resolveTrackAction2(event) {
+  switch (event) {
+    case TRACK_EVENTS.uploadHistoryViewed:
+    case TRACK_EVENTS.myDomainsSuccess:
+    case TRACK_EVENTS.walletBalanceSuccess:
+    case TRACK_EVENTS.appKeyShownSuccess:
+      return TRACK_ACTIONS.view;
+    case TRACK_EVENTS.uploadHistoryCleared:
+      return TRACK_ACTIONS.click;
+    case TRACK_EVENTS.uploadSuccess:
+    case TRACK_EVENTS.importSuccess:
+    case TRACK_EVENTS.exportSuccess:
+    case TRACK_EVENTS.removeSuccess:
+    case TRACK_EVENTS.domainBindSuccess:
+    case TRACK_EVENTS.cliLoginSuccess:
+    case TRACK_EVENTS.appKeySetSuccess:
+    case TRACK_EVENTS.logoutSuccess:
+    case TRACK_EVENTS.projectCreateSuccess:
+    case TRACK_EVENTS.projectSaveSuccess:
+    case TRACK_EVENTS.projectUpdateDbSuccess:
+    case TRACK_EVENTS.projectUpdateWorkerSuccess:
+    case TRACK_EVENTS.projectUpdateWebSuccess:
+    case TRACK_EVENTS.projectDeleteSuccess:
+      return TRACK_ACTIONS.success;
+    case TRACK_EVENTS.uploadFailed:
+    case TRACK_EVENTS.importFailed:
+    case TRACK_EVENTS.exportFailed:
+    case TRACK_EVENTS.removeFailed:
+    case TRACK_EVENTS.domainBindFailed:
+    case TRACK_EVENTS.cliLoginFailed:
+    case TRACK_EVENTS.appKeySetFailed:
+    case TRACK_EVENTS.logoutFailed:
+    case TRACK_EVENTS.myDomainsFailed:
+    case TRACK_EVENTS.walletBalanceFailed:
+    case TRACK_EVENTS.projectCreateFailed:
+    case TRACK_EVENTS.projectSaveFailed:
+    case TRACK_EVENTS.projectUpdateDbFailed:
+    case TRACK_EVENTS.projectUpdateWorkerFailed:
+    case TRACK_EVENTS.projectUpdateWebFailed:
+    case TRACK_EVENTS.projectDeleteFailed:
+    case TRACK_EVENTS.appKeyShownFailed:
+    case TRACK_EVENTS.uploadHistoryFailed:
+      return TRACK_ACTIONS.fail;
+    default:
+      return TRACK_ACTIONS.view;
+  }
+}
+
+// bin/utils/history.ts
+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 ensureHistoryDir = () => {
   if (!import_fs_extra3.default.existsSync(HISTORY_DIR)) {
     import_fs_extra3.default.mkdirSync(HISTORY_DIR, { recursive: true });
@@ -6099,7 +6413,7 @@ var saveUploadHistory = (uploadData) => {
       timestamp: Date.now(),
       date: (0, import_dayjs.default)().format("YYYY-MM-DD HH:mm:ss"),
       path: uploadData.path,
-      filename: uploadData.filename || import_path4.default.basename(uploadData.path),
+      filename: uploadData.filename || import_path5.default.basename(uploadData.path),
       contentHash: uploadData.contentHash,
       previewHash: uploadData.previewHash,
       size: uploadData.size,
@@ -6158,55 +6472,78 @@ async function formatHistoryUrl(value, options) {
   return `https://${normalized}`;
 }
 var displayUploadHistory = async (limit = 10) => {
-  const history = getUploadHistory(limit);
-  if (history.length === 0) {
-    console.log(import_chalk5.default.yellow("No upload history found."));
-    return;
-  }
-  console.log(import_chalk5.default.cyan("Upload History:"));
-  console.log(import_chalk5.default.cyan("-".repeat(80)));
-  let rootDomain = null;
   try {
-    rootDomain = await getRootDomain();
-  } catch {
-    rootDomain = null;
-  }
-  const recentHistory = history.slice(-limit);
-  for (const [index, item] of recentHistory.entries()) {
-    console.log(import_chalk5.default.green(`${index + 1}. ${item.filename}`));
-    console.log(import_chalk5.default.white(`   Path: ${item.path}`));
-    console.log(import_chalk5.default.white(`   IPFS CID: ${item.contentHash}`));
-    const preferredUrl = await formatHistoryUrl(item.dnsUrl) || await formatHistoryUrl(item.pinmeUrl, {
-      appendRootDomain: true,
-      rootDomain
-    }) || await formatHistoryUrl(item.shortUrl, {
-      appendRootDomain: true,
-      rootDomain
+    const history = getUploadHistory(limit);
+    void tracker_default.trackEvent(TRACK_EVENTS.uploadHistoryViewed, TRACK_PAGES.upload, {
+      a: resolveTrackAction2(TRACK_EVENTS.uploadHistoryViewed),
+      record_count: history.length,
+      limit
     });
-    if (preferredUrl) {
-      console.log(import_chalk5.default.white(`   URL: ${preferredUrl}`));
-    }
-    console.log(import_chalk5.default.white(`   Size: ${formatSize(item.size)}`));
-    console.log(import_chalk5.default.white(`   Files: ${item.fileCount}`));
-    console.log(import_chalk5.default.white(`   Type: ${item.type === "directory" ? "Directory" : "File"}`));
-    if (item.timestamp) {
-      console.log(import_chalk5.default.white(`   Date: ${new Date(item.timestamp).toLocaleString()}`));
+    if (history.length === 0) {
+      console.log(import_chalk5.default.yellow("No upload history found."));
+      return;
     }
+    console.log(import_chalk5.default.cyan("Upload History:"));
     console.log(import_chalk5.default.cyan("-".repeat(80)));
+    let rootDomain = null;
+    try {
+      rootDomain = await getRootDomain();
+    } catch {
+      rootDomain = null;
+    }
+    const recentHistory = history.slice(-limit);
+    for (const [index, item] of recentHistory.entries()) {
+      console.log(import_chalk5.default.green(`${index + 1}. ${item.filename}`));
+      console.log(import_chalk5.default.white(`   Path: ${item.path}`));
+      console.log(import_chalk5.default.white(`   IPFS CID: ${item.contentHash}`));
+      const preferredUrl = await formatHistoryUrl(item.dnsUrl) || await formatHistoryUrl(item.pinmeUrl, {
+        appendRootDomain: true,
+        rootDomain
+      }) || await formatHistoryUrl(item.shortUrl, {
+        appendRootDomain: true,
+        rootDomain
+      });
+      if (preferredUrl) {
+        console.log(import_chalk5.default.white(`   URL: ${preferredUrl}`));
+      }
+      console.log(import_chalk5.default.white(`   Size: ${formatSize(item.size)}`));
+      console.log(import_chalk5.default.white(`   Files: ${item.fileCount}`));
+      console.log(import_chalk5.default.white(`   Type: ${item.type === "directory" ? "Directory" : "File"}`));
+      if (item.timestamp) {
+        console.log(import_chalk5.default.white(`   Date: ${new Date(item.timestamp).toLocaleString()}`));
+      }
+      console.log(import_chalk5.default.cyan("-".repeat(80)));
+    }
+    const totalSize = history.reduce((sum, record) => sum + record.size, 0);
+    const totalFiles = history.reduce((sum, record) => sum + record.fileCount, 0);
+    console.log(import_chalk5.default.bold(`Total Uploads: ${history.length}`));
+    console.log(import_chalk5.default.bold(`Total Files: ${totalFiles}`));
+    console.log(import_chalk5.default.bold(`Total Size: ${formatSize(totalSize)}`));
+  } catch (error) {
+    void tracker_default.trackEvent(TRACK_EVENTS.uploadHistoryFailed, TRACK_PAGES.upload, {
+      a: resolveTrackAction2(TRACK_EVENTS.uploadHistoryFailed),
+      action: "view",
+      reason: getTrackErrorReason(error)
+    });
+    throw error;
   }
-  const totalSize = history.reduce((sum, record) => sum + record.size, 0);
-  const totalFiles = history.reduce((sum, record) => sum + record.fileCount, 0);
-  console.log(import_chalk5.default.bold(`Total Uploads: ${history.length}`));
-  console.log(import_chalk5.default.bold(`Total Files: ${totalFiles}`));
-  console.log(import_chalk5.default.bold(`Total Size: ${formatSize(totalSize)}`));
 };
 var clearUploadHistory = () => {
   try {
     ensureHistoryDir();
     import_fs_extra3.default.writeJsonSync(HISTORY_FILE, { uploads: [] });
+    void tracker_default.trackEvent(TRACK_EVENTS.uploadHistoryCleared, TRACK_PAGES.upload, {
+      a: resolveTrackAction2(TRACK_EVENTS.uploadHistoryCleared),
+      cleared: true
+    });
     console.log(import_chalk5.default.green("Upload history cleared successfully."));
     return true;
   } catch (error) {
+    void tracker_default.trackEvent(TRACK_EVENTS.uploadHistoryFailed, TRACK_PAGES.upload, {
+      a: resolveTrackAction2(TRACK_EVENTS.uploadHistoryFailed),
+      action: "clear",
+      reason: getTrackErrorReason(error)
+    });
     console.error(import_chalk5.default.red(`Error clearing upload history: ${error.message}`));
     return false;
   }
@@ -6221,6 +6558,7 @@ var RETRY_DELAY = APP_CONFIG.upload.retryDelayMs;
 var TIMEOUT = APP_CONFIG.upload.timeoutMs;
 var MAX_POLL_TIME = APP_CONFIG.upload.maxPollTimeMs;
 var POLL_INTERVAL = APP_CONFIG.upload.pollIntervalMs;
+var COMPLETE_TO_STATUS_DELAY = 5e3;
 var PROGRESS_UPDATE_INTERVAL = 200;
 var EXPECTED_UPLOAD_TIME = 6e4;
 var MAX_PROGRESS = 0.9;
@@ -6262,11 +6600,14 @@ function createUploadBusinessError(stage, endpoint, method, status, data) {
     [`Endpoint: ${endpoint}`]
   );
 }
-function logAxiosErrorDetails(prefix, error) {
+function logAxiosErrorDetails(prefix, error, traceId) {
   var _a2, _b;
   const status = (_a2 = error == null ? void 0 : error.response) == null ? void 0 : _a2.status;
   const responseData = (_b = error == null ? void 0 : error.response) == null ? void 0 : _b.data;
   console.error(`[pinme upload] ${prefix}`);
+  if (traceId) {
+    console.error(`[pinme upload] trace_id: ${traceId}`);
+  }
   console.error(`[pinme upload] status: ${status ?? "unknown"}`);
   if (responseData === void 0) {
     console.error("[pinme upload] response: <empty>");
@@ -6278,6 +6619,16 @@ function logAxiosErrorDetails(prefix, error) {
     console.error(`[pinme upload] response: ${String(responseData)}`);
   }
 }
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function appendTraceIdToError(error, traceId) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (message.includes(`trace_id: ${traceId}`)) {
+    return error instanceof Error ? error : new Error(message);
+  }
+  return new Error(`${message} (trace_id: ${traceId})`);
+}
 function isStorageLimitError(error) {
   const message = extractAxiosErrorMessage(error).toLowerCase();
   return message.includes("storage space limit") || message.includes("space limit reached") || message.includes("storage limit reached") || message.includes("quota exceeded") || message.includes("insufficient storage");
@@ -6396,9 +6747,9 @@ async function compressDirectory(sourcePath) {
     if (!import_fs_extra4.default.existsSync(tempDir)) {
       import_fs_extra4.default.mkdirSync(tempDir, { recursive: true });
     }
-    const outputPath = import_path5.default.join(
+    const outputPath = import_path6.default.join(
       tempDir,
-      `pinme_${import_path5.default.basename(sourcePath)}_${Date.now()}.zip`
+      `pinme_${import_path6.default.basename(sourcePath)}_${Date.now()}.zip`
     );
     const output = import_fs_extra4.default.createWriteStream(outputPath);
     const zlib2 = require("zlib");
@@ -6423,7 +6774,7 @@ async function compressDirectory(sourcePath) {
 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 fileName = import_path6.default.basename(filePath);
   const fileSize = stats.size;
   const md5 = await calculateMD5(filePath);
   try {
@@ -6533,7 +6884,7 @@ async function uploadChunkWithAbort(sessionId, chunkIndex, chunkData, deviceId,
     );
   }
 }
-async function delayWithAbortCheck(delay, signal) {
+async function delayWithAbortCheck(delay2, signal) {
   return new Promise((resolve, reject) => {
     const timeoutId = setTimeout(() => {
       if (signal.aborted) {
@@ -6541,7 +6892,7 @@ async function delayWithAbortCheck(delay, signal) {
       } else {
         resolve();
       }
-    }, delay);
+    }, delay2);
     if (signal.aborted) {
       clearTimeout(timeoutId);
       reject(new Error("Request cancelled"));
@@ -6685,19 +7036,29 @@ async function getChunkStatus(sessionId, deviceId, options = {}) {
     );
   } catch (error) {
     if (axios_default.isAxiosError(error)) {
-      logAxiosErrorDetails("up_status failed", error);
-      throw formatAxiosError("Upload status check failed", error);
+      logAxiosErrorDetails("up_status failed", error, sessionId);
+      throw formatAxiosError(
+        `Upload status check failed (trace_id: ${sessionId})`,
+        error
+      );
     }
-    throw error;
+    console.error("[pinme upload] up_status failed");
+    console.error(`[pinme upload] trace_id: ${sessionId}`);
+    console.error(
+      `[pinme upload] reason: ${error instanceof Error ? error.message : String(error)}`
+    );
+    throw appendTraceIdToError(error, sessionId);
   }
 }
 async function monitorChunkProgress(traceId, deviceId, options = {}, progressBar) {
   let consecutiveErrors = 0;
-  const startTime = Date.now();
+  let startTime = Date.now();
   if (progressBar) {
     progressBar.startSimulatingProgress();
   }
   try {
+    await delay(COMPLETE_TO_STATUS_DELAY);
+    startTime = Date.now();
     while (Date.now() - startTime < MAX_POLL_TIME) {
       try {
         const status = await getChunkStatus(traceId, deviceId, options);
@@ -6725,7 +7086,9 @@ async function monitorChunkProgress(traceId, deviceId, options = {}, progressBar
       await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL));
     }
     const maxPollTimeMinutes = Math.floor(MAX_POLL_TIME / (60 * 1e3));
-    throw new Error(`Polling timeout after ${maxPollTimeMinutes} minutes`);
+    throw new Error(
+      `Polling timeout after ${maxPollTimeMinutes} minutes (trace_id: ${traceId})`
+    );
   } finally {
     if (progressBar) {
       progressBar.stopSimulatingProgress();
@@ -6741,7 +7104,7 @@ async function uploadDirectoryInChunks(directoryPath, deviceId, options = {}) {
       )} (size: ${formatSize(sizeCheck.size)})`
     );
   }
-  const progressBar = new StepProgressBar(import_path5.default.basename(directoryPath), true);
+  const progressBar = new StepProgressBar(import_path6.default.basename(directoryPath), true);
   try {
     progressBar.startStep(0, "Preparing compression");
     const compressedPath = await compressDirectory(directoryPath);
@@ -6785,7 +7148,7 @@ async function uploadDirectoryInChunks(directoryPath, deviceId, options = {}) {
     }
     const uploadData = {
       path: directoryPath,
-      filename: import_path5.default.basename(directoryPath),
+      filename: import_path6.default.basename(directoryPath),
       contentHash: (result == null ? void 0 : result.hash) || "unknown",
       size: sizeCheck.size,
       fileCount: 0,
@@ -6814,7 +7177,7 @@ async function uploadFileInChunks(filePath, deviceId, options = {}) {
       )} (size: ${formatSize(sizeCheck.size)})`
     );
   }
-  const fileName = import_path5.default.basename(filePath);
+  const fileName = import_path6.default.basename(filePath);
   const progressBar = new StepProgressBar(fileName, false);
   try {
     progressBar.startStep(0, "Initializing session");
@@ -7008,8 +7371,8 @@ function printHighlightedUrl(label, url2, tone = "primary") {
 checkNodeVersion();
 function checkPathSync(inputPath) {
   try {
-    const absolutePath = import_path6.default.resolve(inputPath);
-    if (import_fs2.default.existsSync(absolutePath)) {
+    const absolutePath = import_path7.default.resolve(inputPath);
+    if (import_fs3.default.existsSync(absolutePath)) {
       return absolutePath;
     }
     return null;
@@ -7070,6 +7433,7 @@ async function checkWalletBalanceStatus(authConfig) {
 }
 async function bindDomain(domain, contentHash, isDns, authConfig) {
   const displayDomain = normalizeDomain(domain);
+  const domainType = isDns ? "dns" : "pinme_subdomain";
   if (isDns) {
     console.log(import_chalk7.default.blue("Binding DNS domain..."));
     const dnsResult = await bindDnsDomainV4(
@@ -7079,9 +7443,22 @@ async function bindDomain(domain, contentHash, isDns, authConfig) {
       authConfig.token
     );
     if (dnsResult.code !== 200) {
+      void tracker_default.trackEvent(TRACK_EVENTS.domainBindFailed, TRACK_PAGES.domain, {
+        a: resolveTrackAction2(TRACK_EVENTS.domainBindFailed),
+        domain_type: domainType,
+        domain_name: displayDomain,
+        bind_source: "upload",
+        reason: dnsResult.msg || "dns_bind_failed"
+      });
       console.log(import_chalk7.default.red(`DNS binding failed: ${dnsResult.msg}`));
       return false;
     }
+    void tracker_default.trackEvent(TRACK_EVENTS.domainBindSuccess, TRACK_PAGES.domain, {
+      a: resolveTrackAction2(TRACK_EVENTS.domainBindSuccess),
+      domain_type: domainType,
+      domain_name: displayDomain,
+      bind_source: "upload"
+    });
     console.log(import_chalk7.default.green(`DNS bind success: ${displayDomain}`));
     console.log(import_chalk7.default.white(`Visit: https://${displayDomain}`));
     console.log(
@@ -7093,9 +7470,22 @@ async function bindDomain(domain, contentHash, isDns, authConfig) {
     console.log(import_chalk7.default.blue("Binding Pinme subdomain..."));
     const ok = await bindPinmeDomain(displayDomain, contentHash);
     if (!ok) {
+      void tracker_default.trackEvent(TRACK_EVENTS.domainBindFailed, TRACK_PAGES.domain, {
+        a: resolveTrackAction2(TRACK_EVENTS.domainBindFailed),
+        domain_type: domainType,
+        domain_name: displayDomain,
+        bind_source: "upload",
+        reason: "pinme_bind_failed"
+      });
       console.log(import_chalk7.default.red("Binding failed. Please try again later."));
       return false;
     }
+    void tracker_default.trackEvent(TRACK_EVENTS.domainBindSuccess, TRACK_PAGES.domain, {
+      a: resolveTrackAction2(TRACK_EVENTS.domainBindSuccess),
+      domain_type: domainType,
+      domain_name: displayDomain,
+      bind_source: "upload"
+    });
     console.log(import_chalk7.default.green(`Bind success: ${displayDomain}`));
     const rootDomain = await (await Promise.resolve().then(() => (init_pinmeApi(), pinmeApi_exports))).getRootDomain();
     console.log(import_chalk7.default.white(`Visit: https://${displayDomain}.${rootDomain}`));
@@ -7127,6 +7517,7 @@ var upload_default = async (options) => {
         console.log(import_chalk7.default.red(`path ${argPath} does not exist`));
         return;
       }
+      const pathKind = getPathKind(absolutePath);
       const isDns = dnsArg || (domainArg ? isDnsDomain(domainArg) : false);
       const displayDomain = domainArg == null ? void 0 : domainArg.replace(/^https?:\/\//, "").replace(/\/$/, "");
       if (isDns && domainArg) {
@@ -7182,13 +7573,31 @@ var upload_default = async (options) => {
           uid: authConfig == null ? void 0 : authConfig.address
         });
       } catch (error) {
+        void tracker_default.trackEvent(TRACK_EVENTS.uploadFailed, TRACK_PAGES.upload, {
+          a: resolveTrackAction2(TRACK_EVENTS.uploadFailed),
+          path_kind: pathKind,
+          has_domain: Boolean(domainArg),
+          reason: getTrackErrorReason(error)
+        });
         printCliError(error, "Upload failed.");
         process.exit(1);
       }
       if (!result) {
+        void tracker_default.trackEvent(TRACK_EVENTS.uploadFailed, TRACK_PAGES.upload, {
+          a: resolveTrackAction2(TRACK_EVENTS.uploadFailed),
+          path_kind: pathKind,
+          has_domain: Boolean(domainArg),
+          reason: "no_result_returned"
+        });
         console.error(import_chalk7.default.red("Upload failed: no result returned"));
         process.exit(1);
       }
+      void tracker_default.trackEvent(TRACK_EVENTS.uploadSuccess, TRACK_PAGES.upload, {
+        a: resolveTrackAction2(TRACK_EVENTS.uploadSuccess),
+        path_kind: pathKind,
+        has_domain: Boolean(domainArg),
+        project_name: APP_CONFIG.pinmeProjectName
+      });
       console.log(
         import_chalk7.default.cyan(import_figlet.default.textSync("Successful", { horizontalLayout: "full" }))
       );
@@ -7224,6 +7633,7 @@ var upload_default = async (options) => {
         console.log(import_chalk7.default.red(`path ${answer.path} does not exist`));
         return;
       }
+      const pathKind = getPathKind(absolutePath);
       const isDns = dnsArg || (domainArg ? isDnsDomain(domainArg) : false);
       const displayDomain = domainArg == null ? void 0 : domainArg.replace(/^https?:\/\//, "").replace(/\/$/, "");
       if (isDns && domainArg) {
@@ -7279,13 +7689,31 @@ var upload_default = async (options) => {
           uid: authConfig == null ? void 0 : authConfig.address
         });
       } catch (error) {
+        void tracker_default.trackEvent(TRACK_EVENTS.uploadFailed, TRACK_PAGES.upload, {
+          a: resolveTrackAction2(TRACK_EVENTS.uploadFailed),
+          path_kind: pathKind,
+          has_domain: Boolean(domainArg),
+          reason: getTrackErrorReason(error)
+        });
         printCliError(error, "Upload failed.");
         process.exit(1);
       }
       if (!result) {
+        void tracker_default.trackEvent(TRACK_EVENTS.uploadFailed, TRACK_PAGES.upload, {
+          a: resolveTrackAction2(TRACK_EVENTS.uploadFailed),
+          path_kind: pathKind,
+          has_domain: Boolean(domainArg),
+          reason: "no_result_returned"
+        });
         console.error(import_chalk7.default.red("Upload failed: no result returned"));
         process.exit(1);
       }
+      void tracker_default.trackEvent(TRACK_EVENTS.uploadSuccess, TRACK_PAGES.upload, {
+        a: resolveTrackAction2(TRACK_EVENTS.uploadSuccess),
+        path_kind: pathKind,
+        has_domain: Boolean(domainArg),
+        project_name: APP_CONFIG.pinmeProjectName
+      });
       console.log(
         import_chalk7.default.cyan(import_figlet.default.textSync("Successful", { horizontalLayout: "full" }))
       );
@@ -7314,11 +7742,11 @@ var upload_default = async (options) => {
 };
 
 // bin/importCar.ts
-var import_path7 = __toESM(require("path"));
+var import_path8 = __toESM(require("path"));
 var import_chalk8 = __toESM(require("chalk"));
 var import_inquirer2 = __toESM(require("inquirer"));
 var import_figlet2 = __toESM(require("figlet"));
-var import_fs3 = __toESM(require("fs"));
+var import_fs4 = __toESM(require("fs"));
 var import_crypto_js2 = __toESM(require("crypto-js"));
 init_pinmeApi();
 init_cliError();
@@ -7341,8 +7769,8 @@ function encryptHash2(contentHash, key, uid) {
 }
 function checkPathSync2(inputPath) {
   try {
-    const absolutePath = import_path7.default.resolve(inputPath);
-    if (import_fs3.default.existsSync(absolutePath)) {
+    const absolutePath = import_path8.default.resolve(inputPath);
+    if (import_fs4.default.existsSync(absolutePath)) {
       return absolutePath;
     }
     return null;
@@ -7390,6 +7818,7 @@ var importCar_default = async (options) => {
         console.log(import_chalk8.default.red(`path ${argPath} does not exist`));
         return;
       }
+      const pathKind = getPathKind(absolutePath);
       if (domainArg) {
         const check = await checkDomainAvailable(domainArg);
         if (!check.is_valid) {
@@ -7409,6 +7838,11 @@ var importCar_default = async (options) => {
           uid: getUid2()
         });
         if (result) {
+          void tracker_default.trackEvent(TRACK_EVENTS.importSuccess, TRACK_PAGES.import, {
+            a: resolveTrackAction2(TRACK_EVENTS.importSuccess),
+            path_kind: pathKind,
+            has_domain: Boolean(domainArg)
+          });
           const uid = getUid2();
           const encryptedCID = encryptHash2(
             result.contentHash,
@@ -7433,6 +7867,12 @@ var importCar_default = async (options) => {
             );
             const ok = await bindPinmeDomain(domainArg, result.contentHash);
             if (ok) {
+              void tracker_default.trackEvent(TRACK_EVENTS.domainBindSuccess, TRACK_PAGES.domain, {
+                a: resolveTrackAction2(TRACK_EVENTS.domainBindSuccess),
+                domain_type: "pinme_subdomain",
+                domain_name: domainArg,
+                bind_source: "import"
+              });
               console.log(import_chalk8.default.green(`Bind success: ${domainArg}`));
               const rootDomain = await getRootDomain();
               console.log(
@@ -7441,12 +7881,25 @@ var importCar_default = async (options) => {
                 )
               );
             } else {
+              void tracker_default.trackEvent(TRACK_EVENTS.domainBindFailed, TRACK_PAGES.domain, {
+                a: resolveTrackAction2(TRACK_EVENTS.domainBindFailed),
+                domain_type: "pinme_subdomain",
+                domain_name: domainArg,
+                bind_source: "import",
+                reason: "pinme_bind_failed"
+              });
               console.log(import_chalk8.default.red("Binding failed. Please try again later."));
             }
           }
           console.log(import_chalk8.default.green("\n\u{1F389} import successful, program exit"));
         }
       } catch (error) {
+        void tracker_default.trackEvent(TRACK_EVENTS.importFailed, TRACK_PAGES.import, {
+          a: resolveTrackAction2(TRACK_EVENTS.importFailed),
+          path_kind: pathKind,
+          has_domain: Boolean(domainArg),
+          reason: getTrackErrorReason(error)
+        });
         printCliError(error, "Import failed.");
       }
       process.exit(0);
@@ -7464,6 +7917,7 @@ var importCar_default = async (options) => {
         console.log(import_chalk8.default.red(`path ${answer.path} does not exist`));
         return;
       }
+      const pathKind = getPathKind(absolutePath);
       if (domainArg) {
         const check = await checkDomainAvailable(domainArg);
         if (!check.is_valid) {
@@ -7483,6 +7937,11 @@ var importCar_default = async (options) => {
           uid: getUid2()
         });
         if (result) {
+          void tracker_default.trackEvent(TRACK_EVENTS.importSuccess, TRACK_PAGES.import, {
+            a: resolveTrackAction2(TRACK_EVENTS.importSuccess),
+            path_kind: pathKind,
+            has_domain: Boolean(domainArg)
+          });
           const uid = getUid2();
           const encryptedCID = encryptHash2(
             result.contentHash,
@@ -7507,6 +7966,12 @@ var importCar_default = async (options) => {
             );
             const ok = await bindPinmeDomain(domainArg, result.contentHash);
             if (ok) {
+              void tracker_default.trackEvent(TRACK_EVENTS.domainBindSuccess, TRACK_PAGES.domain, {
+                a: resolveTrackAction2(TRACK_EVENTS.domainBindSuccess),
+                domain_type: "pinme_subdomain",
+                domain_name: domainArg,
+                bind_source: "import"
+              });
               console.log(import_chalk8.default.green(`Bind success: ${domainArg}`));
               const rootDomain = await getRootDomain();
               console.log(
@@ -7515,27 +7980,44 @@ var importCar_default = async (options) => {
                 )
               );
             } else {
+              void tracker_default.trackEvent(TRACK_EVENTS.domainBindFailed, TRACK_PAGES.domain, {
+                a: resolveTrackAction2(TRACK_EVENTS.domainBindFailed),
+                domain_type: "pinme_subdomain",
+                domain_name: domainArg,
+                bind_source: "import",
+                reason: "pinme_bind_failed"
+              });
               console.log(import_chalk8.default.red("Binding failed. Please try again later."));
             }
           }
           console.log(import_chalk8.default.green("\n\u{1F389} import successful, program exit"));
         }
       } catch (error) {
+        void tracker_default.trackEvent(TRACK_EVENTS.importFailed, TRACK_PAGES.import, {
+          a: resolveTrackAction2(TRACK_EVENTS.importFailed),
+          path_kind: pathKind,
+          has_domain: Boolean(domainArg),
+          reason: getTrackErrorReason(error)
+        });
         printCliError(error, "Import failed.");
       }
       process.exit(0);
     }
   } catch (error) {
+    void tracker_default.trackEvent(TRACK_EVENTS.importFailed, TRACK_PAGES.import, {
+      a: resolveTrackAction2(TRACK_EVENTS.importFailed),
+      reason: getTrackErrorReason(error)
+    });
     printCliError(error, "Import failed.");
   }
 };
 
 // bin/exportCar.ts
-var import_path8 = __toESM(require("path"));
+var import_path9 = __toESM(require("path"));
 var import_chalk9 = __toESM(require("chalk"));
 var import_inquirer3 = __toESM(require("inquirer"));
 var import_figlet3 = __toESM(require("figlet"));
-var import_fs4 = __toESM(require("fs"));
+var import_fs5 = __toESM(require("fs"));
 init_axios2();
 var import_ora2 = __toESM(require("ora"));
 init_cliError();
@@ -7578,7 +8060,7 @@ async function downloadCarFile(downloadUrl, outputPath) {
       timeout: 18e5
       // 30 minutes timeout
     });
-    const writer = import_fs4.default.createWriteStream(outputPath);
+    const writer = import_fs5.default.createWriteStream(outputPath);
     let downloadedBytes = 0;
     const totalBytes = parseInt(response.headers["content-length"] || "0", 10);
     response.data.on("data", (chunk) => {
@@ -7674,15 +8156,15 @@ var exportCar_default = async () => {
       ]);
       outputDir = answer.output.trim() || currentDir;
     }
-    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()) {
+    outputDir = import_path9.default.resolve(outputDir);
+    if (!import_fs5.default.existsSync(outputDir)) {
+      import_fs5.default.mkdirSync(outputDir, { recursive: true });
+    } else if (!import_fs5.default.statSync(outputDir).isDirectory()) {
       console.log(import_chalk9.default.red(`Error: ${outputDir} exists but is not a directory.`));
       return;
     }
-    const finalOutputPath = import_path8.default.join(outputDir, `${cid}.car`);
-    if (import_fs4.default.existsSync(finalOutputPath)) {
+    const finalOutputPath = import_path9.default.join(outputDir, `${cid}.car`);
+    if (import_fs5.default.existsSync(finalOutputPath)) {
       const answer = await import_inquirer3.default.prompt([
         {
           type: "confirm",
@@ -7710,12 +8192,22 @@ var exportCar_default = async () => {
         startTime
       );
       if (!downloadUrl) {
+        void tracker_default.trackEvent(TRACK_EVENTS.exportFailed, TRACK_PAGES.export, {
+          a: resolveTrackAction2(TRACK_EVENTS.exportFailed),
+          cid,
+          reason: "export_failed_or_timed_out"
+        });
         console.log(import_chalk9.default.red("Export failed or timed out."));
         return;
       }
       const success = await downloadCarFile(downloadUrl, finalOutputPath);
       if (success) {
-        const fileSize = import_fs4.default.statSync(finalOutputPath).size;
+        void tracker_default.trackEvent(TRACK_EVENTS.exportSuccess, TRACK_PAGES.export, {
+          a: resolveTrackAction2(TRACK_EVENTS.exportSuccess),
+          cid,
+          output_dir: outputDir
+        });
+        const fileSize = import_fs5.default.statSync(finalOutputPath).size;
         const fileSizeMB = (fileSize / (1024 * 1024)).toFixed(2);
         console.log(
           import_chalk9.default.cyan(
@@ -7728,13 +8220,27 @@ var exportCar_default = async () => {
         console.log(import_chalk9.default.cyan(`Size: ${fileSizeMB} MB`));
         console.log(import_chalk9.default.cyan(`CID: ${cid}`));
       } else {
+        void tracker_default.trackEvent(TRACK_EVENTS.exportFailed, TRACK_PAGES.export, {
+          a: resolveTrackAction2(TRACK_EVENTS.exportFailed),
+          cid,
+          reason: "download_failed"
+        });
         console.log(import_chalk9.default.red("Download failed."));
       }
     } catch (error) {
+      void tracker_default.trackEvent(TRACK_EVENTS.exportFailed, TRACK_PAGES.export, {
+        a: resolveTrackAction2(TRACK_EVENTS.exportFailed),
+        cid,
+        reason: getTrackErrorReason(error)
+      });
       spinner.fail(`Error: ${error.message}`);
       printCliError(error, "Export failed.");
     }
   } catch (error) {
+    void tracker_default.trackEvent(TRACK_EVENTS.exportFailed, TRACK_PAGES.export, {
+      a: resolveTrackAction2(TRACK_EVENTS.exportFailed),
+      reason: getTrackErrorReason(error)
+    });
     printCliError(error, "Export failed.");
   }
 };
@@ -7882,6 +8388,10 @@ var remove_default = async (options) => {
       try {
         const success = await removeFromIpfs(parsedInput.value, parsedInput.type);
         if (success) {
+          void tracker_default.trackEvent(TRACK_EVENTS.removeSuccess, TRACK_PAGES.remove, {
+            a: resolveTrackAction2(TRACK_EVENTS.removeSuccess),
+            input_type: parsedInput.type
+          });
           console.log(
             import_chalk11.default.cyan(
               import_figlet4.default.textSync("Successful", { horizontalLayout: "full" })
@@ -7889,6 +8399,11 @@ var remove_default = async (options) => {
           );
         }
       } catch (error) {
+        void tracker_default.trackEvent(TRACK_EVENTS.removeFailed, TRACK_PAGES.remove, {
+          a: resolveTrackAction2(TRACK_EVENTS.removeFailed),
+          input_type: parsedInput.type,
+          reason: getTrackErrorReason(error)
+        });
         console.error(import_chalk11.default.red(`Error: ${error.message}`));
       }
       return;
@@ -7946,6 +8461,10 @@ var remove_default = async (options) => {
       try {
         const success = await removeFromIpfs(parsedInput.value, parsedInput.type);
         if (success) {
+          void tracker_default.trackEvent(TRACK_EVENTS.removeSuccess, TRACK_PAGES.remove, {
+            a: resolveTrackAction2(TRACK_EVENTS.removeSuccess),
+            input_type: parsedInput.type
+          });
           console.log(
             import_chalk11.default.cyan(
               import_figlet4.default.textSync("Successful", { horizontalLayout: "full" })
@@ -7953,10 +8472,19 @@ var remove_default = async (options) => {
           );
         }
       } catch (error) {
+        void tracker_default.trackEvent(TRACK_EVENTS.removeFailed, TRACK_PAGES.remove, {
+          a: resolveTrackAction2(TRACK_EVENTS.removeFailed),
+          input_type: parsedInput.type,
+          reason: getTrackErrorReason(error)
+        });
         console.error(import_chalk11.default.red(`Error: ${error.message}`));
       }
     }
   } catch (error) {
+    void tracker_default.trackEvent(TRACK_EVENTS.removeFailed, TRACK_PAGES.remove, {
+      a: resolveTrackAction2(TRACK_EVENTS.removeFailed),
+      reason: getTrackErrorReason(error)
+    });
     console.error(import_chalk11.default.red(`Error executing remove command: ${error.message}`));
     console.error(error.stack);
   }
@@ -7994,7 +8522,16 @@ async function setAppKeyCmd() {
     } else {
       console.log(import_chalk12.default.yellow("Anonymous history merge not confirmed. You may retry later."));
     }
+    void tracker_default.trackEvent(TRACK_EVENTS.appKeySetSuccess, TRACK_PAGES.auth, {
+      a: resolveTrackAction2(TRACK_EVENTS.appKeySetSuccess),
+      merged_anonymous_history: ok,
+      has_token_address: Boolean(saved.address)
+    });
   } catch (e) {
+    void tracker_default.trackEvent(TRACK_EVENTS.appKeySetFailed, TRACK_PAGES.auth, {
+      a: resolveTrackAction2(TRACK_EVENTS.appKeySetFailed),
+      reason: getTrackErrorReason(e)
+    });
     console.log(import_chalk12.default.red(`Failed to set AppKey: ${(e == null ? void 0 : e.message) || e}`));
   }
 }
@@ -8023,9 +8560,17 @@ async function logoutCmd() {
       return;
     }
     clearAuthToken();
+    void tracker_default.trackEvent(TRACK_EVENTS.logoutSuccess, TRACK_PAGES.auth, {
+      a: resolveTrackAction2(TRACK_EVENTS.logoutSuccess),
+      had_session: true
+    });
     console.log(import_chalk13.default.green("Successfully logged out."));
     console.log(import_chalk13.default.gray(`Address ${auth.address} has been removed from local storage.`));
   } catch (e) {
+    void tracker_default.trackEvent(TRACK_EVENTS.logoutFailed, TRACK_PAGES.auth, {
+      a: resolveTrackAction2(TRACK_EVENTS.logoutFailed),
+      reason: getTrackErrorReason(e)
+    });
     console.log(import_chalk13.default.red(`Failed to logout: ${(e == null ? void 0 : e.message) || e}`));
   }
 }
@@ -8037,6 +8582,10 @@ function showAppKeyCmd() {
   try {
     const auth = getAuthConfig();
     if (!auth) {
+      void tracker_default.trackEvent(TRACK_EVENTS.appKeyShownFailed, TRACK_PAGES.auth, {
+        a: resolveTrackAction2(TRACK_EVENTS.appKeyShownFailed),
+        reason: "no_appkey_found"
+      });
       console.log(import_chalk14.default.yellow("No AppKey found. Please set your AppKey first."));
       console.log(import_chalk14.default.gray("Run: pinme set-appkey <AppKey>"));
       return;
@@ -8057,7 +8606,15 @@ function showAppKeyCmd() {
     } else {
       console.log(import_chalk14.default.cyan(`  AppKey: ${"*".repeat(combined.length)}`));
     }
+    void tracker_default.trackEvent(TRACK_EVENTS.appKeyShownSuccess, TRACK_PAGES.auth, {
+      a: resolveTrackAction2(TRACK_EVENTS.appKeyShownSuccess),
+      has_token_address: Boolean(auth.address)
+    });
   } catch (e) {
+    void tracker_default.trackEvent(TRACK_EVENTS.appKeyShownFailed, TRACK_PAGES.auth, {
+      a: resolveTrackAction2(TRACK_EVENTS.appKeyShownFailed),
+      reason: getTrackErrorReason(e)
+    });
     console.log(import_chalk14.default.red(`Failed to show AppKey: ${(e == null ? void 0 : e.message) || e}`));
   }
 }
@@ -8070,6 +8627,10 @@ init_pinmeApi();
 async function myDomainsCmd() {
   try {
     const list = await getMyDomains();
+    void tracker_default.trackEvent(TRACK_EVENTS.myDomainsSuccess, TRACK_PAGES.domain, {
+      a: resolveTrackAction2(TRACK_EVENTS.myDomainsSuccess),
+      domain_count: list.length
+    });
     if (!list.length) {
       console.log(import_chalk15.default.yellow("No bound domains found."));
       return;
@@ -8089,6 +8650,10 @@ async function myDomainsCmd() {
       console.log(import_chalk15.default.cyan("-".repeat(80)));
     });
   } catch (e) {
+    void tracker_default.trackEvent(TRACK_EVENTS.myDomainsFailed, TRACK_PAGES.domain, {
+      a: resolveTrackAction2(TRACK_EVENTS.myDomainsFailed),
+      reason: getTrackErrorReason(e)
+    });
     printCliError(e, "Failed to fetch domains.");
   }
 }
@@ -8110,9 +8675,18 @@ async function walletBalanceCmd() {
     const result = await getWalletBalance(auth.address, auth.token);
     const balance = Number(((_a2 = result.data) == null ? void 0 : _a2.wallet_balance_usd) ?? 0);
     if (!Number.isFinite(balance)) {
+      void tracker_default.trackEvent(TRACK_EVENTS.walletBalanceFailed, TRACK_PAGES.wallet, {
+        a: resolveTrackAction2(TRACK_EVENTS.walletBalanceFailed),
+        reason: "invalid_balance_value"
+      });
       console.log(import_chalk16.default.red("Failed to parse wallet balance."));
       return;
     }
+    void tracker_default.trackEvent(TRACK_EVENTS.walletBalanceSuccess, TRACK_PAGES.wallet, {
+      a: resolveTrackAction2(TRACK_EVENTS.walletBalanceSuccess),
+      has_balance: balance > 0,
+      balance_usd: balance.toFixed(2)
+    });
     console.log(import_chalk16.default.cyan("Wallet balance:"));
     console.log(import_chalk16.default.green(`  USD: $${balance.toFixed(2)}`));
     if (balance <= 0) {
@@ -8120,12 +8694,16 @@ async function walletBalanceCmd() {
       printRechargeUrl(getWalletRechargeUrl());
     }
   } catch (e) {
+    void tracker_default.trackEvent(TRACK_EVENTS.walletBalanceFailed, TRACK_PAGES.wallet, {
+      a: resolveTrackAction2(TRACK_EVENTS.walletBalanceFailed),
+      reason: getTrackErrorReason(e)
+    });
     printCliError(e, "Failed to fetch wallet balance.");
   }
 }
 
 // bin/bind.ts
-var import_path9 = __toESM(require("path"));
+var import_path10 = __toESM(require("path"));
 var import_chalk17 = __toESM(require("chalk"));
 var import_inquirer7 = __toESM(require("inquirer"));
 init_pinmeApi();
@@ -8214,6 +8792,8 @@ async function bindCmd() {
     }
     const isDns = dns || isDnsDomain(domain);
     const displayDomain = normalizeDomain(domain);
+    const pathKind = getPathKind(import_path10.default.resolve(targetPath));
+    const domainType = isDns ? "dns" : "pinme_subdomain";
     if (isDns) {
       const validation = validateDnsDomain(domain);
       if (!validation.valid) {
@@ -8253,13 +8833,24 @@ async function bindCmd() {
       }
       throw e;
     }
-    const absolutePath = import_path9.default.resolve(targetPath);
+    const absolutePath = import_path10.default.resolve(targetPath);
     console.log(import_chalk17.default.blue(`Uploading: ${absolutePath}`));
     const up = await uploadPath(absolutePath, { uid: authConfig.address });
     if (!(up == null ? void 0 : up.contentHash)) {
+      void tracker_default.trackEvent(TRACK_EVENTS.uploadFailed, TRACK_PAGES.upload, {
+        a: resolveTrackAction2(TRACK_EVENTS.uploadFailed),
+        path_kind: pathKind,
+        has_domain: true,
+        reason: "no_content_hash"
+      });
       console.log(import_chalk17.default.red("Upload failed, binding aborted."));
       return;
     }
+    void tracker_default.trackEvent(TRACK_EVENTS.uploadSuccess, TRACK_PAGES.upload, {
+      a: resolveTrackAction2(TRACK_EVENTS.uploadSuccess),
+      path_kind: pathKind,
+      has_domain: true
+    });
     console.log(import_chalk17.default.green(`Upload success, CID: ${up.contentHash}`));
     try {
       if (isDns) {
@@ -8271,9 +8862,22 @@ async function bindCmd() {
           authConfig.token
         );
         if (dnsResult.code !== 200) {
+          void tracker_default.trackEvent(TRACK_EVENTS.domainBindFailed, TRACK_PAGES.domain, {
+            a: resolveTrackAction2(TRACK_EVENTS.domainBindFailed),
+            domain_type: domainType,
+            domain_name: displayDomain,
+            bind_source: "bind",
+            reason: dnsResult.msg || "dns_bind_failed"
+          });
           console.log(import_chalk17.default.red(`DNS binding failed: ${dnsResult.msg}`));
           return;
         }
+        void tracker_default.trackEvent(TRACK_EVENTS.domainBindSuccess, TRACK_PAGES.domain, {
+          a: resolveTrackAction2(TRACK_EVENTS.domainBindSuccess),
+          domain_type: domainType,
+          domain_name: displayDomain,
+          bind_source: "bind"
+        });
         console.log(import_chalk17.default.green(`DNS bind success: ${displayDomain}`));
         console.log(import_chalk17.default.white(`Visit: https://${displayDomain}`));
         console.log(
@@ -8285,9 +8889,22 @@ async function bindCmd() {
         console.log(import_chalk17.default.blue("Binding Pinme subdomain..."));
         const ok = await bindPinmeDomain(displayDomain, up.contentHash);
         if (!ok) {
+          void tracker_default.trackEvent(TRACK_EVENTS.domainBindFailed, TRACK_PAGES.domain, {
+            a: resolveTrackAction2(TRACK_EVENTS.domainBindFailed),
+            domain_type: domainType,
+            domain_name: displayDomain,
+            bind_source: "bind",
+            reason: "pinme_bind_failed"
+          });
           console.log(import_chalk17.default.red("Binding failed. Please try again later."));
           return;
         }
+        void tracker_default.trackEvent(TRACK_EVENTS.domainBindSuccess, TRACK_PAGES.domain, {
+          a: resolveTrackAction2(TRACK_EVENTS.domainBindSuccess),
+          domain_type: domainType,
+          domain_name: displayDomain,
+          bind_source: "bind"
+        });
         console.log(import_chalk17.default.green(`Bind success: ${displayDomain}`));
         const rootDomain = await getRootDomain();
         console.log(
@@ -8301,6 +8918,11 @@ async function bindCmd() {
       throw e;
     }
   } catch (e) {
+    void tracker_default.trackEvent(TRACK_EVENTS.domainBindFailed, TRACK_PAGES.domain, {
+      a: resolveTrackAction2(TRACK_EVENTS.domainBindFailed),
+      bind_source: "bind",
+      reason: getTrackErrorReason(e)
+    });
     printCliError(e, "Bind failed.");
   }
 }
@@ -8315,9 +8937,9 @@ var ENV_URLS = {
   prod: "https://pinme.eth.limo"
 };
 async function loginCmd(options = {}) {
+  const env = (options.env || "prod").toLowerCase();
   try {
     let webBaseUrl;
-    const env = (options.env || "prod").toLowerCase();
     if (ENV_URLS[env]) {
       webBaseUrl = ENV_URLS[env];
       console.log(import_chalk18.default.blue(`Using ${env} environment: ${webBaseUrl}`));
@@ -8338,8 +8960,19 @@ async function loginCmd(options = {}) {
     if (ok) {
       console.log(import_chalk18.default.green("History merged to your account"));
     }
+    void tracker_default.trackEvent(TRACK_EVENTS.cliLoginSuccess, TRACK_PAGES.login, {
+      a: resolveTrackAction2(TRACK_EVENTS.cliLoginSuccess),
+      env,
+      has_token_address: true,
+      merged_anonymous_history: ok
+    });
     process.exit(0);
   } catch (e) {
+    void tracker_default.trackEvent(TRACK_EVENTS.cliLoginFailed, TRACK_PAGES.login, {
+      a: resolveTrackAction2(TRACK_EVENTS.cliLoginFailed),
+      env,
+      reason: getTrackErrorReason(e)
+    });
     console.log(import_chalk18.default.red(`
 Login failed: ${(e == null ? void 0 : e.message) || e}`));
     process.exit(1);
@@ -8349,23 +8982,23 @@ Login failed: ${(e == null ? void 0 : e.message) || e}`));
 // bin/create.ts
 var import_chalk20 = __toESM(require("chalk"));
 var import_fs_extra6 = __toESM(require("fs-extra"));
-var import_path11 = __toESM(require("path"));
+var import_path12 = __toESM(require("path"));
 var import_inquirer8 = __toESM(require("inquirer"));
 init_axios2();
-var import_child_process3 = require("child_process");
+var import_child_process4 = require("child_process");
 init_webLogin();
 
 // bin/utils/installProjectDependencies.ts
 var import_fs_extra5 = __toESM(require("fs-extra"));
-var import_os4 = __toESM(require("os"));
-var import_path10 = __toESM(require("path"));
+var import_os5 = __toESM(require("os"));
+var import_path11 = __toESM(require("path"));
 var import_chalk19 = __toESM(require("chalk"));
-var import_child_process2 = require("child_process");
+var import_child_process3 = require("child_process");
 function makeTempCacheDir() {
-  return import_fs_extra5.default.mkdtempSync(import_path10.default.join(import_os4.default.tmpdir(), "pinme-npm-cache-"));
+  return import_fs_extra5.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"], {
+  (0, import_child_process3.execFileSync)("npm", ["install", "--cache", cacheDir, "--no-audit", "--no-fund"], {
     cwd,
     stdio: "inherit",
     env: {
@@ -8434,7 +9067,7 @@ function resolveExtractedTemplateDir(extractDir) {
       `Template branch: ${TEMPLATE_BRANCH}`
     ]);
   }
-  return import_path11.default.join(extractDir, templateDir.name);
+  return import_path12.default.join(extractDir, templateDir.name);
 }
 function updateFrontendUrlInConfig(configPath, frontendUrl) {
   let config = import_fs_extra6.default.readFileSync(configPath, "utf-8");
@@ -8483,7 +9116,7 @@ async function createCmd(options) {
       ]);
       projectName = answers.projectName;
     }
-    const targetDir = import_path11.default.join(PROJECT_DIR, projectName);
+    const targetDir = import_path12.default.join(PROJECT_DIR, projectName);
     if (import_fs_extra6.default.existsSync(targetDir) && !options.force) {
       console.log(import_chalk20.default.yellow(`
 Directory "${projectName}" already exists.`));
@@ -8534,15 +9167,15 @@ Directory "${projectName}" already exists.`));
       ]);
     }
     console.log(import_chalk20.default.blue("\n2. Downloading template from repository..."));
-    const zipPath = import_path11.default.join(PROJECT_DIR, "template.zip");
-    const extractDir = import_path11.default.join(PROJECT_DIR, `.pinme-template-${Date.now()}`);
+    const zipPath = import_path12.default.join(PROJECT_DIR, "template.zip");
+    const extractDir = import_path12.default.join(PROJECT_DIR, `.pinme-template-${Date.now()}`);
     const templateZipUrl = getTemplateZipUrl(TEMPLATE_BRANCH);
     let downloadSuccess = false;
     console.log(import_chalk20.default.gray(`   Template branch: ${TEMPLATE_BRANCH}`));
     for (let attempt = 1; attempt <= 3 && !downloadSuccess; attempt++) {
       try {
         console.log(import_chalk20.default.gray(`   Download attempt ${attempt}/3...`));
-        (0, import_child_process3.execSync)(`curl -L --retry 3 --retry-delay 2 -o "${zipPath}" "${templateZipUrl}"`, {
+        (0, import_child_process4.execSync)(`curl -L --retry 3 --retry-delay 2 -o "${zipPath}" "${templateZipUrl}"`, {
           stdio: "inherit"
         });
         if (!import_fs_extra6.default.existsSync(zipPath) || import_fs_extra6.default.statSync(zipPath).size < 100) {
@@ -8561,15 +9194,15 @@ Directory "${projectName}" already exists.`));
     }
     try {
       import_fs_extra6.default.ensureDirSync(extractDir);
-      (0, import_child_process3.execSync)(`unzip -o "${zipPath}" -d "${extractDir}"`, {
+      (0, import_child_process4.execSync)(`unzip -o "${zipPath}" -d "${extractDir}"`, {
         stdio: "inherit"
       });
       const subDir = resolveExtractedTemplateDir(extractDir);
       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");
+      const nodeModulesPath = import_path12.default.join(targetDir, "node_modules");
+      const packageLockPath = import_path12.default.join(targetDir, "package-lock.json");
       if (import_fs_extra6.default.existsSync(nodeModulesPath)) {
         console.log(import_chalk20.default.gray("   Removing existing node_modules..."));
         import_fs_extra6.default.removeSync(nodeModulesPath);
@@ -8578,10 +9211,10 @@ Directory "${projectName}" already exists.`));
         console.log(import_chalk20.default.gray("   Removing existing package-lock.json..."));
         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");
+      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_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);
@@ -8593,7 +9226,7 @@ Directory "${projectName}" already exists.`));
       ]);
     }
     console.log(import_chalk20.default.blue("\n3. Updating configuration..."));
-    const configPath = import_path11.default.join(targetDir, "pinme.toml");
+    const configPath = import_path12.default.join(targetDir, "pinme.toml");
     const config = import_fs_extra6.default.readFileSync(configPath, "utf-8");
     let updatedConfig = config.replace(
       /project_name = ".*"/,
@@ -8602,16 +9235,16 @@ Directory "${projectName}" already exists.`));
     import_fs_extra6.default.writeFileSync(configPath, updatedConfig);
     console.log(import_chalk20.default.green(`   Updated pinme.toml`));
     console.log(import_chalk20.default.gray(`   metadata: ${workerData.metadata}`));
-    const backendDir = import_path11.default.join(targetDir, "backend");
+    const backendDir = import_path12.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_extra6.default.writeFileSync(
-        import_path11.default.join(backendDir, "metadata.json"),
+        import_path12.default.join(backendDir, "metadata.json"),
         metadataContent
       );
       console.log(import_chalk20.default.green(`   Saved metadata.json`));
     }
-    const wranglerPath = import_path11.default.join(backendDir, "wrangler.toml");
+    const wranglerPath = import_path12.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(
@@ -8621,18 +9254,18 @@ Directory "${projectName}" already exists.`));
       import_fs_extra6.default.writeFileSync(wranglerPath, wranglerContent);
       console.log(import_chalk20.default.green(`   Updated backend/wrangler.toml API_KEY`));
     }
-    const frontendConfigPath = import_path11.default.join(targetDir, "frontend", "src", "utils", "config.ts");
+    const frontendConfigPath = import_path12.default.join(targetDir, "frontend", "src", "utils", "config.ts");
     if (workerData.public_client_config) {
       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.ensureDirSync(import_path12.default.dirname(frontendConfigPath));
       import_fs_extra6.default.writeFileSync(
         frontendConfigPath,
         injectPublicClientConfigIntoFile(frontendConfigContent, workerData.public_client_config)
       );
       console.log(import_chalk20.default.green(`   Updated frontend/src/utils/config.ts public_client_config`));
     }
-    const envExamplePath = import_path11.default.join(targetDir, "frontend", ".env.example");
-    const envPath = import_path11.default.join(targetDir, "frontend", ".env");
+    const envExamplePath = import_path12.default.join(targetDir, "frontend", ".env.example");
+    const envPath = import_path12.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);
@@ -8707,7 +9340,7 @@ Directory "${projectName}" already exists.`));
     }
     console.log(import_chalk20.default.blue("\n5. Building backend worker..."));
     try {
-      (0, import_child_process3.execSync)("npm run build:worker", {
+      (0, import_child_process4.execSync)("npm run build:worker", {
         cwd: targetDir,
         stdio: "inherit"
       });
@@ -8717,8 +9350,8 @@ Directory "${projectName}" already exists.`));
         "Fix the build error shown above, then rerun `pinme create`."
       ]);
     }
-    const distWorkerDir = import_path11.default.join(targetDir, "dist-worker");
-    const workerJsPath = import_path11.default.join(distWorkerDir, "worker.js");
+    const distWorkerDir = import_path12.default.join(targetDir, "dist-worker");
+    const workerJsPath = import_path12.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."
@@ -8728,15 +9361,15 @@ Directory "${projectName}" already exists.`));
     const files = import_fs_extra6.default.readdirSync(distWorkerDir);
     for (const file of files) {
       if (file.endsWith(".js") && file !== "worker.js") {
-        modulePaths.push(import_path11.default.join(distWorkerDir, file));
+        modulePaths.push(import_path12.default.join(distWorkerDir, file));
       }
     }
-    const sqlDir = import_path11.default.join(targetDir, "db");
+    const sqlDir = import_path12.default.join(targetDir, "db");
     const sqlFiles = [];
     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_path11.default.join(sqlDir, filename));
+        sqlFiles.push(import_path12.default.join(sqlDir, filename));
         console.log(import_chalk20.default.gray(`   Including SQL: ${filename}`));
       }
     }
@@ -8756,14 +9389,14 @@ Directory "${projectName}" already exists.`));
         type: "application/javascript+module"
       }), "worker.js");
       for (const modulePath of modulePaths) {
-        const filename = import_path11.default.basename(modulePath);
+        const filename = import_path12.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_path11.default.basename(sqlFile);
+        const filename = import_path12.default.basename(sqlFile);
         const content = import_fs_extra6.default.readFileSync(sqlFile, "utf-8");
         formData.append("sql_file", new Blob2([content], {
           type: "application/sql"
@@ -8797,10 +9430,10 @@ Directory "${projectName}" already exists.`));
       ]);
     }
     console.log(import_chalk20.default.blue("\n7. Building frontend..."));
-    const frontendDir = import_path11.default.join(targetDir, "frontend");
+    const frontendDir = import_path12.default.join(targetDir, "frontend");
     if (import_fs_extra6.default.existsSync(frontendDir)) {
       try {
-        (0, import_child_process3.execSync)("npm run build:frontend", {
+        (0, import_child_process4.execSync)("npm run build:frontend", {
           cwd: targetDir,
           stdio: "inherit"
         });
@@ -8812,13 +9445,13 @@ Directory "${projectName}" already exists.`));
       }
       console.log(import_chalk20.default.blue("   Uploading to IPFS..."));
       try {
-        const uploadResult = await uploadPath(import_path11.default.join(frontendDir, "dist"), {
+        const uploadResult = await uploadPath(import_path12.default.join(frontendDir, "dist"), {
           projectName: workerData.project_name,
           uid: headers["token-address"]
         });
         printHighlightedUrl("Frontend URL", uploadResult.publicUrl, "primary");
         updateFrontendUrlInConfig(
-          import_path11.default.join(targetDir, "pinme.toml"),
+          import_path12.default.join(targetDir, "pinme.toml"),
           uploadResult.publicUrl
         );
         console.log(import_chalk20.default.green("   Updated pinme.toml with frontend URL"));
@@ -8840,8 +9473,29 @@ Project Details:`));
 Next steps:`));
     console.log(import_chalk20.default.gray(`   cd ${projectName}`));
     console.log(import_chalk20.default.gray(`   pinme save`));
+    void tracker_default.trackEvent(
+      TRACK_EVENTS.projectCreateSuccess,
+      TRACK_PAGES.project,
+      {
+        a: resolveTrackAction2(TRACK_EVENTS.projectCreateSuccess),
+        project_name: workerData.project_name,
+        template_branch: TEMPLATE_BRANCH,
+        force: Boolean(options.force)
+      }
+    );
     process.exit(0);
   } catch (error) {
+    void tracker_default.trackEvent(
+      TRACK_EVENTS.projectCreateFailed,
+      TRACK_PAGES.project,
+      {
+        a: resolveTrackAction2(TRACK_EVENTS.projectCreateFailed),
+        project_name: options.name,
+        template_branch: TEMPLATE_BRANCH,
+        force: Boolean(options.force),
+        reason: getTrackErrorReason(error)
+      }
+    );
     printCliError(error, "Project creation failed.");
     process.exit(1);
   }
@@ -8850,9 +9504,9 @@ Next steps:`));
 // bin/save.ts
 var import_chalk21 = __toESM(require("chalk"));
 var import_fs_extra7 = __toESM(require("fs-extra"));
-var import_path12 = __toESM(require("path"));
+var import_path13 = __toESM(require("path"));
 init_axios2();
-var import_child_process4 = require("child_process");
+var import_child_process5 = require("child_process");
 init_webLogin();
 init_pinmeApi();
 init_domainValidator();
@@ -8860,7 +9514,7 @@ init_cliError();
 init_config();
 var PROJECT_DIR2 = process.cwd();
 function loadConfig() {
-  const configPath = import_path12.default.join(PROJECT_DIR2, "pinme.toml");
+  const configPath = import_path13.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.",
@@ -8877,7 +9531,7 @@ function getProjectManagementUrl2(projectName) {
   return `${APP_CONFIG.projectPeviewUrl}${projectName}`;
 }
 function getMetadata() {
-  const metadataPath = import_path12.default.join(PROJECT_DIR2, "backend", "metadata.json");
+  const metadataPath = import_path13.default.join(PROJECT_DIR2, "backend", "metadata.json");
   if (!import_fs_extra7.default.existsSync(metadataPath)) {
     console.log(import_chalk21.default.yellow("   Warning: metadata.json not found, using empty metadata"));
     return {};
@@ -8887,7 +9541,7 @@ function getMetadata() {
 function buildWorker() {
   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_DIR2,
       stdio: "inherit"
     });
@@ -8943,13 +9597,13 @@ function installDependencies() {
   }
 }
 function getBuiltWorker() {
-  const distWorkerDir = import_path12.default.join(PROJECT_DIR2, "dist-worker");
+  const distWorkerDir = import_path13.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_path12.default.join(distWorkerDir, "worker.js");
+  const workerJsPath = import_path13.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."
@@ -8959,18 +9613,18 @@ function getBuiltWorker() {
   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));
+      modulePaths.push(import_path13.default.join(distWorkerDir, file));
     }
   }
   return { workerJsPath, modulePaths };
 }
 function getSqlFiles() {
-  const sqlDir = import_path12.default.join(PROJECT_DIR2, "db");
+  const sqlDir = import_path13.default.join(PROJECT_DIR2, "db");
   if (!import_fs_extra7.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));
+  return files.map((f) => import_path13.default.join(sqlDir, f));
 }
 async function saveWorker(workerJsPath, modulePaths, sqlFiles, metadata, projectName) {
   var _a2, _b;
@@ -8995,14 +9649,14 @@ async function saveWorker(workerJsPath, modulePaths, sqlFiles, metadata, project
       type: "application/javascript+module"
     }), "worker.js");
     for (const modulePath of modulePaths) {
-      const filename = import_path12.default.basename(modulePath);
+      const filename = import_path13.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 filename = import_path13.default.basename(sqlFile);
       const content = import_fs_extra7.default.readFileSync(sqlFile, "utf-8");
       formData.append("sql_file", new Blob2([content], {
         type: "application/sql"
@@ -9041,7 +9695,7 @@ async function saveWorker(workerJsPath, modulePaths, sqlFiles, metadata, project
 function buildFrontend() {
   console.log(import_chalk21.default.blue("Building frontend..."));
   try {
-    (0, import_child_process4.execSync)("npm run build:frontend", {
+    (0, import_child_process5.execSync)("npm run build:frontend", {
       cwd: PROJECT_DIR2,
       stdio: "inherit"
     });
@@ -9072,11 +9726,11 @@ async function deployFrontend(projectName) {
   console.log(import_chalk21.default.blue("Deploying frontend to IPFS..."));
   try {
     const headers = getAuthHeaders();
-    const uploadResult = await uploadPath(import_path12.default.join(PROJECT_DIR2, "frontend", "dist"), {
+    const uploadResult = await uploadPath(import_path13.default.join(PROJECT_DIR2, "frontend", "dist"), {
       projectName,
       uid: headers["token-address"]
     });
-    updateFrontendUrlInConfig2(import_path12.default.join(PROJECT_DIR2, "pinme.toml"), uploadResult.publicUrl);
+    updateFrontendUrlInConfig2(import_path13.default.join(PROJECT_DIR2, "pinme.toml"), uploadResult.publicUrl);
     return {
       contentHash: uploadResult.contentHash,
       publicUrl: uploadResult.publicUrl
@@ -9126,9 +9780,9 @@ 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");
+    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_extra7.default.existsSync(tokenFileSrc) && !import_fs_extra7.default.existsSync(tokenFileDst)) {
       import_fs_extra7.default.copySync(tokenFileSrc, tokenFileDst);
     }
@@ -9174,8 +9828,20 @@ async function saveCmd(options) {
       "management"
     );
     console.log(import_chalk21.default.green("\nDeployment complete."));
+    void tracker_default.trackEvent(TRACK_EVENTS.projectSaveSuccess, TRACK_PAGES.deploy, {
+      a: resolveTrackAction2(TRACK_EVENTS.projectSaveSuccess),
+      project_name: projectName,
+      has_domain: Boolean(options.domain),
+      domain_type: options.domain ? isDnsDomain(options.domain) ? "dns" : "pinme_subdomain" : void 0
+    });
     process.exit(0);
   } catch (error) {
+    void tracker_default.trackEvent(TRACK_EVENTS.projectSaveFailed, TRACK_PAGES.deploy, {
+      a: resolveTrackAction2(TRACK_EVENTS.projectSaveFailed),
+      project_name: options.projectName || options.name,
+      has_domain: Boolean(options.domain),
+      reason: getTrackErrorReason(error)
+    });
     printCliError(error, "Save failed.");
     process.exit(1);
   }
@@ -9184,14 +9850,14 @@ async function saveCmd(options) {
 // bin/updateDb.ts
 var import_chalk22 = __toESM(require("chalk"));
 var import_fs_extra8 = __toESM(require("fs-extra"));
-var import_path13 = __toESM(require("path"));
+var import_path14 = __toESM(require("path"));
 init_axios2();
 init_webLogin();
 init_cliError();
 init_config();
 var PROJECT_DIR3 = process.cwd();
 function loadConfig2() {
-  const configPath = import_path13.default.join(PROJECT_DIR3, "pinme.toml");
+  const configPath = import_path14.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."
@@ -9204,7 +9870,7 @@ function loadConfig2() {
   };
 }
 function getSqlFiles2() {
-  const sqlDir = import_path13.default.join(PROJECT_DIR3, "db");
+  const sqlDir = import_path14.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."
@@ -9216,7 +9882,7 @@ function getSqlFiles2() {
       "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_chalk22.default.blue("Importing SQL files to database..."));
@@ -9231,7 +9897,7 @@ async function updateDb(sqlFiles, projectName) {
     const formData = new FormData4();
     let totalSize = 0;
     for (const sqlFile of sqlFiles) {
-      const filename = import_path13.default.basename(sqlFile);
+      const filename = import_path14.default.basename(sqlFile);
       const content = import_fs_extra8.default.readFileSync(sqlFile);
       totalSize += content.length;
       if (totalSize > 10 * 1024 * 1024) {
@@ -9287,9 +9953,9 @@ 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");
+    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_extra8.default.existsSync(tokenFileSrc) && !import_fs_extra8.default.existsSync(tokenFileDst)) {
       import_fs_extra8.default.copySync(tokenFileSrc, tokenFileDst);
     }
@@ -9307,8 +9973,26 @@ async function updateDbCmd(options) {
     console.log(import_chalk22.default.gray(`Found ${sqlFiles.length} SQL file(s) in db`));
     await updateDb(sqlFiles, projectName);
     console.log(import_chalk22.default.green("\nDatabase update complete."));
+    void tracker_default.trackEvent(
+      TRACK_EVENTS.projectUpdateDbSuccess,
+      TRACK_PAGES.deploy,
+      {
+        a: resolveTrackAction2(TRACK_EVENTS.projectUpdateDbSuccess),
+        project_name: projectName,
+        sql_file_count: sqlFiles.length
+      }
+    );
     process.exit(0);
   } catch (error) {
+    void tracker_default.trackEvent(
+      TRACK_EVENTS.projectUpdateDbFailed,
+      TRACK_PAGES.deploy,
+      {
+        a: resolveTrackAction2(TRACK_EVENTS.projectUpdateDbFailed),
+        project_name: (options == null ? void 0 : options.projectName) || (options == null ? void 0 : options.name),
+        reason: getTrackErrorReason(error)
+      }
+    );
     printCliError(error, "Database update failed.");
     process.exit(1);
   }
@@ -9317,15 +10001,15 @@ async function updateDbCmd(options) {
 // bin/updateWorker.ts
 var import_chalk23 = __toESM(require("chalk"));
 var import_fs_extra9 = __toESM(require("fs-extra"));
-var import_path14 = __toESM(require("path"));
+var import_path15 = __toESM(require("path"));
 init_axios2();
-var import_child_process5 = require("child_process");
+var import_child_process6 = require("child_process");
 init_webLogin();
 init_cliError();
 init_config();
 var PROJECT_DIR4 = process.cwd();
 function loadConfig3() {
-  const configPath = import_path14.default.join(PROJECT_DIR4, "pinme.toml");
+  const configPath = import_path15.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."
@@ -9338,7 +10022,7 @@ function loadConfig3() {
   };
 }
 function getMetadata2() {
-  const metadataPath = import_path14.default.join(PROJECT_DIR4, "backend", "metadata.json");
+  const metadataPath = import_path15.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."
@@ -9349,7 +10033,7 @@ function getMetadata2() {
 function buildWorker2() {
   console.log(import_chalk23.default.blue("Building worker..."));
   try {
-    (0, import_child_process5.execSync)("npm run build:worker", {
+    (0, import_child_process6.execSync)("npm run build:worker", {
       cwd: PROJECT_DIR4,
       stdio: "inherit"
     });
@@ -9361,13 +10045,13 @@ function buildWorker2() {
   }
 }
 function getBuiltWorker2() {
-  const distWorkerDir = import_path14.default.join(PROJECT_DIR4, "dist-worker");
+  const distWorkerDir = import_path15.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_path14.default.join(distWorkerDir, "worker.js");
+  const workerJsPath = import_path15.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."
@@ -9377,7 +10061,7 @@ function getBuiltWorker2() {
   const files = import_fs_extra9.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 };
@@ -9403,7 +10087,7 @@ async function updateWorker(workerJsPath, modulePaths, metadata, projectName) {
       type: "application/javascript+module"
     }), "worker.js");
     for (const modulePath of modulePaths) {
-      const filename = import_path14.default.basename(modulePath);
+      const filename = import_path15.default.basename(modulePath);
       const content = import_fs_extra9.default.readFileSync(modulePath, "utf-8");
       formData.append(filename, new Blob2([content], {
         type: "application/javascript+module"
@@ -9466,9 +10150,9 @@ 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");
+    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_extra9.default.existsSync(tokenFileSrc) && !import_fs_extra9.default.existsSync(tokenFileDst)) {
       import_fs_extra9.default.copySync(tokenFileSrc, tokenFileDst);
     }
@@ -9491,8 +10175,26 @@ async function updateWorkerCmd(options) {
     console.log(import_chalk23.default.gray(`SQL files: ignored (not processed for update_worker)`));
     await updateWorker(workerJsPath, modulePaths, metadata, projectName);
     console.log(import_chalk23.default.green("\nWorker update complete."));
+    void tracker_default.trackEvent(
+      TRACK_EVENTS.projectUpdateWorkerSuccess,
+      TRACK_PAGES.deploy,
+      {
+        a: resolveTrackAction2(TRACK_EVENTS.projectUpdateWorkerSuccess),
+        project_name: projectName,
+        module_count: modulePaths.length
+      }
+    );
     process.exit(0);
   } catch (error) {
+    void tracker_default.trackEvent(
+      TRACK_EVENTS.projectUpdateWorkerFailed,
+      TRACK_PAGES.deploy,
+      {
+        a: resolveTrackAction2(TRACK_EVENTS.projectUpdateWorkerFailed),
+        project_name: (options == null ? void 0 : options.projectName) || (options == null ? void 0 : options.name),
+        reason: getTrackErrorReason(error)
+      }
+    );
     printCliError(error, "Worker update failed.");
     process.exit(1);
   }
@@ -9501,14 +10203,14 @@ async function updateWorkerCmd(options) {
 // bin/updateWeb.ts
 var import_chalk24 = __toESM(require("chalk"));
 var import_fs_extra10 = __toESM(require("fs-extra"));
-var import_path15 = __toESM(require("path"));
-var import_child_process6 = require("child_process");
+var import_path16 = __toESM(require("path"));
+var import_child_process7 = require("child_process");
 init_webLogin();
 init_cliError();
 init_config();
 var PROJECT_DIR5 = process.cwd();
 function loadConfig4() {
-  const configPath = import_path15.default.join(PROJECT_DIR5, "pinme.toml");
+  const configPath = import_path16.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."
@@ -9526,7 +10228,7 @@ function getProjectManagementUrl3(projectName) {
 function buildFrontend2() {
   console.log(import_chalk24.default.blue("Building frontend..."));
   try {
-    (0, import_child_process6.execSync)("npm run build:frontend", {
+    (0, import_child_process7.execSync)("npm run build:frontend", {
       cwd: PROJECT_DIR5,
       stdio: "inherit"
     });
@@ -9541,7 +10243,7 @@ async function deployFrontend2(projectName) {
   console.log(import_chalk24.default.blue("Deploying frontend to IPFS..."));
   try {
     const headers = getAuthHeaders();
-    const uploadResult = await uploadPath(import_path15.default.join(PROJECT_DIR5, "frontend", "dist"), {
+    const uploadResult = await uploadPath(import_path16.default.join(PROJECT_DIR5, "frontend", "dist"), {
       projectName,
       uid: headers["token-address"]
     });
@@ -9565,9 +10267,9 @@ 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");
+    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_extra10.default.existsSync(tokenFileSrc) && !import_fs_extra10.default.existsSync(tokenFileDst)) {
       import_fs_extra10.default.copySync(tokenFileSrc, tokenFileDst);
     }
@@ -9585,8 +10287,25 @@ async function updateWebCmd(options) {
     buildFrontend2();
     await deployFrontend2(projectName);
     console.log(import_chalk24.default.green("\nWeb update complete."));
+    void tracker_default.trackEvent(
+      TRACK_EVENTS.projectUpdateWebSuccess,
+      TRACK_PAGES.deploy,
+      {
+        a: resolveTrackAction2(TRACK_EVENTS.projectUpdateWebSuccess),
+        project_name: projectName
+      }
+    );
     process.exit(0);
   } catch (error) {
+    void tracker_default.trackEvent(
+      TRACK_EVENTS.projectUpdateWebFailed,
+      TRACK_PAGES.deploy,
+      {
+        a: resolveTrackAction2(TRACK_EVENTS.projectUpdateWebFailed),
+        project_name: (options == null ? void 0 : options.projectName) || (options == null ? void 0 : options.name),
+        reason: getTrackErrorReason(error)
+      }
+    );
     printCliError(error, "Web update failed.");
     process.exit(1);
   }
@@ -9597,11 +10316,11 @@ var import_chalk25 = __toESM(require("chalk"));
 var import_inquirer9 = __toESM(require("inquirer"));
 init_axios2();
 var import_fs_extra11 = __toESM(require("fs-extra"));
-var import_path16 = __toESM(require("path"));
+var import_path17 = __toESM(require("path"));
 init_webLogin();
 init_config();
 function getProjectName() {
-  const configPath = import_path16.default.join(process.cwd(), "pinme.toml");
+  const configPath = import_path17.default.join(process.cwd(), "pinme.toml");
   if (!import_fs_extra11.default.existsSync(configPath)) {
     return null;
   }
@@ -9668,6 +10387,17 @@ async function deleteCmd(options) {
     });
     const data = response.data;
     if (data.code === 200) {
+      void tracker_default.trackEvent(
+        TRACK_EVENTS.projectDeleteSuccess,
+        TRACK_PAGES.project,
+        {
+          a: resolveTrackAction2(TRACK_EVENTS.projectDeleteSuccess),
+          project_name: data.data.project_name,
+          domain_deleted: Boolean(data.data.domain_deleted),
+          worker_deleted: Boolean(data.data.worker_deleted),
+          database_deleted: Boolean(data.data.database_deleted)
+        }
+      );
       console.log(import_chalk25.default.green("\n\u2705 Project deleted successfully!"));
       console.log(import_chalk25.default.gray(`
 Project: ${data.data.project_name}`));
@@ -9681,6 +10411,16 @@ Project: ${data.data.project_name}`));
     }
     process.exit(0);
   } catch (error) {
+    void tracker_default.trackEvent(
+      TRACK_EVENTS.projectDeleteFailed,
+      TRACK_PAGES.project,
+      {
+        a: resolveTrackAction2(TRACK_EVENTS.projectDeleteFailed),
+        project_name: options.name || getProjectName() || void 0,
+        force: Boolean(options.force),
+        reason: getTrackErrorReason(error)
+      }
+    );
     console.log(import_chalk25.default.red(error));
     const errorMsg = ((_b = (_a2 = error.response) == null ? void 0 : _a2.data) == null ? void 0 : _b.msg) || error.message || "Failed to delete project";
     console.error(import_chalk25.default.red(`