@prisma-next/cli-telemetry 0.10.0 → 0.11.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [2026] [Prisma Data, Inc]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/dist/enrich-CGZ8Za8Y.mjs

@@ -0,0 +1,214 @@
+import { readFileSync } from "node:fs";
+import { join } from "pathe";
+//#region src/detect-agent.ts
+const AGENT_MARKERS = [
+	{
+		envVar: "CLAUDECODE",
+		agent: "Claude Code"
+	},
+	{
+		envVar: "CURSOR_AGENT",
+		agent: "Cursor"
+	},
+	{
+		envVar: "CODEX_SANDBOX",
+		agent: "Codex CLI"
+	},
+	{
+		envVar: "GEMINI_CLI",
+		agent: "Gemini CLI"
+	},
+	{
+		envVar: "WINDSURF",
+		agent: "Windsurf"
+	},
+	{
+		envVar: "AIDER",
+		agent: "Aider"
+	},
+	{
+		envVar: "CODY",
+		agent: "Cody"
+	},
+	{
+		envVar: "CONTINUE",
+		agent: "Continue"
+	}
+];
+function isTruthyMarker(raw) {
+	if (raw === void 0) return false;
+	const normalised = raw.trim().toLowerCase();
+	if (normalised === "") return false;
+	if (normalised === "0") return false;
+	if (normalised === "false") return false;
+	return true;
+}
+/**
+* Resolve the agent label from an env snapshot, or `null` if no marker
+* is set. Returns the **first** matching marker in `AGENT_MARKERS`
+* order, so when multiple markers are set the agent label is
+* deterministic and the allowlist's first entry wins.
+*
+* Pure: takes an env record, returns a string or null. No I/O.
+*/
+function detectAgent(env) {
+	for (const marker of AGENT_MARKERS) if (isTruthyMarker(env[marker.envVar])) return marker.agent;
+	return null;
+}
+//#endregion
+//#region src/enrich.ts
+const EMPTY_PROJECT_CONFIG = {
+	databaseTarget: null,
+	extensions: []
+};
+/**
+* Best-effort load of `prisma-next.config.*` from `projectRoot`,
+* validated against the canonical `@prisma-next/config` schema.
+* Returns `{ databaseTarget: null, extensions: [] }` on any failure
+* mode — missing config file (e.g. before `prisma-next init`), c12
+* throws while evaluating user TS, validator rejects a malformed
+* shape, etc. Telemetry is non-blocking and best-effort; an empty
+* result is the only downside of an unloadable or invalid config.
+*
+* Both `c12` and `@prisma-next/config/config-validation` are imported
+* lazily so the detached sender's cold-start cost is paid only when
+* telemetry actually fires, not on every fork even when gates
+* short-circuit before reaching this code path.
+*/
+async function loadProjectConfig(projectRoot) {
+	try {
+		const { loadConfig } = await import("c12");
+		const config = (await loadConfig({
+			name: "prisma-next",
+			cwd: projectRoot,
+			dotenv: false,
+			rcFile: false,
+			globalRc: false
+		})).config ?? null;
+		if (config === null || Object.keys(config).length === 0) return EMPTY_PROJECT_CONFIG;
+		const validate = (await import("@prisma-next/config/config-validation")).validateConfig;
+		validate(config);
+		return {
+			databaseTarget: config.target.targetId,
+			extensions: (config.extensionPacks ?? []).map((pack) => pack.id)
+		};
+	} catch {
+		return EMPTY_PROJECT_CONFIG;
+	}
+}
+/**
+* Identify the runtime the sender is running in. Same-runtime as the
+* parent is a correctness requirement: the parent forked us via
+* `child_process.fork`, which inherits the parent's runtime. Detection
+* keys on the runtime-specific version field rather than env vars so a
+* spoofed env can't lie about the actual interpreter.
+*/
+function resolveRuntime(versions) {
+	if (versions.bun !== void 0) return {
+		name: "bun",
+		version: versions.bun
+	};
+	if (versions.deno !== void 0) return {
+		name: "deno",
+		version: versions.deno
+	};
+	return {
+		name: "node",
+		version: versions.node
+	};
+}
+/**
+* Parse `npm_config_user_agent` into a `<pm>/<version>` token. The
+* value, when present, looks like
+* `"pnpm/10.27.0 npm/? node/v24.13.0 darwin arm64"` — we take the first
+* whitespace-separated token. Any failure → `null`.
+*/
+function parsePackageManager(userAgent) {
+	if (userAgent === void 0) return null;
+	const first = userAgent.split(/\s+/)[0];
+	if (first === void 0 || first.length === 0) return null;
+	if (!first.includes("/")) return null;
+	return first;
+}
+/**
+* Read the user's project `package.json` and resolve a TypeScript
+* version from `devDependencies.typescript` (preferred) or
+* `dependencies.typescript`. Strips a leading `^` or `~` semver
+* prefix. Returns `null` on any failure mode — file missing,
+* unreadable, malformed JSON, key absent, not a string.
+*/
+function readTsVersionFromPackageJson(raw) {
+	if (raw === null) return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return null;
+	}
+	const candidate = pickStringDep(parsed["devDependencies"]) ?? pickStringDep(parsed["dependencies"]);
+	if (candidate === null) return null;
+	return candidate.replace(/^[\^~]/, "");
+}
+function pickStringDep(deps) {
+	if (deps === null || typeof deps !== "object" || Array.isArray(deps)) return null;
+	const value = deps["typescript"];
+	return typeof value === "string" ? value : null;
+}
+/**
+* Build the full backend event from the parent's payload, the
+* c12-loaded project-config slice, and the child's per-process
+* snapshot. Pure given a `projectConfig` + `EnrichEnvironment`.
+*/
+function buildTelemetryEvent(payload, projectConfig, env) {
+	const runtime = resolveRuntime(env.versions);
+	return {
+		installationId: payload.installationId,
+		version: payload.version,
+		command: payload.command,
+		flags: payload.flags,
+		runtimeName: runtime.name,
+		runtimeVersion: runtime.version,
+		os: env.platform,
+		arch: env.arch,
+		packageManager: parsePackageManager(env.env["npm_config_user_agent"]),
+		databaseTarget: projectConfig.databaseTarget,
+		tsVersion: readTsVersionFromPackageJson(env.readProjectPackageJson()),
+		agent: detectAgent(env.env),
+		extensions: projectConfig.extensions
+	};
+}
+/**
+* Convenience for the sender entry: build the event from the live
+* `process` plus a c12 load of `prisma-next.config.*` from
+* `payload.projectRoot` plus a real project-package.json reader,
+* swallowing any I/O errors in the file read.
+*
+* The parent's `payload.databaseTarget` (when present) wins over the
+* c12-derived value. The parent sets this for the first-`init` run,
+* where the config file does not exist on disk yet but the user has
+* just declared a target via the consent prompt; every other
+* invocation leaves it unset and the c12 load supplies the value.
+*/
+async function buildTelemetryEventFromProcess(payload) {
+	const loadedConfig = await loadProjectConfig(payload.projectRoot);
+	return buildTelemetryEvent(payload, {
+		databaseTarget: payload.databaseTarget ?? loadedConfig.databaseTarget,
+		extensions: loadedConfig.extensions
+	}, {
+		platform: process.platform,
+		arch: process.arch,
+		versions: process.versions,
+		env: process.env,
+		readProjectPackageJson: () => {
+			try {
+				return readFileSync(join(payload.projectRoot, "package.json"), "utf-8");
+			} catch {
+				return null;
+			}
+		}
+	});
+}
+//#endregion
+export { loadProjectConfig as n, buildTelemetryEventFromProcess as t };
+
+//# sourceMappingURL=enrich-CGZ8Za8Y.mjs.map

package/dist/enrich-CGZ8Za8Y.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"enrich-CGZ8Za8Y.mjs","names":[],"sources":["../src/detect-agent.ts","../src/enrich.ts"],"sourcesContent":["/**\n * Best-effort identification of AI coding-agent sessions from an\n * env-var allowlist. Detector property: false positives are negligible\n * (a marker present ⇒ confidently an agent); false negatives are\n * expected and documented in the user-facing telemetry docs. New\n * entries should land here, not in per-CLI hand-rolls.\n *\n * Each entry is a `(envVar, agent)` pair with uniform comparison shape:\n * the marker counts as \"present\" when `process.env[envVar]` is set to a\n * truthy string. Truthy = anything other than the empty string, `'0'`,\n * or `'false'` (case-insensitive); see `gating.isTruthyOptOut` for the\n * same convention applied to opt-out env vars.\n *\n * The detector runs in the **child** sender process, never the parent;\n * the parent does not probe env at command start.\n *\n * Codex CLI note: `CODEX_SANDBOX` is the only clear marker available here.\n * Non-sandboxed Codex sessions may be false negatives.\n *\n * TODO: a ci-info-for-agents would be nice — this allowlist drifts the\n * moment a new agent ships its env marker, and consolidating with the\n * other ecosystems that need the same lookup (rate-limited LLM\n * gateways, agent-aware metrics, etc.) would let one library carry the\n * matrix instead of every consumer re-doing it.\n */\nexport interface AgentMarker {\n  /** The env-var name to read. Exact-match; no prefix or fuzzy logic. */\n  readonly envVar: string;\n  /** The agent label written to the `agent` field of the telemetry event. */\n  readonly agent: string;\n}\n\nexport const AGENT_MARKERS: readonly AgentMarker[] = [\n  { envVar: 'CLAUDECODE', agent: 'Claude Code' },\n  { envVar: 'CURSOR_AGENT', agent: 'Cursor' },\n  { envVar: 'CODEX_SANDBOX', agent: 'Codex CLI' },\n  { envVar: 'GEMINI_CLI', agent: 'Gemini CLI' },\n  { envVar: 'WINDSURF', agent: 'Windsurf' },\n  { envVar: 'AIDER', agent: 'Aider' },\n  { envVar: 'CODY', agent: 'Cody' },\n  { envVar: 'CONTINUE', agent: 'Continue' },\n];\n\nfunction isTruthyMarker(raw: string | undefined): boolean {\n  if (raw === undefined) return false;\n  const normalised = raw.trim().toLowerCase();\n  if (normalised === '') return false;\n  if (normalised === '0') return false;\n  if (normalised === 'false') return false;\n  return true;\n}\n\n/**\n * Resolve the agent label from an env snapshot, or `null` if no marker\n * is set. Returns the **first** matching marker in `AGENT_MARKERS`\n * order, so when multiple markers are set the agent label is\n * deterministic and the allowlist's first entry wins.\n *\n * Pure: takes an env record, returns a string or null. No I/O.\n */\nexport function detectAgent(env: Readonly<Record<string, string | undefined>>): string | null {\n  for (const marker of AGENT_MARKERS) {\n    if (isTruthyMarker(env[marker.envVar])) {\n      return marker.agent;\n    }\n  }\n  return null;\n}\n","import { readFileSync } from 'node:fs';\nimport type { PrismaNextConfig } from '@prisma-next/config/config-types';\nimport { join } from 'pathe';\nimport { detectAgent } from './detect-agent';\nimport type { ParentToSenderPayload, TelemetryEvent } from './payload';\n\n/**\n * Subset of the user's `prisma-next.config.*` the telemetry event\n * surfaces. Loaded inside the detached child via {@link loadProjectConfig}\n * — see the design rationale on {@link ParentToSenderPayload} for why\n * this side runs c12 instead of the parent CLI.\n */\nexport interface ProjectConfigFields {\n  readonly databaseTarget: string | null;\n  readonly extensions: readonly string[];\n}\n\nconst EMPTY_PROJECT_CONFIG: ProjectConfigFields = {\n  databaseTarget: null,\n  extensions: [],\n};\n\n/**\n * Best-effort load of `prisma-next.config.*` from `projectRoot`,\n * validated against the canonical `@prisma-next/config` schema.\n * Returns `{ databaseTarget: null, extensions: [] }` on any failure\n * mode — missing config file (e.g. before `prisma-next init`), c12\n * throws while evaluating user TS, validator rejects a malformed\n * shape, etc. Telemetry is non-blocking and best-effort; an empty\n * result is the only downside of an unloadable or invalid config.\n *\n * Both `c12` and `@prisma-next/config/config-validation` are imported\n * lazily so the detached sender's cold-start cost is paid only when\n * telemetry actually fires, not on every fork even when gates\n * short-circuit before reaching this code path.\n */\nexport async function loadProjectConfig(projectRoot: string): Promise<ProjectConfigFields> {\n  try {\n    const { loadConfig } = await import('c12');\n    const result = await loadConfig<Record<string, unknown>>({\n      name: 'prisma-next',\n      cwd: projectRoot,\n      dotenv: false,\n      rcFile: false,\n      globalRc: false,\n    });\n    const config = result.config ?? null;\n    // c12 returns an empty object when no config file exists in the\n    // search path — distinct from \"file existed but parsed to an empty\n    // object\". Either way, the canonical validator below would reject\n    // it on the first required field (`family`), so short-circuit\n    // without paying the import cost.\n    if (config === null || Object.keys(config).length === 0) {\n      return EMPTY_PROJECT_CONFIG;\n    }\n    const validation = await import('@prisma-next/config/config-validation');\n    // TS 4.7+ only flows `asserts cfg is X` narrowing when the\n    // assertion function is called via a directly-declared name with\n    // an explicit signature. The dynamic-import binding doesn't\n    // satisfy that, so wrap the call in a local declaration that\n    // re-asserts the signature.\n    const validate: (cfg: unknown) => asserts cfg is PrismaNextConfig = validation.validateConfig;\n    validate(config);\n    return {\n      databaseTarget: config.target.targetId,\n      extensions: (config.extensionPacks ?? []).map((pack) => pack.id),\n    };\n  } catch {\n    return EMPTY_PROJECT_CONFIG;\n  }\n}\n\n/**\n * Versions surface the enrichment cares about. Modelled as a structural\n * record with a required `node` field so tests can pass a literal object\n * without faking every field of `NodeJS.ProcessVersions` (which adds\n * properties between Node versions and includes a long tail the\n * enrichment never touches). Both `bun` and `deno` are read on the\n * runtime-resolution path; everything else is ignored.\n */\nexport interface VersionsSnapshot {\n  readonly node: string;\n  readonly bun?: string;\n  readonly deno?: string;\n}\n\n/**\n * Snapshot of process-level inputs the enrichment reads. Tests pass an\n * explicit snapshot so the enrichment is deterministic per case; the\n * sender entry point passes a fresh snapshot from `process`.\n */\nexport interface EnrichEnvironment {\n  readonly platform: NodeJS.Platform;\n  readonly arch: string;\n  readonly versions: VersionsSnapshot;\n  /**\n   * Included because package-manager and agent detection intentionally read\n   * environment variables from the same process snapshot as platform/versions.\n   */\n  readonly env: Readonly<Record<string, string | undefined>>;\n  /**\n   * Best-effort reader for the project's `package.json`, used only to derive\n   * the optional `tsVersion` telemetry field. Returning `null` means unknown.\n   */\n  readonly readProjectPackageJson: () => string | null;\n}\n\n/**\n * Identify the runtime the sender is running in. Same-runtime as the\n * parent is a correctness requirement: the parent forked us via\n * `child_process.fork`, which inherits the parent's runtime. Detection\n * keys on the runtime-specific version field rather than env vars so a\n * spoofed env can't lie about the actual interpreter.\n */\nfunction resolveRuntime(versions: VersionsSnapshot): {\n  readonly name: 'node' | 'bun' | 'deno';\n  readonly version: string;\n} {\n  if (versions.bun !== undefined) {\n    return { name: 'bun', version: versions.bun };\n  }\n  if (versions.deno !== undefined) {\n    return { name: 'deno', version: versions.deno };\n  }\n  return { name: 'node', version: versions.node };\n}\n\n/**\n * Parse `npm_config_user_agent` into a `<pm>/<version>` token. The\n * value, when present, looks like\n * `\"pnpm/10.27.0 npm/? node/v24.13.0 darwin arm64\"` — we take the first\n * whitespace-separated token. Any failure → `null`.\n */\nexport function parsePackageManager(userAgent: string | undefined): string | null {\n  if (userAgent === undefined) return null;\n  const first = userAgent.split(/\\s+/)[0];\n  if (first === undefined || first.length === 0) return null;\n  if (!first.includes('/')) return null;\n  return first;\n}\n\n/**\n * Read the user's project `package.json` and resolve a TypeScript\n * version from `devDependencies.typescript` (preferred) or\n * `dependencies.typescript`. Strips a leading `^` or `~` semver\n * prefix. Returns `null` on any failure mode — file missing,\n * unreadable, malformed JSON, key absent, not a string.\n */\nexport function readTsVersionFromPackageJson(raw: string | null): string | null {\n  if (raw === null) return null;\n  let parsed: Record<string, unknown>;\n  try {\n    parsed = JSON.parse(raw) as Record<string, unknown>;\n  } catch {\n    return null;\n  }\n  const candidate =\n    pickStringDep(parsed['devDependencies']) ?? pickStringDep(parsed['dependencies']);\n  if (candidate === null) return null;\n  return candidate.replace(/^[\\^~]/, '');\n}\n\nfunction pickStringDep(deps: unknown): string | null {\n  if (deps === null || typeof deps !== 'object' || Array.isArray(deps)) return null;\n  const value = (deps as Record<string, unknown>)['typescript'];\n  return typeof value === 'string' ? value : null;\n}\n\n/**\n * Build the full backend event from the parent's payload, the\n * c12-loaded project-config slice, and the child's per-process\n * snapshot. Pure given a `projectConfig` + `EnrichEnvironment`.\n */\nexport function buildTelemetryEvent(\n  payload: ParentToSenderPayload,\n  projectConfig: ProjectConfigFields,\n  env: EnrichEnvironment,\n): TelemetryEvent {\n  const runtime = resolveRuntime(env.versions);\n  return {\n    installationId: payload.installationId,\n    version: payload.version,\n    command: payload.command,\n    flags: payload.flags,\n    runtimeName: runtime.name,\n    runtimeVersion: runtime.version,\n    os: env.platform,\n    arch: env.arch,\n    packageManager: parsePackageManager(env.env['npm_config_user_agent']),\n    databaseTarget: projectConfig.databaseTarget,\n    tsVersion: readTsVersionFromPackageJson(env.readProjectPackageJson()),\n    agent: detectAgent(env.env),\n    extensions: projectConfig.extensions,\n  };\n}\n\n/**\n * Convenience for the sender entry: build the event from the live\n * `process` plus a c12 load of `prisma-next.config.*` from\n * `payload.projectRoot` plus a real project-package.json reader,\n * swallowing any I/O errors in the file read.\n *\n * The parent's `payload.databaseTarget` (when present) wins over the\n * c12-derived value. The parent sets this for the first-`init` run,\n * where the config file does not exist on disk yet but the user has\n * just declared a target via the consent prompt; every other\n * invocation leaves it unset and the c12 load supplies the value.\n */\nexport async function buildTelemetryEventFromProcess(\n  payload: ParentToSenderPayload,\n): Promise<TelemetryEvent> {\n  const loadedConfig = await loadProjectConfig(payload.projectRoot);\n  const projectConfig: ProjectConfigFields = {\n    databaseTarget: payload.databaseTarget ?? loadedConfig.databaseTarget,\n    extensions: loadedConfig.extensions,\n  };\n  return buildTelemetryEvent(payload, projectConfig, {\n    platform: process.platform,\n    arch: process.arch,\n    versions: process.versions,\n    env: process.env,\n    readProjectPackageJson: () => {\n      try {\n        return readFileSync(join(payload.projectRoot, 'package.json'), 'utf-8');\n      } catch {\n        return null;\n      }\n    },\n  });\n}\n"],"mappings":"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"}

package/dist/exports/index.d.mts

@@ -21,6 +21,109 @@ declare const TELEMETRY_ENDPOINT_PATH = "/events";
  */
 declare function resolveTelemetryEndpoint(env?: Readonly<Record<string, string | undefined>>): string;
 //#endregion
+//#region src/payload.d.ts
+/**
+ * Wire-shape payload the parent IPC-sends to the forked child sender.
+ * Mirrors only the fields the parent has naturally in hand at command
+ * start: installation id, sanitised command + flags, CLI version, and
+ * the project root the child uses to discover everything else. The
+ * child probes its own process (runtime/os/arch, package manager, ts
+ * version, agent) and reads the user's `prisma-next.config.*` via
+ * c12 to derive `databaseTarget` and `extensions`.
+ *
+ * Loading c12 on the parent side would put a `loadConfig()` await on
+ * the command's hot path between gate resolution and `fork()`,
+ * opening a race against any CLI command that throws synchronously
+ * before that await resolves (the parent exits before forking the
+ * sender, and the telemetry event is lost). Moving the load into the
+ * detached child eliminates that race; the trade is that the child
+ * now evaluates user TS config code, so it's gated behind the same
+ * privacy checks the parent already resolved before forking.
+ *
+ * `databaseTarget` is an optional parent-side override for the
+ * c12-derived value: the first-`init` invocation supplies the
+ * prompt-chosen target via this field because the config file does
+ * not yet exist on disk at that moment. Every other invocation
+ * leaves it unset (`undefined`) and the child's c12 load determines
+ * the value — there is no third state, so the field's type is
+ * `string | undefined`, not `string | null | undefined`.
+ *
+ * Both sides version-couple on this shape because the IPC carrier is
+ * structured-cloned by Node and there's no on-wire compat to maintain.
+ */
+interface ParentToSenderPayload {
+  readonly installationId: string;
+  readonly version: string;
+  readonly command: string;
+  readonly flags: readonly string[];
+  /**
+   * Absolute path of the user's project. The child reads
+   * `<projectRoot>/package.json` for `tsVersion` and loads
+   * `<projectRoot>/prisma-next.config.*` via c12 for `databaseTarget`
+   * + `extensions`.
+   */
+  readonly projectRoot: string;
+  /** Resolved endpoint URL (already includes the `/events` path). */
+  readonly endpoint: string;
+  /**
+   * Optional parent-side override for the c12-derived database target.
+   * Set by `fireTelemetryAfterInitConsent` (the first-`init` path,
+   * where the config file is about to be written but doesn't exist
+   * yet); left undefined by `fireTelemetryFromPreAction` (steady
+   * state, child resolves the value via c12). The wire-format
+   * `TelemetryEvent.databaseTarget: string | null` keeps `null` as
+   * the on-the-wire "no target known" marker, but the IPC override
+   * channel only needs two states so it's `string | undefined`.
+   */
+  readonly databaseTarget?: string;
+}
+/**
+ * The full event the child POSTs to the backend. Shape matches the
+ * backend's arktype schema (`apps/telemetry-backend/src/schema.ts`).
+ */
+interface TelemetryEvent {
+  readonly installationId: string;
+  readonly version: string;
+  readonly command: string;
+  readonly flags: readonly string[];
+  readonly runtimeName: string;
+  readonly runtimeVersion: string;
+  readonly os: string;
+  readonly arch: string;
+  readonly packageManager: string | null;
+  readonly databaseTarget: string | null;
+  readonly tsVersion: string | null;
+  readonly agent: string | null;
+  readonly extensions: readonly string[];
+}
+//#endregion
+//#region src/enrich.d.ts
+/**
+ * Subset of the user's `prisma-next.config.*` the telemetry event
+ * surfaces. Loaded inside the detached child via {@link loadProjectConfig}
+ * — see the design rationale on {@link ParentToSenderPayload} for why
+ * this side runs c12 instead of the parent CLI.
+ */
+interface ProjectConfigFields {
+  readonly databaseTarget: string | null;
+  readonly extensions: readonly string[];
+}
+/**
+ * Best-effort load of `prisma-next.config.*` from `projectRoot`,
+ * validated against the canonical `@prisma-next/config` schema.
+ * Returns `{ databaseTarget: null, extensions: [] }` on any failure
+ * mode — missing config file (e.g. before `prisma-next init`), c12
+ * throws while evaluating user TS, validator rejects a malformed
+ * shape, etc. Telemetry is non-blocking and best-effort; an empty
+ * result is the only downside of an unloadable or invalid config.
+ *
+ * Both `c12` and `@prisma-next/config/config-validation` are imported
+ * lazily so the detached sender's cold-start cost is paid only when
+ * telemetry actually fires, not on every fork even when gates
+ * short-circuit before reaching this code path.
+ */
+declare function loadProjectConfig(projectRoot: string): Promise<ProjectConfigFields>;
+//#endregion
 //#region src/user-config.d.ts
 /**
  * The user-level config file. Persists the consent flag and the
@@ -103,50 +206,6 @@ interface GatingInputs {
  */
 declare function resolveGating(inputs: GatingInputs): GatingResolution;
 //#endregion
-//#region src/payload.d.ts
-/**
- * Wire-shape payload the parent IPC-sends to the forked child sender.
- * Mirrors the fields the parent has naturally in hand at command start
- * (installation id, sanitised command + flags, CLI version, db target,
- * extension-pack ids, project root for TS-version lookup). The child
- * fills in the rest (runtime/os/arch, package manager, ts version,
- * agent) on its side.
- *
- * Both sides version-couple on this shape because the IPC carrier is
- * structured-cloned by Node and there's no on-wire compat to maintain.
- */
-interface ParentToSenderPayload {
-  readonly installationId: string;
-  readonly version: string;
-  readonly command: string;
-  readonly flags: readonly string[];
-  readonly databaseTarget: string | null;
-  readonly extensions: readonly string[];
-  /** Absolute path of the user's project. The child reads `<projectRoot>/package.json` for `tsVersion`. */
-  readonly projectRoot: string;
-  /** Resolved endpoint URL (already includes the `/events` path). */
-  readonly endpoint: string;
-}
-/**
- * The full event the child POSTs to the backend. Shape matches the
- * backend's arktype schema (`apps/telemetry-backend/src/schema.ts`).
- */
-interface TelemetryEvent {
-  readonly installationId: string;
-  readonly version: string;
-  readonly command: string;
-  readonly flags: readonly string[];
-  readonly runtimeName: string;
-  readonly runtimeVersion: string;
-  readonly os: string;
-  readonly arch: string;
-  readonly packageManager: string | null;
-  readonly databaseTarget: string | null;
-  readonly tsVersion: string | null;
-  readonly agent: string | null;
-  readonly extensions: readonly string[];
-}
-//#endregion
 //#region src/sanitize.d.ts
 interface CommanderOptionShape {
   /** Commander's option attribute name, e.g. `dryRun` for `--dry-run`. */
@@ -213,22 +272,33 @@ declare function sanitizeCommanderResult(input: CommanderResultShape): Sanitised
 //#region src/spawn.d.ts
 /**
  * Inputs the CLI entry point hands the telemetry layer at command
- * start. The CLI is responsible for stitching commander's result, the
- * loaded config, and the project root together; the telemetry module
- * does no I/O of its own except for the user-config read (skipped when
- * `userConfig` is provided).
+ * start. The CLI is responsible for stitching commander's result and
+ * the project root together; the telemetry module does no I/O of its
+ * own except for the user-config read (skipped when `userConfig` is
+ * provided). `extensions` is deliberately absent: the detached child
+ * loads `prisma-next.config.*` via c12 itself and derives the
+ * extension-pack ids from the validated config — see the rationale
+ * on `ParentToSenderPayload` for why c12 lives in the child rather
+ * than on the parent's hot path.
+ *
+ * `databaseTarget` is an optional parent-side override forwarded to
+ * the child. Set by `fireTelemetryAfterInitConsent` (where the
+ * config file does not yet exist on disk); left unset by the
+ * preAction-hook path so the child's c12 load supplies the value.
  */
 interface RunTelemetryInputs {
   /** Sanitised commander snapshot — see `CommanderResultShape`. */
   readonly command: CommanderResultShape;
   /** This CLI's own version (from its `package.json`). */
   readonly version: string;
-  /** Resolved `config.target.targetId`, or `null` when the config could not be loaded. */
-  readonly databaseTarget: string | null;
-  /** Declared extension-pack IDs, in any deterministic order. */
-  readonly extensions: readonly string[];
   /** Absolute path of the project root (typically `process.cwd()`). */
   readonly projectRoot: string;
+  /**
+   * Optional parent-side override for the c12-derived database target,
+   * forwarded verbatim to the child sender. Wins over the child's
+   * c12-derived value when present; `undefined` means "no override".
+   */
+  readonly databaseTarget?: string;
   /**
    * Path to the sender entry compiled into this package's `dist/`.
    * Resolved by the caller because the compiled sender lives at
@@ -274,5 +344,5 @@ declare function runTelemetry(inputs: RunTelemetryInputs): TelemetryRunOutcome;
  */
 declare function senderModuleUrl(importMetaUrl: string): string;
 //#endregion
-export { type CommanderOptionShape, type CommanderResultShape, type GatingDisabledReason, type GatingInputs, type GatingResolution, type ParentToSenderPayload, type RunTelemetryInputs, type SanitisedCommand, TELEMETRY_BACKEND_URL, TELEMETRY_ENDPOINT_PATH, type TelemetryEvent, type TelemetryRunOutcome, type UserConfig, readUserConfig, resolveGating, resolveTelemetryEndpoint, runTelemetry, sanitizeCommanderResult, senderModuleUrl, userConfigPath, writeUserConfig };
+export { type CommanderOptionShape, type CommanderResultShape, type GatingDisabledReason, type GatingInputs, type GatingResolution, type ParentToSenderPayload, type ProjectConfigFields, type RunTelemetryInputs, type SanitisedCommand, TELEMETRY_BACKEND_URL, TELEMETRY_ENDPOINT_PATH, type TelemetryEvent, type TelemetryRunOutcome, type UserConfig, loadProjectConfig, readUserConfig, resolveGating, resolveTelemetryEndpoint, runTelemetry, sanitizeCommanderResult, senderModuleUrl, userConfigPath, writeUserConfig };
 //# sourceMappingURL=index.d.mts.map