@farm.js/create-app 0.1.0-beta.36 → 0.1.0-beta.38

package/bin/create-farm-app.js

@@ -19,7 +19,7 @@ program
   .option("--skip-install", "Skip installing dependencies")
   .action(async (projectName, options) => {
     try {
-      await createApp(projectName, options);
+      await createApp(projectName, { ...options, telemetryPackageVersion: version });
     } catch (error) {
       console.error("Failed to create app:", error);
       process.exit(1);

package/dist/index.js

@@ -12,6 +12,9 @@ let node_fs = require("node:fs");
 let node_fs_promises = require("node:fs/promises");
 let node_path = require("node:path");
 node_path = require_rolldown_runtime.__toESM(node_path);
+let node_crypto = require("node:crypto");
+let node_os = require("node:os");
+node_os = require_rolldown_runtime.__toESM(node_os);
 //#region ../farm-cli/src/ui-feature-registry.ts
 async function installUIFeature(input) {
 	const feature = input.definition.ui;
@@ -2526,6 +2529,269 @@ function escapeRegExp(input) {
 	return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 //#endregion
+//#region ../farm-cli/src/telemetry.ts
+const TELEMETRY_SCHEMA_VERSION = 1;
+const DEFAULT_TELEMETRY_ENDPOINT = "https://farmjs.dev/api/telemetry/v1/events";
+const TELEMETRY_NOTICE_URL = "https://farmjs.dev/docs/telemetry";
+const REQUEST_TIMEOUT_MS = 750;
+const FARM_TEMPLATES = [
+	"basic",
+	"react-compiler",
+	"auth",
+	"better-auth",
+	"ai",
+	"auth0",
+	"authjs",
+	"autumn",
+	"clerk",
+	"jobs-inngest",
+	"jobs-trigger",
+	"polar",
+	"resend",
+	"stripe",
+	"supabase",
+	"unkey",
+	"workos"
+];
+const RENDERERS = [
+	"react",
+	"preact",
+	"solid",
+	"vue",
+	"svelte"
+];
+const PACKAGE_MANAGERS = [
+	"npm",
+	"pnpm",
+	"yarn",
+	"bun"
+];
+function defaultConfig() {
+	return {
+		version: TELEMETRY_SCHEMA_VERSION,
+		enabled: false,
+		noticeShown: false
+	};
+}
+function configDirectory() {
+	if (process.env.FARM_TELEMETRY_CONFIG_DIR) return node_path.default.resolve(process.env.FARM_TELEMETRY_CONFIG_DIR);
+	if (process.platform === "win32") return node_path.default.join(process.env.APPDATA || node_path.default.join(node_os.default.homedir(), "AppData", "Roaming"), "farmjs");
+	if (process.platform === "darwin") return node_path.default.join(node_os.default.homedir(), "Library", "Application Support", "farmjs");
+	return node_path.default.join(process.env.XDG_CONFIG_HOME || node_path.default.join(node_os.default.homedir(), ".config"), "farmjs");
+}
+function getFarmTelemetryConfigFile() {
+	return node_path.default.join(configDirectory(), "telemetry.json");
+}
+async function readConfig() {
+	try {
+		const parsed = JSON.parse(await (0, node_fs_promises.readFile)(getFarmTelemetryConfigFile(), "utf8"));
+		if (parsed.version !== TELEMETRY_SCHEMA_VERSION) return defaultConfig();
+		return {
+			version: TELEMETRY_SCHEMA_VERSION,
+			enabled: parsed.enabled === true,
+			noticeShown: parsed.noticeShown === true,
+			anonymousId: isUuid(parsed.anonymousId) ? parsed.anonymousId : void 0
+		};
+	} catch {
+		return defaultConfig();
+	}
+}
+async function writeConfig(config) {
+	const file = getFarmTelemetryConfigFile();
+	const directory = node_path.default.dirname(file);
+	const temporaryFile = `${file}.${process.pid}.${(0, node_crypto.randomUUID)()}.tmp`;
+	try {
+		await (0, node_fs_promises.mkdir)(directory, {
+			recursive: true,
+			mode: 448
+		});
+		await (0, node_fs_promises.writeFile)(temporaryFile, `${JSON.stringify(config, null, 2)}\n`, { mode: 384 });
+		await (0, node_fs_promises.rename)(temporaryFile, file);
+		await (0, node_fs_promises.chmod)(file, 384).catch(() => void 0);
+	} catch {
+		await (0, node_fs_promises.unlink)(temporaryFile).catch(() => void 0);
+	}
+}
+function isUuid(value) {
+	return typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+}
+function isTrue(value) {
+	return value !== void 0 && [
+		"1",
+		"true",
+		"yes",
+		"on"
+	].includes(value.toLowerCase());
+}
+function isFalse(value) {
+	return value !== void 0 && [
+		"0",
+		"false",
+		"no",
+		"off"
+	].includes(value.toLowerCase());
+}
+function environmentDecision() {
+	if (process.env.DO_NOT_TRACK !== void 0 && !isFalse(process.env.DO_NOT_TRACK)) return {
+		enabled: false,
+		reason: "DO_NOT_TRACK is set"
+	};
+	if (isTrue(process.env.FARM_TELEMETRY_DISABLED)) return {
+		enabled: false,
+		reason: "FARM_TELEMETRY_DISABLED is set"
+	};
+	if (isTrue(process.env.FARM_TELEMETRY)) return { enabled: true };
+	if (isFalse(process.env.FARM_TELEMETRY)) return {
+		enabled: false,
+		reason: "FARM_TELEMETRY disables collection"
+	};
+	return {};
+}
+function isContinuousIntegration() {
+	return isTrue(process.env.CI) || isTrue(process.env.GITHUB_ACTIONS) || isTrue(process.env.BUILDKITE) || isTrue(process.env.CIRCLECI);
+}
+function isInteractive() {
+	return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+function getEndpoint() {
+	const candidate = process.env.FARM_TELEMETRY_ENDPOINT || DEFAULT_TELEMETRY_ENDPOINT;
+	try {
+		const url = new URL(candidate);
+		const isLocal = [
+			"localhost",
+			"127.0.0.1",
+			"::1"
+		].includes(url.hostname);
+		if (url.protocol !== "https:" && !(url.protocol === "http:" && isLocal)) return DEFAULT_TELEMETRY_ENDPOINT;
+		return url.toString();
+	} catch {
+		return DEFAULT_TELEMETRY_ENDPOINT;
+	}
+}
+async function resolveState() {
+	const config = await readConfig();
+	const environment = environmentDecision();
+	const enabled = environment.enabled ?? config.enabled;
+	const source = environment.enabled !== void 0 ? "environment" : config.enabled ? "configuration" : "default";
+	if (!enabled) return {
+		config,
+		enabled,
+		active: false,
+		source,
+		reason: environment.reason
+	};
+	if (environment.enabled === true) return {
+		config,
+		enabled,
+		active: true,
+		source
+	};
+	if (process.env.NODE_ENV === "test") return {
+		config,
+		enabled,
+		active: false,
+		source,
+		reason: "test environments are skipped"
+	};
+	if (isContinuousIntegration()) return {
+		config,
+		enabled,
+		active: false,
+		source,
+		reason: "CI environments are skipped"
+	};
+	if (!isInteractive()) return {
+		config,
+		enabled,
+		active: false,
+		source,
+		reason: "non-interactive commands are skipped"
+	};
+	return {
+		config,
+		enabled,
+		active: true,
+		source
+	};
+}
+async function showFarmTelemetryNotice() {
+	if (!isInteractive() || isContinuousIntegration() || process.env.NODE_ENV === "test") return;
+	if (environmentDecision().enabled !== void 0) return;
+	const config = await readConfig();
+	if (config.noticeShown) return;
+	process.stderr.write(`Farm.js anonymous telemetry is off during beta. Run "farm telemetry enable" to opt in.\nLearn more: ${TELEMETRY_NOTICE_URL}\n`);
+	await writeConfig({
+		...config,
+		noticeShown: true
+	});
+}
+async function trackFarmProjectCreated(input) {
+	const template = allowlisted(input.template, FARM_TEMPLATES);
+	const renderer = allowlisted(input.renderer, RENDERERS);
+	const packageManager = allowlisted(input.packageManager, PACKAGE_MANAGERS);
+	await track({
+		eventType: "project_created",
+		source: "create-app",
+		packageName: "@farm.js/create-app",
+		packageVersion: sanitizeVersion(input.packageVersion),
+		...template ? { template } : {},
+		...renderer ? { renderer } : {},
+		...packageManager ? { packageManager } : {},
+		...typeof input.typescript === "boolean" ? { typescript: input.typescript } : {},
+		...typeof input.installedDependencies === "boolean" ? { installedDependencies: input.installedDependencies } : {}
+	});
+}
+async function track(event) {
+	try {
+		const state = await resolveState();
+		if (!state.active) return;
+		const anonymousId = state.config.anonymousId || (0, node_crypto.randomUUID)();
+		if (!state.config.anonymousId) await writeConfig({
+			...state.config,
+			anonymousId
+		});
+		await send({
+			schemaVersion: TELEMETRY_SCHEMA_VERSION,
+			eventId: (0, node_crypto.randomUUID)(),
+			anonymousId,
+			nodeMajor: Number.parseInt(process.versions.node.split(".")[0] || "0", 10),
+			platform: normalizePlatform(process.platform),
+			architecture: normalizeArchitecture(process.arch),
+			...event
+		});
+	} catch {}
+}
+async function send(payload) {
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+	timeout.unref?.();
+	try {
+		await fetch(getEndpoint(), {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify(payload),
+			signal: controller.signal,
+			keepalive: true
+		});
+	} catch {} finally {
+		clearTimeout(timeout);
+	}
+}
+function sanitizeVersion(value) {
+	return /^[0-9A-Za-z.+_-]{1,64}$/.test(value) ? value : "unknown";
+}
+function allowlisted(value, values) {
+	return value && values.includes(value) ? value : void 0;
+}
+function normalizePlatform(value) {
+	if (value === "darwin" || value === "linux") return value;
+	if (value === "win32") return "windows";
+	return "other";
+}
+function normalizeArchitecture(value) {
+	return value === "arm64" || value === "x64" ? value : "other";
+}
+//#endregion
 //#region src/index.ts
 const templateDetails = {
 	basic: {
@@ -2668,6 +2934,7 @@ function integrationTemplate(input) {
 }
 async function createApp(projectName, options = {}) {
 	require_utils.showBanner();
+	await showFarmTelemetryNotice();
 	const templates = await getAvailableTemplates();
 	if (templates.length === 0) {
 		require_utils.logger.error("No templates are available in this package.");
@@ -2826,6 +3093,14 @@ async function createApp(projectName, options = {}) {
 		if (integrationResult.env.length) require_utils.logger.info("Copy .env.example to .env.local and add your provider credentials.");
 		for (const note of integrationResult.notes) require_utils.logger.info(note);
 	}
+	await trackFarmProjectCreated({
+		packageVersion: options.telemetryPackageVersion ?? "unknown",
+		template,
+		renderer,
+		packageManager: packageManager.name,
+		typescript: useTypeScript,
+		installedDependencies: !options.skipInstall
+	});
 }
 async function copyTemplate(template, projectPath, useTypeScript, renderer) {
 	const details = templateDetails[template];
@@ -3011,9 +3286,9 @@ async function copyDir(src, dest) {
 		else await fs_promises.default.copyFile(srcPath, destPath);
 	}
 }
-async function dirExists(path$4) {
+async function dirExists(path$5) {
 	try {
-		return (await fs_promises.default.stat(path$4)).isDirectory();
+		return (await fs_promises.default.stat(path$5)).isDirectory();
 	} catch {
 		return false;
 	}