create-tina-app 0.0.0-e6ffde4-20251216055147 → 0.0.0-e9ba228-20251219004107

package/dist/index.js

@@ -1,7 +1,6 @@
 // src/index.ts
-import { Telemetry } from "@tinacms/metrics";
 import prompts from "prompts";
-import path4 from "node:path";
+import path3 from "node:path";
 import { createRequire } from "node:module";
 
 // src/util/fileUtil.ts
@@ -20,6 +19,16 @@ var TextStyles = {
   err: chalk.red,
   bold: chalk.bold
 };
+var TextStylesBold = {
+  tinaOrange: chalk.hex("#EC4816").bold,
+  link: (url) => `\x1B]8;;${url}\x07${chalk.cyan.underline(url)}\x1B]8;;\x07`,
+  cmd: chalk.bgBlackBright.bold.white,
+  info: chalk.blue,
+  success: chalk.green,
+  warn: chalk.yellow,
+  err: chalk.red,
+  bold: chalk.bold
+};
 
 // src/util/fileUtil.ts
 async function isWriteable(directory) {
@@ -125,7 +134,6 @@ function install(packageManager, verboseOutput) {
 
 // src/util/git.ts
 import { execSync } from "child_process";
-import path2 from "path";
 import fs2 from "fs-extra";
 function isInGitRepository() {
   try {
@@ -144,16 +152,11 @@ function isInMercurialRepository() {
   return false;
 }
 function makeFirstCommit(root) {
-  try {
-    execSync("git checkout -b main", { stdio: "ignore" });
-    execSync("git add -A", { stdio: "ignore" });
-    execSync('git commit -m "Initial commit from Create Tina App"', {
-      stdio: "ignore"
-    });
-  } catch (err) {
-    fs2.removeSync(path2.join(root, ".git"));
-    throw err;
-  }
+  execSync("git checkout -b main", { stdio: "ignore" });
+  execSync("git add -A", { stdio: "ignore" });
+  execSync('git commit -m "Initial commit from Create Tina App"', {
+    stdio: "ignore"
+  });
 }
 function initializeGit(spinner) {
   execSync("git --version", { stdio: "ignore" });
@@ -236,7 +239,7 @@ async function downloadAndExtractRepo(root, { username, name: name2, branch, fil
 
 // src/templates.ts
 import { copy } from "fs-extra";
-import path3 from "path";
+import path2 from "path";
 var TEMPLATES = [
   {
     title: "\u2B50 NextJS starter",
@@ -405,7 +408,7 @@ async function downloadTemplate(template, root, spinner) {
     )}`;
     await downloadAndExtractRepo(root, repoInfo);
   } else {
-    const templateFile = path3.join(__dirname, "..", "examples", template.value);
+    const templateFile = path2.join(__dirname, "..", "examples", template.value);
     await copy(`${templateFile}/`, "./");
   }
 }
@@ -455,7 +458,7 @@ import { Command } from "commander";
 
 // package.json
 var name = "create-tina-app";
-var version = "2.0.0";
+var version = "2.1.0";
 
 // src/util/packageManagers.ts
 var PKG_MANAGERS = ["npm", "yarn", "pnpm", "bun"];
@@ -631,6 +634,259 @@ var THEMES = [
 ];
 
 // src/index.ts
+import { PostHog } from "posthog-node";
+
+// src/util/posthog.ts
+import { createHash, randomUUID } from "node:crypto";
+import { system as getSystemInfo } from "systeminformation";
+var CreateTinaAppStartedEvent = "create-tina-app-started";
+var CreateTinaAppFinishedEvent = "create-tina-app-finished";
+var TRACKING_STEPS = {
+  INIT: "initializing",
+  PRE_RUN_CHECKS: "pre_run_checks",
+  TELEMETRY_SETUP: "telemetry_setup",
+  PKG_MANAGER_SELECT: "package_manager_selection",
+  PROJECT_NAME_INPUT: "project_name_input",
+  TEMPLATE_SELECT: "template_selection",
+  THEME_SELECT: "theme_selection",
+  DIRECTORY_SETUP: "directory_setup",
+  DOWNLOADING_TEMPLATE: "downloading_template",
+  UPDATING_METADATA: "updating_metadata",
+  INSTALLING_PACKAGES: "installing_packages",
+  GIT_INIT: "git_initialization",
+  COMPLETE: "complete"
+};
+function generateSessionId() {
+  return randomUUID();
+}
+async function getAnonymousUserId() {
+  try {
+    const sysInfo = await getSystemInfo();
+    const systemUuid = sysInfo.uuid || "unknown";
+    if (systemUuid === "unknown" || !systemUuid) {
+      return `fallback-${randomUUID()}`;
+    }
+    const hash = createHash("sha256");
+    hash.update(systemUuid);
+    return hash.digest("hex").substring(0, 32);
+  } catch (error) {
+    return `fallback-${randomUUID()}`;
+  }
+}
+var ERROR_CODES = {
+  // Validation Errors (VAL_*)
+  ERR_VAL_INVALID_TEMPLATE: "ERR_VAL_INVALID_TEMPLATE",
+  ERR_VAL_INVALID_PKG_MANAGER: "ERR_VAL_INVALID_PKG_MANAGER",
+  ERR_VAL_INVALID_PROJECT_NAME: "ERR_VAL_INVALID_PROJECT_NAME",
+  ERR_VAL_UNSUPPORTED_NODE: "ERR_VAL_UNSUPPORTED_NODE",
+  ERR_VAL_NO_PKG_MANAGERS: "ERR_VAL_NO_PKG_MANAGERS",
+  // File System Errors (FS_*)
+  ERR_FS_NOT_WRITABLE: "ERR_FS_NOT_WRITABLE",
+  ERR_FS_HAS_CONFLICTS: "ERR_FS_HAS_CONFLICTS",
+  ERR_FS_MKDIR_FAILED: "ERR_FS_MKDIR_FAILED",
+  ERR_FS_CHDIR_FAILED: "ERR_FS_CHDIR_FAILED",
+  ERR_FS_READ_PACKAGE_JSON: "ERR_FS_READ_PACKAGE_JSON",
+  ERR_FS_WRITE_PACKAGE_JSON: "ERR_FS_WRITE_PACKAGE_JSON",
+  ERR_FS_UPDATE_THEME_FAILED: "ERR_FS_UPDATE_THEME_FAILED",
+  ERR_FS_COPY_TEMPLATE_FAILED: "ERR_FS_COPY_TEMPLATE_FAILED",
+  // Network Errors (NET_*)
+  ERR_NET_POSTHOG_CONFIG_FETCH: "ERR_NET_POSTHOG_CONFIG_FETCH",
+  ERR_NET_TARBALL_DOWNLOAD: "ERR_NET_TARBALL_DOWNLOAD",
+  ERR_NET_GITHUB_API_FAILED: "ERR_NET_GITHUB_API_FAILED",
+  ERR_NET_REPO_INFO_NOT_FOUND: "ERR_NET_REPO_INFO_NOT_FOUND",
+  ERR_NET_REPO_INVALID_URL: "ERR_NET_REPO_INVALID_URL",
+  ERR_NET_TARBALL_EXTRACT: "ERR_NET_TARBALL_EXTRACT",
+  // Installation Errors (INSTALL_*)
+  ERR_INSTALL_PKG_MANAGER_FAILED: "ERR_INSTALL_PKG_MANAGER_FAILED",
+  ERR_INSTALL_PKG_MANAGER_NOT_FOUND: "ERR_INSTALL_PKG_MANAGER_NOT_FOUND",
+  ERR_INSTALL_SPAWN_ERROR: "ERR_INSTALL_SPAWN_ERROR",
+  ERR_INSTALL_TIMEOUT: "ERR_INSTALL_TIMEOUT",
+  // Git Errors (GIT_*)
+  ERR_GIT_NOT_INSTALLED: "ERR_GIT_NOT_INSTALLED",
+  ERR_GIT_INIT_FAILED: "ERR_GIT_INIT_FAILED",
+  ERR_GIT_ADD_FAILED: "ERR_GIT_ADD_FAILED",
+  ERR_GIT_COMMIT_FAILED: "ERR_GIT_COMMIT_FAILED",
+  ERR_GIT_CHECKOUT_FAILED: "ERR_GIT_CHECKOUT_FAILED",
+  ERR_GIT_ALREADY_INITIALIZED: "ERR_GIT_ALREADY_INITIALIZED",
+  // User Cancellation (CANCEL_*)
+  ERR_CANCEL_PKG_MANAGER_PROMPT: "ERR_CANCEL_PKG_MANAGER_PROMPT",
+  ERR_CANCEL_PROJECT_NAME_PROMPT: "ERR_CANCEL_PROJECT_NAME_PROMPT",
+  ERR_CANCEL_TEMPLATE_PROMPT: "ERR_CANCEL_TEMPLATE_PROMPT",
+  ERR_CANCEL_THEME_PROMPT: "ERR_CANCEL_THEME_PROMPT",
+  ERR_CANCEL_SIGINT: "ERR_CANCEL_SIGINT",
+  // Configuration Errors (CFG_*)
+  ERR_CFG_POSTHOG_INIT_FAILED: "ERR_CFG_POSTHOG_INIT_FAILED",
+  ERR_CFG_OSINFO_FETCH_FAILED: "ERR_CFG_OSINFO_FETCH_FAILED",
+  ERR_CFG_TELEMETRY_SETUP_FAILED: "ERR_CFG_TELEMETRY_SETUP_FAILED",
+  // Template Errors (TPL_*)
+  ERR_TPL_DOWNLOAD_FAILED: "ERR_TPL_DOWNLOAD_FAILED",
+  ERR_TPL_EXTRACT_FAILED: "ERR_TPL_EXTRACT_FAILED",
+  ERR_TPL_METADATA_UPDATE_FAILED: "ERR_TPL_METADATA_UPDATE_FAILED",
+  ERR_TPL_INTERNAL_COPY_FAILED: "ERR_TPL_INTERNAL_COPY_FAILED",
+  ERR_TPL_THEME_UPDATE_FAILED: "ERR_TPL_THEME_UPDATE_FAILED",
+  // Uncategorized
+  ERR_UNCAUGHT: "ERR_UNCAUGHT"
+};
+function sanitizeStackTrace(stack) {
+  if (!stack) return "";
+  let sanitized = stack;
+  sanitized = sanitized.replace(/\/Users\/[^\/]+/g, "<user-home>");
+  sanitized = sanitized.replace(/[A-Z]:\\Users\\[^\\]+/gi, "<user-home>");
+  sanitized = sanitized.replace(
+    /.*\/(packages\/create-tina-app)\//g,
+    "<workspace>/$1/"
+  );
+  sanitized = sanitized.replace(
+    /(\/|\\)node_modules(\/|\\)/g,
+    "<node_modules>/"
+  );
+  sanitized = sanitized.replace(/\.npm\/_cacache/g, "<pkg-cache>");
+  sanitized = sanitized.replace(/\.yarn\/cache/g, "<pkg-cache>");
+  sanitized = sanitized.replace(/\.pnpm-store/g, "<pkg-cache>");
+  sanitized = sanitized.replace(/[A-Z]:\\/gi, "<drive>/");
+  return sanitized;
+}
+function truncateStackTrace(stack, maxFrames = 5) {
+  const lines = stack.split("\n");
+  const filtered = lines.filter((line) => {
+    if (!line.trim().startsWith("at ")) return true;
+    return !line.includes("node:internal") && !line.includes("node_modules/prompts") && !line.includes("node_modules/ora");
+  }).slice(0, maxFrames + 1);
+  return filtered.join("\n");
+}
+function createSimpleHash(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(36);
+}
+function sanitizeError(error) {
+  const message = error.message || "Unknown error";
+  const rawStack = error.stack || "";
+  const truncated = truncateStackTrace(rawStack);
+  const sanitizedStack = sanitizeStackTrace(truncated);
+  const stackForHash = rawStack.replace(/:\d+:\d+/g, "").replace(/\/Users\/[^\/]+/g, "").replace(/[A-Z]:\\Users\\[^\\]+/gi, "");
+  const originalStackHash = createSimpleHash(stackForHash);
+  return {
+    message,
+    sanitizedStack,
+    originalStackHash
+  };
+}
+function postHogCapture(client, distinctId, sessionId, event, properties) {
+  if (process.env.TINA_DEV === "true") return;
+  if (!client) {
+    return;
+  }
+  try {
+    client.capture({
+      distinctId,
+      event,
+      properties: {
+        ...properties,
+        sessionId,
+        system: "tinacms/create-tina-app"
+      }
+    });
+  } catch (error) {
+    console.error("Error capturing event:", error);
+  }
+}
+function postHogCaptureError(client, distinctId, sessionId, error, context) {
+  if (process.env.TINA_DEV === "true") return;
+  if (!client) return;
+  const { message, sanitizedStack, originalStackHash } = sanitizeError(error);
+  const {
+    errorCode,
+    errorCategory,
+    step,
+    fatal = true,
+    additionalProperties = {}
+  } = context;
+  let eventName;
+  if (errorCategory === "user-cancellation") {
+    eventName = "create-tina-app-user-cancelled";
+  } else if (errorCategory === "validation") {
+    eventName = "create-tina-app-validation-error";
+  } else {
+    eventName = "create-tina-app-error";
+  }
+  const properties = {
+    error_code: errorCode,
+    error_category: errorCategory,
+    error_message: message.substring(0, 500),
+    // Limit message length
+    sanitized_stack: sanitizedStack,
+    stack_hash: originalStackHash,
+    step,
+    fatal,
+    user_cancelled: errorCategory === "user-cancellation",
+    sessionId,
+    ...additionalProperties
+  };
+  try {
+    client.capture({
+      distinctId,
+      event: eventName,
+      properties: {
+        ...properties,
+        system: "tinacms/create-tina-app"
+      }
+    });
+  } catch (captureError) {
+    console.error("Error capturing error event:", captureError);
+  }
+}
+
+// src/util/fetchPosthogConfig.tsx
+async function fetchPostHogConfig(endpointUrl) {
+  try {
+    const response = await fetch(endpointUrl, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch PostHog config: ${response.statusText}`);
+    }
+    const config = await response.json();
+    return {
+      POSTHOG_API_KEY: config.api_key,
+      POSTHOG_ENDPOINT: config.host
+    };
+  } catch (error) {
+    console.warn(
+      `Failed to fetch PostHog config from endpoint: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+    return {};
+  }
+}
+
+// src/index.ts
+import { osInfo as getOsSystemInfo } from "systeminformation";
+var posthogClient = null;
+async function initializePostHog(configEndpoint) {
+  let apiKey;
+  let endpoint;
+  if (configEndpoint) {
+    const config = await fetchPostHogConfig(configEndpoint);
+    apiKey = config.POSTHOG_API_KEY;
+    endpoint = config.POSTHOG_ENDPOINT;
+  }
+  if (!apiKey) {
+    console.warn(
+      "PostHog API key not found. PostHog tracking will be disabled."
+    );
+    return null;
+  }
+  return new PostHog(apiKey, {
+    host: endpoint
+  });
+}
 function formatTemplateChoice(template) {
   let description = template.description || "";
   if (template.features && template.features.length > 0) {
@@ -649,6 +905,8 @@ ${featuresText}`;
 async function run() {
   const ora = (await import("ora")).default;
   let packageManagerInstallationHadError = false;
+  const sessionId = generateSessionId();
+  const userId = await getAnonymousUserId();
   if (process.stdout.columns >= 60) {
     console.log(TextStyles.tinaOrange(`${llama}`));
     console.log(TextStyles.tinaOrange(`${tinaCms}`));
@@ -658,10 +916,43 @@ async function run() {
   const require2 = createRequire(import.meta.url);
   const version2 = require2("../package.json").version;
   console.log(`Create Tina App v${version2}`);
+  const opts = extractOptions(process.argv);
+  const installedPkgManagers = [];
+  for (const pkg_manager of PKG_MANAGERS) {
+    if (await checkPackageExists(pkg_manager)) {
+      installedPkgManagers.push(pkg_manager);
+    }
+  }
+  const telemetryData = {};
+  if (!opts.noTelemetry) {
+    console.log(`
+${TextStylesBold.bold("Telemetry Notice")}`);
+    console.log(
+      `To help the TinaCMS team improve the developer experience, create-tina-app collects anonymous usage statistics. This data helps us understand which environments and features are most important to support. Usage analytics may include: Operating system and version, package manager name and version (local only), Node.js version (local only), and the selected TinaCMS starter template.
+No personal or project-specific code is ever collected. You can opt out at any time by passing the --noTelemetry flag.
+`
+    );
+    posthogClient = await initializePostHog(
+      "https://identity-v2.tinajs.io/v2/posthog-token"
+    );
+    const osInfo = await getOsSystemInfo();
+    telemetryData["os-platform"] = osInfo.platform;
+    telemetryData["os-distro"] = osInfo.distro;
+    telemetryData["os-release"] = osInfo.release;
+    telemetryData["node-version"] = process.version;
+    for (const pkgManager2 of PKG_MANAGERS) {
+      telemetryData[`${pkgManager2}-installed`] = installedPkgManagers.includes(pkgManager2);
+    }
+  }
   const spinner = ora();
   preRunChecks(spinner);
-  const opts = extractOptions(process.argv);
-  const telemetry = new Telemetry({ disabled: opts?.noTelemetry });
+  postHogCapture(
+    posthogClient,
+    userId,
+    sessionId,
+    CreateTinaAppStartedEvent,
+    telemetryData
+  );
   let template = null;
   if (opts.template) {
     template = TEMPLATES.find((_template) => _template.value === opts.template);
@@ -671,6 +962,23 @@ async function run() {
           (x2) => x2.value
         )}`
       );
+      postHogCaptureError(
+        posthogClient,
+        userId,
+        sessionId,
+        new Error(`Invalid template: ${opts.template}`),
+        {
+          errorCode: ERROR_CODES.ERR_VAL_INVALID_TEMPLATE,
+          errorCategory: "validation",
+          step: TRACKING_STEPS.TEMPLATE_SELECT,
+          fatal: true,
+          additionalProperties: {
+            ...telemetryData,
+            "package-manager": opts.template
+          }
+        }
+      );
+      if (posthogClient) await posthogClient.shutdown();
       exit(1);
     }
   }
@@ -680,20 +988,45 @@ async function run() {
       spinner.fail(
         `The provided package manager '${opts.pkgManager}' is not supported. Please provide one of the following: ${PKG_MANAGERS}`
       );
+      postHogCaptureError(
+        posthogClient,
+        userId,
+        sessionId,
+        new Error(`Invalid package manager: ${opts.pkgManager}`),
+        {
+          errorCode: ERROR_CODES.ERR_VAL_INVALID_PKG_MANAGER,
+          errorCategory: "validation",
+          step: TRACKING_STEPS.PKG_MANAGER_SELECT,
+          fatal: true,
+          additionalProperties: {
+            ...telemetryData,
+            provided_pkg_manager: opts.pkgManager
+          }
+        }
+      );
+      if (posthogClient) await posthogClient.shutdown();
       exit(1);
     }
   }
   if (!pkgManager) {
-    const installedPkgManagers = [];
-    for (const pkg_manager of PKG_MANAGERS) {
-      if (await checkPackageExists(pkg_manager)) {
-        installedPkgManagers.push(pkg_manager);
-      }
-    }
     if (installedPkgManagers.length === 0) {
       spinner.fail(
         `You have no supported package managers installed. Please install one of the following: ${PKG_MANAGERS}`
       );
+      postHogCaptureError(
+        posthogClient,
+        userId,
+        sessionId,
+        new Error("No supported package managers installed"),
+        {
+          errorCode: ERROR_CODES.ERR_VAL_NO_PKG_MANAGERS,
+          errorCategory: "validation",
+          step: TRACKING_STEPS.PRE_RUN_CHECKS,
+          fatal: true,
+          additionalProperties: telemetryData
+        }
+      );
+      if (posthogClient) await posthogClient.shutdown();
       exit(1);
     }
     const res = await prompts({
@@ -704,9 +1037,26 @@ async function run() {
         return { title: manager, value: manager };
       })
     });
-    if (!Object.hasOwn(res, "packageManager")) exit(1);
+    if (!Object.hasOwn(res, "packageManager")) {
+      postHogCaptureError(
+        posthogClient,
+        userId,
+        sessionId,
+        new Error("User cancelled package manager selection"),
+        {
+          errorCode: ERROR_CODES.ERR_CANCEL_PKG_MANAGER_PROMPT,
+          errorCategory: "user-cancellation",
+          step: TRACKING_STEPS.PKG_MANAGER_SELECT,
+          fatal: true,
+          additionalProperties: telemetryData
+        }
+      );
+      if (posthogClient) await posthogClient.shutdown();
+      exit(1);
+    }
     pkgManager = res.packageManager;
   }
+  telemetryData["package-manager"] = pkgManager;
   let projectName = opts.projectName;
   if (!projectName) {
     const res = await prompts({
@@ -716,13 +1066,29 @@ async function run() {
       initial: "my-tina-app",
       validate: (name2) => {
         const { message, isError } = validate(
-          path4.basename(path4.resolve(name2))
+          path3.basename(path3.resolve(name2))
         );
         if (isError) return `Invalid project name: ${message}`;
         return true;
       }
     });
-    if (!Object.hasOwn(res, "name")) exit(1);
+    if (!Object.hasOwn(res, "name")) {
+      postHogCaptureError(
+        posthogClient,
+        userId,
+        sessionId,
+        new Error("User cancelled project name input"),
+        {
+          errorCode: ERROR_CODES.ERR_CANCEL_PROJECT_NAME_PROMPT,
+          errorCategory: "user-cancellation",
+          step: TRACKING_STEPS.PROJECT_NAME_INPUT,
+          fatal: true,
+          additionalProperties: telemetryData
+        }
+      );
+      if (posthogClient) await posthogClient.shutdown();
+      exit(1);
+    }
     projectName = res.name;
   }
   if (!template) {
@@ -732,9 +1098,26 @@ async function run() {
       message: "What starter code would you like to use?",
       choices: TEMPLATES.map(formatTemplateChoice)
     });
-    if (!Object.hasOwn(res, "template")) exit(1);
+    if (!Object.hasOwn(res, "template")) {
+      postHogCaptureError(
+        posthogClient,
+        userId,
+        sessionId,
+        new Error("User cancelled template selection"),
+        {
+          errorCode: ERROR_CODES.ERR_CANCEL_TEMPLATE_PROMPT,
+          errorCategory: "user-cancellation",
+          step: TRACKING_STEPS.TEMPLATE_SELECT,
+          fatal: true,
+          additionalProperties: telemetryData
+        }
+      );
+      if (posthogClient) await posthogClient.shutdown();
+      exit(1);
+    }
     template = TEMPLATES.find((_template) => _template.value === res.template);
   }
+  telemetryData["template"] = template.value;
   let themeChoice;
   if (template.value === "tina-docs") {
     const res = await prompts({
@@ -743,33 +1126,69 @@ async function run() {
       message: "What theme would you like to use?",
       choices: THEMES
     });
-    if (!Object.hasOwn(res, "theme")) exit(1);
+    if (!Object.hasOwn(res, "theme")) {
+      postHogCaptureError(
+        posthogClient,
+        userId,
+        sessionId,
+        new Error("User cancelled theme selection"),
+        {
+          errorCode: ERROR_CODES.ERR_CANCEL_THEME_PROMPT,
+          errorCategory: "user-cancellation",
+          step: TRACKING_STEPS.THEME_SELECT,
+          fatal: true,
+          additionalProperties: {
+            ...telemetryData,
+            template: template.value
+          }
+        }
+      );
+      if (posthogClient) await posthogClient.shutdown();
+      exit(1);
+    }
     themeChoice = res.theme;
   }
-  await telemetry.submitRecord({
-    event: {
-      name: "create-tina-app:invoke",
-      template: template.value,
-      pkgManager
-    }
-  });
-  const rootDir = path4.join(process.cwd(), projectName);
-  if (!await isWriteable(path4.dirname(rootDir))) {
+  const rootDir = path3.join(process.cwd(), projectName);
+  if (!await isWriteable(path3.dirname(rootDir))) {
     spinner.fail(
       "The application path is not writable, please check folder permissions and try again. It is likely you do not have write permissions for this folder."
     );
+    postHogCaptureError(
+      posthogClient,
+      userId,
+      sessionId,
+      new Error("Directory not writable"),
+      {
+        errorCode: ERROR_CODES.ERR_FS_NOT_WRITABLE,
+        errorCategory: "filesystem",
+        step: TRACKING_STEPS.DIRECTORY_SETUP,
+        fatal: true,
+        additionalProperties: { ...telemetryData }
+      }
+    );
+    if (posthogClient) await posthogClient.shutdown();
     process.exit(1);
   }
   let appName;
   try {
     appName = await setupProjectDirectory(rootDir);
+    telemetryData["app-name"] = appName;
   } catch (err) {
-    spinner.fail(err.message);
+    const error = err;
+    spinner.fail(error.message);
+    postHogCaptureError(posthogClient, userId, sessionId, error, {
+      errorCode: ERROR_CODES.ERR_FS_MKDIR_FAILED,
+      errorCategory: "filesystem",
+      step: TRACKING_STEPS.DIRECTORY_SETUP,
+      fatal: true,
+      additionalProperties: { ...telemetryData }
+    });
+    if (posthogClient) await posthogClient.shutdown();
     exit(1);
   }
   try {
-    await downloadTemplate(template, rootDir, spinner);
     if (themeChoice) {
+      telemetryData["theme"] = themeChoice;
       await updateThemeSettings(rootDir, themeChoice);
     }
     spinner.start("Downloading template...");
@@ -780,7 +1199,16 @@ async function run() {
     updateProjectPackageVersion(rootDir, "0.0.1");
     spinner.succeed();
   } catch (err) {
-    spinner.fail(`Failed to download template: ${err.message}`);
+    const error = err;
+    spinner.fail(`Failed to download template: ${error.message}`);
+    postHogCaptureError(posthogClient, userId, sessionId, error, {
+      errorCode: ERROR_CODES.ERR_TPL_DOWNLOAD_FAILED,
+      errorCategory: "template",
+      step: TRACKING_STEPS.DOWNLOADING_TEMPLATE,
+      fatal: true,
+      additionalProperties: { ...telemetryData }
+    });
+    if (posthogClient) await posthogClient.shutdown();
     exit(1);
   }
   spinner.start("Installing packages.");
@@ -788,8 +1216,16 @@ async function run() {
     await install(pkgManager, opts.verbose);
     spinner.succeed();
   } catch (err) {
-    spinner.fail(`Failed to install packages: ${err.message}`);
+    const error = err;
+    spinner.fail(`Failed to install packages: ${error.message}`);
     packageManagerInstallationHadError = true;
+    postHogCaptureError(posthogClient, userId, sessionId, error, {
+      errorCode: ERROR_CODES.ERR_INSTALL_PKG_MANAGER_FAILED,
+      errorCategory: "installation",
+      step: TRACKING_STEPS.INSTALLING_PACKAGES,
+      fatal: false,
+      additionalProperties: { ...telemetryData }
+    });
   }
   spinner.start("Initializing git repository.");
   try {
@@ -798,8 +1234,23 @@ async function run() {
       spinner.succeed();
     }
   } catch (err) {
+    const error = err;
     spinner.fail("Failed to initialize Git repository, skipping.");
+    postHogCaptureError(posthogClient, userId, sessionId, error, {
+      errorCode: ERROR_CODES.ERR_GIT_INIT_FAILED,
+      errorCategory: "git",
+      step: TRACKING_STEPS.GIT_INIT,
+      fatal: false,
+      additionalProperties: { ...telemetryData }
+    });
   }
+  postHogCapture(
+    posthogClient,
+    userId,
+    sessionId,
+    CreateTinaAppFinishedEvent,
+    telemetryData
+  );
   spinner.succeed(`Created ${TextStyles.tinaOrange(appName)}
 `);
   if (template.value === "tina-hugo-starter") {
@@ -842,12 +1293,28 @@ async function run() {
     )}`
   );
 }
-run().catch((error) => {
+run().catch(async (error) => {
   if (process.stdout.columns >= 60) {
     console.log(TextStyles.tinaOrange(`${errorArt}`));
   }
-  console.error("Error running create-tina-app: \n", error);
+  console.error("Error running create-tina-app:", error);
+  const sessionId = generateSessionId();
+  const userId = await getAnonymousUserId();
+  postHogCaptureError(posthogClient, userId, sessionId, error, {
+    errorCode: ERROR_CODES.ERR_UNCAUGHT,
+    errorCategory: "uncategorized",
+    step: "unknown",
+    fatal: true,
+    additionalProperties: {}
+  });
+  if (posthogClient) {
+    await posthogClient.shutdown();
+  }
   process.exit(1);
+}).then(async () => {
+  if (posthogClient) {
+    await posthogClient.shutdown();
+  }
 });
 export {
   run

package/dist/util/fetchPosthogConfig.d.ts

@@ -0,0 +1,5 @@
+export interface PostHogConfig {
+    POSTHOG_API_KEY?: string;
+    POSTHOG_ENDPOINT?: string;
+}
+export default function fetchPostHogConfig(endpointUrl: string): Promise<PostHogConfig>;

package/dist/util/posthog.d.ts

@@ -0,0 +1,147 @@
+import { PostHog } from 'posthog-node';
+export declare const CreateTinaAppStartedEvent: string;
+export declare const CreateTinaAppFinishedEvent: string;
+/**
+ * Step names for tracking progress through the create-tina-app process
+ */
+export declare const TRACKING_STEPS: {
+    readonly INIT: "initializing";
+    readonly PRE_RUN_CHECKS: "pre_run_checks";
+    readonly TELEMETRY_SETUP: "telemetry_setup";
+    readonly PKG_MANAGER_SELECT: "package_manager_selection";
+    readonly PROJECT_NAME_INPUT: "project_name_input";
+    readonly TEMPLATE_SELECT: "template_selection";
+    readonly THEME_SELECT: "theme_selection";
+    readonly DIRECTORY_SETUP: "directory_setup";
+    readonly DOWNLOADING_TEMPLATE: "downloading_template";
+    readonly UPDATING_METADATA: "updating_metadata";
+    readonly INSTALLING_PACKAGES: "installing_packages";
+    readonly GIT_INIT: "git_initialization";
+    readonly COMPLETE: "complete";
+};
+/**
+ * Generate a unique session ID for this run
+ */
+export declare function generateSessionId(): string;
+/**
+ * Get a hashed user ID based on system UUID
+ * Returns a consistent anonymous identifier for the machine
+ */
+export declare function getAnonymousUserId(): Promise<string>;
+/**
+ * Structured error codes for categorizing failures
+ */
+export declare const ERROR_CODES: {
+    readonly ERR_VAL_INVALID_TEMPLATE: "ERR_VAL_INVALID_TEMPLATE";
+    readonly ERR_VAL_INVALID_PKG_MANAGER: "ERR_VAL_INVALID_PKG_MANAGER";
+    readonly ERR_VAL_INVALID_PROJECT_NAME: "ERR_VAL_INVALID_PROJECT_NAME";
+    readonly ERR_VAL_UNSUPPORTED_NODE: "ERR_VAL_UNSUPPORTED_NODE";
+    readonly ERR_VAL_NO_PKG_MANAGERS: "ERR_VAL_NO_PKG_MANAGERS";
+    readonly ERR_FS_NOT_WRITABLE: "ERR_FS_NOT_WRITABLE";
+    readonly ERR_FS_HAS_CONFLICTS: "ERR_FS_HAS_CONFLICTS";
+    readonly ERR_FS_MKDIR_FAILED: "ERR_FS_MKDIR_FAILED";
+    readonly ERR_FS_CHDIR_FAILED: "ERR_FS_CHDIR_FAILED";
+    readonly ERR_FS_READ_PACKAGE_JSON: "ERR_FS_READ_PACKAGE_JSON";
+    readonly ERR_FS_WRITE_PACKAGE_JSON: "ERR_FS_WRITE_PACKAGE_JSON";
+    readonly ERR_FS_UPDATE_THEME_FAILED: "ERR_FS_UPDATE_THEME_FAILED";
+    readonly ERR_FS_COPY_TEMPLATE_FAILED: "ERR_FS_COPY_TEMPLATE_FAILED";
+    readonly ERR_NET_POSTHOG_CONFIG_FETCH: "ERR_NET_POSTHOG_CONFIG_FETCH";
+    readonly ERR_NET_TARBALL_DOWNLOAD: "ERR_NET_TARBALL_DOWNLOAD";
+    readonly ERR_NET_GITHUB_API_FAILED: "ERR_NET_GITHUB_API_FAILED";
+    readonly ERR_NET_REPO_INFO_NOT_FOUND: "ERR_NET_REPO_INFO_NOT_FOUND";
+    readonly ERR_NET_REPO_INVALID_URL: "ERR_NET_REPO_INVALID_URL";
+    readonly ERR_NET_TARBALL_EXTRACT: "ERR_NET_TARBALL_EXTRACT";
+    readonly ERR_INSTALL_PKG_MANAGER_FAILED: "ERR_INSTALL_PKG_MANAGER_FAILED";
+    readonly ERR_INSTALL_PKG_MANAGER_NOT_FOUND: "ERR_INSTALL_PKG_MANAGER_NOT_FOUND";
+    readonly ERR_INSTALL_SPAWN_ERROR: "ERR_INSTALL_SPAWN_ERROR";
+    readonly ERR_INSTALL_TIMEOUT: "ERR_INSTALL_TIMEOUT";
+    readonly ERR_GIT_NOT_INSTALLED: "ERR_GIT_NOT_INSTALLED";
+    readonly ERR_GIT_INIT_FAILED: "ERR_GIT_INIT_FAILED";
+    readonly ERR_GIT_ADD_FAILED: "ERR_GIT_ADD_FAILED";
+    readonly ERR_GIT_COMMIT_FAILED: "ERR_GIT_COMMIT_FAILED";
+    readonly ERR_GIT_CHECKOUT_FAILED: "ERR_GIT_CHECKOUT_FAILED";
+    readonly ERR_GIT_ALREADY_INITIALIZED: "ERR_GIT_ALREADY_INITIALIZED";
+    readonly ERR_CANCEL_PKG_MANAGER_PROMPT: "ERR_CANCEL_PKG_MANAGER_PROMPT";
+    readonly ERR_CANCEL_PROJECT_NAME_PROMPT: "ERR_CANCEL_PROJECT_NAME_PROMPT";
+    readonly ERR_CANCEL_TEMPLATE_PROMPT: "ERR_CANCEL_TEMPLATE_PROMPT";
+    readonly ERR_CANCEL_THEME_PROMPT: "ERR_CANCEL_THEME_PROMPT";
+    readonly ERR_CANCEL_SIGINT: "ERR_CANCEL_SIGINT";
+    readonly ERR_CFG_POSTHOG_INIT_FAILED: "ERR_CFG_POSTHOG_INIT_FAILED";
+    readonly ERR_CFG_OSINFO_FETCH_FAILED: "ERR_CFG_OSINFO_FETCH_FAILED";
+    readonly ERR_CFG_TELEMETRY_SETUP_FAILED: "ERR_CFG_TELEMETRY_SETUP_FAILED";
+    readonly ERR_TPL_DOWNLOAD_FAILED: "ERR_TPL_DOWNLOAD_FAILED";
+    readonly ERR_TPL_EXTRACT_FAILED: "ERR_TPL_EXTRACT_FAILED";
+    readonly ERR_TPL_METADATA_UPDATE_FAILED: "ERR_TPL_METADATA_UPDATE_FAILED";
+    readonly ERR_TPL_INTERNAL_COPY_FAILED: "ERR_TPL_INTERNAL_COPY_FAILED";
+    readonly ERR_TPL_THEME_UPDATE_FAILED: "ERR_TPL_THEME_UPDATE_FAILED";
+    readonly ERR_UNCAUGHT: "ERR_UNCAUGHT";
+};
+/**
+ * Sends an event to PostHog for analytics tracking.
+ *
+ * @param client - The PostHog client instance used to send the event
+ * @param distinctId - A unique identifier for the user (hashed system UUID)
+ * @param sessionId - A unique identifier for this run/session
+ * @param event - The name of the event to track (e.g., 'create-tina-app-started')
+ * @param properties - Additional properties to include with the event
+ *
+ * @remarks
+ * - Returns early if the PostHog client is not provided
+ * - Skips sending data when `TINA_DEV` environment variable is set to 'true'
+ * - Automatically adds a 'system' property with value 'tinacms/create-tina-app'
+ * - Includes sessionId in properties to track individual runs
+ * - Uses hashed system UUID as distinctId to track unique users anonymously
+ * - Logs errors to console if event capture fails
+ *
+ * @example
+ * ```typescript
+ * const client = new PostHog('api-key');
+ * const userId = await getAnonymousUserId();
+ * const sessionId = generateSessionId();
+ * postHogCapture(client, userId, sessionId, 'create-tina-app-started', {
+ *   template: 'basic',
+ *   typescript: true
+ * });
+ * ```
+ */
+export declare function postHogCapture(client: PostHog, distinctId: string, sessionId: string, event: string, properties: Record<string, any>): void;
+/**
+ * Capture an error event in PostHog with categorized tracking and sanitized stack traces
+ *
+ * @param client - The PostHog client instance
+ * @param distinctId - A unique identifier for the user (hashed system UUID)
+ * @param sessionId - A unique identifier for this run/session
+ * @param error - The error object that was thrown
+ * @param context - Context about the error including code, category, step, and additional properties
+ *
+ * @remarks
+ * - Sanitizes stack traces to remove local file paths
+ * - Maps error categories to three event types:
+ *   - 'create-tina-app-error' for technical failures (filesystem, network, installation, git, etc.)
+ *   - 'create-tina-app-validation-error' for user input validation issues
+ *   - 'create-tina-app-user-cancelled' for user cancellations (Ctrl+C)
+ * - Includes error code, sanitized stack, step name, and telemetry data in properties
+ * - Non-fatal errors are tracked but allow the process to continue
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await downloadTemplate();
+ * } catch (err) {
+ *   postHogCaptureError(client, userId, sessionId, err as Error, {
+ *     errorCode: ERROR_CODES.ERR_TPL_DOWNLOAD_FAILED,
+ *     errorCategory: 'template',
+ *     step: TRACKING_STEPS.DOWNLOADING_TEMPLATE,
+ *     fatal: true,
+ *     additionalProperties: { template: 'basic' }
+ *   });
+ * }
+ * ```
+ */
+export declare function postHogCaptureError(client: PostHog | null, distinctId: string, sessionId: string, error: Error, context: {
+    errorCode: string;
+    errorCategory: string;
+    step: string;
+    fatal?: boolean;
+    additionalProperties?: Record<string, any>;
+}): void;

package/dist/util/textstyles.d.ts

@@ -8,3 +8,13 @@ export declare const TextStyles: {
     err: import("chalk").ChalkInstance;
     bold: import("chalk").ChalkInstance;
 };
+export declare const TextStylesBold: {
+    tinaOrange: import("chalk").ChalkInstance;
+    link: (url: string) => string;
+    cmd: import("chalk").ChalkInstance;
+    info: import("chalk").ChalkInstance;
+    success: import("chalk").ChalkInstance;
+    warn: import("chalk").ChalkInstance;
+    err: import("chalk").ChalkInstance;
+    bold: import("chalk").ChalkInstance;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-tina-app",
-  "version": "0.0.0-e6ffde4-20251216055147",
+  "version": "0.0.0-e9ba228-20251219004107",
   "type": "module",
   "main": "dist/index.js",
   "files": [
@@ -44,9 +44,10 @@
     "cross-spawn": "^7.0.6",
     "fs-extra": "^11.3.0",
     "ora": "^8.2.0",
+    "posthog-node": "^5.17.2",
     "prompts": "^2.4.2",
-    "tar": "7.4.0",
-    "@tinacms/metrics": "2.0.1"
+    "systeminformation": "^5.27.13",
+    "tar": "7.4.0"
   },
   "scripts": {
     "types": "pnpm tsc",