@absolutejs/absolute 0.16.12 → 0.17.0

package/.claude/settings.local.json

@@ -8,7 +8,8 @@
       "WebFetch(domain:gist.github.com)",
       "WebFetch(domain:vite.dev)",
       "WebFetch(domain:leapcell.io)",
-      "Bash(bun run build:*)"
+      "Bash(bun run build:*)",
+      "Bash(bun run:*)"
     ]
   }
 }

package/dist/cli/index.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env bun
 // @bun
+var __require = import.meta.require;
 
 // src/cli/scripts/dev.ts
 var {$: $2 } = globalThis.Bun;
 var {env } = globalThis.Bun;
-import { existsSync as existsSync2 } from "fs";
-import { resolve as resolve2 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { resolve as resolve3 } from "path";
 
 // src/constants.ts
 var SECONDS_IN_A_MINUTE = 60;
@@ -295,14 +296,124 @@ var createInteractiveHandler = (actions) => {
   return { clearPrompt, dispose, showPrompt };
 };
 
+// src/cli/telemetryEvent.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { arch, platform } from "os";
+import { resolve } from "path";
+
+// src/cli/scripts/telemetry.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var configDir = join(homedir(), ".absolutejs");
+var configPath = join(configDir, "telemetry.json");
+var getTelemetryConfig = () => {
+  try {
+    if (!existsSync(configPath))
+      return null;
+    const raw = readFileSync(configPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+var saveTelemetryConfig = (config) => {
+  mkdirSync(configDir, { recursive: true });
+  writeFileSync(configPath, JSON.stringify(config, null, "\t") + `
+`);
+};
+var enable = () => {
+  const existing = getTelemetryConfig();
+  const config = {
+    enabled: true,
+    anonymousId: existing?.anonymousId ?? crypto.randomUUID(),
+    createdAt: existing?.createdAt ?? new Date().toISOString()
+  };
+  saveTelemetryConfig(config);
+  console.log("Telemetry enabled.");
+  console.log(`Anonymous ID: ${config.anonymousId}`);
+};
+var disable = () => {
+  const existing = getTelemetryConfig();
+  if (existing) {
+    saveTelemetryConfig({ ...existing, enabled: false });
+  }
+  console.log("Telemetry disabled.");
+};
+var status = () => {
+  const config = getTelemetryConfig();
+  if (!config || !config.enabled) {
+    console.log("Telemetry is disabled.");
+  } else {
+    console.log("Telemetry is enabled.");
+    console.log(`Anonymous ID: ${config.anonymousId}`);
+  }
+};
+var telemetry = (args) => {
+  const subcommand = args[0];
+  if (subcommand === "enable") {
+    enable();
+  } else if (subcommand === "disable") {
+    disable();
+  } else if (subcommand === "status" || !subcommand) {
+    status();
+    if (!subcommand) {
+      console.log("");
+      console.log("Usage: absolute telemetry <command>");
+      console.log("Commands:");
+      console.log("  enable    Enable anonymous telemetry");
+      console.log("  disable   Disable telemetry");
+      console.log("  status    Show current telemetry status");
+    }
+  } else {
+    console.error(`Unknown telemetry command: ${subcommand}`);
+    console.error("Usage: absolute telemetry <enable|disable|status>");
+    process.exit(1);
+  }
+};
+
+// src/cli/telemetryEvent.ts
+var __dirname = "/home/alexkahn/abs/absolutejs/src/cli";
+var getVersion = () => {
+  try {
+    const pkgPath = resolve(__dirname, "../../package.json");
+    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+    return pkg.version;
+  } catch {
+    return "unknown";
+  }
+};
+var sendTelemetryEvent = (event, payload) => {
+  try {
+    const config = getTelemetryConfig();
+    if (!config?.enabled)
+      return;
+    const body = {
+      event,
+      anonymousId: config.anonymousId,
+      version: getVersion(),
+      os: platform(),
+      arch: arch(),
+      bunVersion: Bun.version,
+      timestamp: new Date().toISOString(),
+      payload
+    };
+    fetch("https://absolutejs.com/api/telemetry", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    }).catch(() => {});
+  } catch {}
+};
+
 // src/cli/utils.ts
 var {$ } = globalThis.Bun;
 import { execSync } from "child_process";
-import { existsSync, readFileSync } from "fs";
-import { resolve } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve2 } from "path";
 var isWSLEnvironment = () => {
   try {
-    const release = readFileSync("/proc/version", "utf-8");
+    const release = readFileSync3("/proc/version", "utf-8");
     return /microsoft|wsl/i.test(release);
   } catch {
     return false;
@@ -311,8 +422,8 @@ var isWSLEnvironment = () => {
 var COMPOSE_PATH = "db/docker-compose.db.yml";
 var DEFAULT_SERVER_ENTRY = "src/backend/server.ts";
 var readDbScripts = async () => {
-  const pkgPath = resolve("package.json");
-  if (!existsSync(pkgPath))
+  const pkgPath = resolve2("package.json");
+  if (!existsSync2(pkgPath))
     return null;
   const pkg = await Bun.file(pkgPath).json();
   const upCommand = pkg.scripts?.["db:up"];
@@ -380,7 +491,7 @@ var cliTag = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[cl
 var dev = async (serverEntry) => {
   const port = Number(env.PORT) || DEFAULT_PORT;
   killStaleProcesses(port);
-  const usesDocker = existsSync2(resolve2(COMPOSE_PATH));
+  const usesDocker = existsSync3(resolve3(COMPOSE_PATH));
   const scripts = usesDocker ? await readDbScripts() : null;
   if (scripts)
     await startDatabase(scripts);
@@ -428,10 +539,16 @@ var dev = async (serverEntry) => {
     return proc;
   };
   let serverProcess = spawnServer();
+  const sessionStart = Date.now();
+  sendTelemetryEvent("dev:start", { entry: serverEntry });
   const cleanup = async (exitCode = 0) => {
     if (cleaning)
       return;
     cleaning = true;
+    sendTelemetryEvent("dev:session-duration", {
+      duration: Math.round((Date.now() - sessionStart) / 1000),
+      entry: serverEntry
+    });
     if (interactive)
       interactive.dispose();
     if (paused)
@@ -484,9 +601,9 @@ var dev = async (serverEntry) => {
   };
   const openInBrowser = async () => {
     const url = `http://localhost:${port}`;
-    const { platform } = process;
-    const isWSL = platform === "linux" && isWSLEnvironment();
-    const cmd = isWSL ? "cmd.exe" : platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
+    const { platform: platform2 } = process;
+    const isWSL = platform2 === "linux" && isWSLEnvironment();
+    const cmd = isWSL ? "cmd.exe" : platform2 === "darwin" ? "open" : platform2 === "win32" ? "start" : "xdg-open";
     const args = isWSL ? ["/c", "start", url] : [url];
     try {
       Bun.spawn([cmd, ...args], {
@@ -529,6 +646,10 @@ var dev = async (serverEntry) => {
         return;
       }
       console.error(cliTag("\x1B[31m", `Server exited (code ${exitCode}), restarting...`));
+      sendTelemetryEvent("dev:server-crash", {
+        exitCode,
+        entry: serverEntry
+      });
       serverProcess = spawnServer();
     }
   };
@@ -537,7 +658,7 @@ var dev = async (serverEntry) => {
 
 // src/cli/cache.ts
 import { mkdir } from "fs/promises";
-import { join } from "path";
+import { join as join2 } from "path";
 var {Glob } = globalThis.Bun;
 var CACHE_DIR = ".absolutejs";
 var MAX_FILES_PER_BATCH = 200;
@@ -561,7 +682,7 @@ var hashConfigs = async (configFiles) => {
 };
 var loadCache = async (tool) => {
   try {
-    const path = join(CACHE_DIR, `${tool}.cache.json`);
+    const path = join2(CACHE_DIR, `${tool}.cache.json`);
     const data = await Bun.file(path).json();
     return data;
   } catch {
@@ -570,7 +691,7 @@ var loadCache = async (tool) => {
 };
 var saveCache = async (tool, data) => {
   await mkdir(CACHE_DIR, { recursive: true });
-  const path = join(CACHE_DIR, `${tool}.cache.json`);
+  const path = join2(CACHE_DIR, `${tool}.cache.json`);
   await Bun.write(path, JSON.stringify(data, null, "\t"));
 };
 var getChangedFiles = async (adapter) => {
@@ -663,6 +784,142 @@ var eslint = async (args) => {
   await runTool(eslintAdapter, args);
 };
 
+// src/cli/scripts/info.ts
+import { execSync as execSync2 } from "child_process";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { arch as arch2, cpus, platform as platform2, totalmem, version } from "os";
+import { resolve as resolve4 } from "path";
+var __dirname = "/home/alexkahn/abs/absolutejs/src/cli/scripts";
+var bold = (str) => `\x1B[1m${str}\x1B[0m`;
+var getBinaryVersion = (binary, flag = "--version") => {
+  try {
+    const raw = execSync2(`${binary} ${flag}`, {
+      encoding: "utf-8",
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const match = /(\d+\.\d+\.\d+[\w.-]*)/.exec(raw);
+    return match !== null ? match[1] : raw.replace(/^v/, "");
+  } catch {
+    return "N/A";
+  }
+};
+var getPackageVersion = (packageName) => {
+  try {
+    const pkgPath = __require.resolve(`${packageName}/package.json`, {
+      paths: [process.cwd()]
+    });
+    const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+    return pkg.version;
+  } catch {
+    return "N/A";
+  }
+};
+var getAbsoluteVersion = () => {
+  try {
+    const pkgPath = resolve4(__dirname, "../../../package.json");
+    const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+    return pkg.version;
+  } catch {
+    return getPackageVersion("@absolutejs/absolute");
+  }
+};
+var detectCI = () => {
+  const { env: env2 } = process;
+  if (env2.GITHUB_ACTIONS)
+    return "GitHub Actions";
+  if (env2.GITLAB_CI)
+    return "GitLab CI";
+  if (env2.CIRCLECI)
+    return "CircleCI";
+  if (env2.JENKINS_URL)
+    return "Jenkins";
+  if (env2.TRAVIS)
+    return "Travis CI";
+  if (env2.BUILDKITE)
+    return "Buildkite";
+  if (env2.CODEBUILD_BUILD_ID)
+    return "AWS CodeBuild";
+  if (env2.TF_BUILD)
+    return "Azure Pipelines";
+  if (env2.VERCEL)
+    return "Vercel";
+  if (env2.NETLIFY)
+    return "Netlify";
+  if (env2.CI)
+    return "Yes (unknown provider)";
+  return "No";
+};
+var isDockerEnvironment = () => {
+  try {
+    return existsSync4("/.dockerenv");
+  } catch {
+    return false;
+  }
+};
+var getMemoryMB = () => Math.round(totalmem() / 1024 / 1024);
+var getGlibcVersion = () => {
+  if (platform2() !== "linux")
+    return null;
+  try {
+    const output = execSync2("ldd --version 2>&1 || true", {
+      encoding: "utf-8",
+      timeout: 5000
+    });
+    const match = /(\d+\.\d+)/.exec(output);
+    return match !== null ? match[1] : "N/A";
+  } catch {
+    return "N/A";
+  }
+};
+var info = () => {
+  const lines = [];
+  const section = (title) => {
+    lines.push(`${bold(title)}`);
+  };
+  const field = (key, val) => {
+    lines.push(`  ${key}: ${val}`);
+  };
+  section("Operating System:");
+  field("Platform", platform2());
+  field("Arch", arch2());
+  field("Version", version());
+  field("Available memory (MB)", String(getMemoryMB()));
+  field("Available CPU cores", String(cpus().length));
+  const glibc = getGlibcVersion();
+  if (glibc)
+    field("glibc", glibc);
+  lines.push("");
+  section("Environment:");
+  field("WSL", isWSLEnvironment() ? "Yes" : "No");
+  field("Docker", isDockerEnvironment() ? "Yes" : "No");
+  field("CI", detectCI());
+  lines.push("");
+  section("Binaries:");
+  field("Bun", getBinaryVersion("bun"));
+  field("Node", getBinaryVersion("node"));
+  field("npm", getBinaryVersion("npm"));
+  field("Yarn", getBinaryVersion("yarn"));
+  field("pnpm", getBinaryVersion("pnpm"));
+  field("Docker", getBinaryVersion("docker", "--version"));
+  field("docker-compose", getBinaryVersion("docker-compose", "--version"));
+  lines.push("");
+  section("Relevant Packages:");
+  field("@absolutejs/absolute", getAbsoluteVersion());
+  field("elysia", getPackageVersion("elysia"));
+  field("react", getPackageVersion("react"));
+  field("react-dom", getPackageVersion("react-dom"));
+  field("svelte", getPackageVersion("svelte"));
+  field("vue", getPackageVersion("vue"));
+  field("typescript", getPackageVersion("typescript"));
+  field("tailwindcss", getPackageVersion("tailwindcss"));
+  field("@tailwindcss/cli", getPackageVersion("@tailwindcss/cli"));
+  lines.push("");
+  console.log("");
+  console.log(lines.join(`
+`));
+};
+
 // src/cli/scripts/prettier.ts
 var prettierAdapter = {
   name: "prettier",
@@ -695,19 +952,30 @@ var prettier = async (args) => {
 var command = process.argv[2];
 var args = process.argv.slice(3);
 if (command === "dev") {
+  sendTelemetryEvent("cli:command", { command });
   const serverEntry = args[0] ?? DEFAULT_SERVER_ENTRY;
   await dev(serverEntry);
 } else if (command === "eslint") {
+  sendTelemetryEvent("cli:command", { command });
   await eslint(args);
 } else if (command === "prettier") {
+  sendTelemetryEvent("cli:command", { command });
   await prettier(args);
+} else if (command === "info") {
+  sendTelemetryEvent("cli:command", { command });
+  info();
+} else if (command === "telemetry") {
+  sendTelemetryEvent("cli:command", { command });
+  telemetry(args);
 } else {
   const message = command ? `Unknown command: ${command}` : "No command specified";
   console.error(message);
-  console.error("Usage: absolutejs <command>");
+  console.error("Usage: absolute <command>");
   console.error("Commands:");
   console.error("  dev [entry]   Start development server");
   console.error("  eslint        Run ESLint (cached)");
+  console.error("  info          Print system info for bug reports");
   console.error("  prettier      Run Prettier check (cached)");
+  console.error("  telemetry     Manage anonymous telemetry");
   process.exit(1);
 }