pattern-mcp 0.14.0 → 0.14.1

package/README.md

@@ -15,12 +15,17 @@ design reference.
 
 [Website](https://usepattern.sh) · [npm](https://www.npmjs.com/package/pattern-mcp) · [Report an issue](https://github.com/donaldrichard19-LVD/pattern-mcp/issues/new/choose)
 
-**Current release: v0.14.0** — a crash on startup is now diagnosable
-instead of silent (a new, coarse `pattern_cli_exited` telemetry event),
-Pattern warns at startup if `ANTHROPIC_API_KEY` is missing or clearly
-malformed instead of only surfacing a raw 401 mid-call, and a 429 from
-the Anthropic API now gets one respectful retry (honoring `Retry-After`)
-before it's raised. Previously: v0.13.0 added `npx pattern-mcp init`,
+**Current release: v0.14.1** — the crash/exit telemetry added in
+v0.14.0 (`pattern_cli_exited`) is now registered before any of this
+file's own module-level code runs, instead of near `main()`, so it
+catches more of what can go wrong on startup; both `pattern_cli_started`
+and `pattern_cli_exited` now also carry the running package version, so
+a crash right around a release can be tied to the old or new binary
+instead of staying ambiguous. Previously: v0.14.0 made a crash on
+startup diagnosable instead of silent, warned at startup if
+`ANTHROPIC_API_KEY` is missing or clearly malformed instead of only
+surfacing a raw 401 mid-call, and added one respectful retry on a 429
+(honoring `Retry-After`). Before that: v0.13.0 added `npx pattern-mcp init`,
 which sets up the connection to your MCP client for you (Claude Code,
 Claude Desktop, Cursor detected and configured automatically; Codex CLI
 gets manual instructions). Running `npx pattern-mcp` bare in your own

package/dist/index.js

@@ -40,6 +40,53 @@ import { fileURLToPath } from "node:url";
 import { captureApiError, captureCliExited, captureCliStarted, captureRecommendation, getClient as getPostHogClient, installId, printTelemetryNoticeOnce, shutdownTelemetry, TELEMETRY_ENABLED, } from "./telemetry.js";
 import { offerEnforcementSetupOnce } from "./init-enforcement.js";
 import { connectInstructionsText, offerClientConnectSetupOnce, runConnect } from "./client-connect.js";
+// Read as early as possible in this file's own module-level code, wrapped
+// so a missing/corrupt package.json can't itself become a new, unguarded
+// crash source -- this is read before the crash handlers below exist to
+// catch anything. Moved up from where it used to live (just above the
+// `server` construction, far later in this file) after a 2026-09-14
+// incident where a caller crashed on every single launch, ~29 times in 4
+// minutes, immediately after a version bump published -- telemetry had no
+// way to say whether the crashing process was the old or new version (see
+// project_pattern_activation_funnel memory). Every pattern_cli_started/
+// pattern_cli_exited event now carries this, closing that gap for next
+// time.
+const PACKAGE_VERSION = (() => {
+    try {
+        return JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), "..", "package.json"), "utf8")).version;
+    }
+    catch {
+        return "unknown";
+    }
+})();
+// Registered before anything else in this file runs (all the way up here,
+// not down by main() where it used to be) so a throw anywhere in this
+// file's own module-level code -- not just inside main() -- is captured
+// instead of dying silently before these handlers would otherwise have
+// existed. Can't cover a throw during the import statements above this
+// line (nothing can run before those resolve), but this closes the much
+// larger window between "imports finished" and "main() starts," which is
+// most of this file's ~4700 lines of function/constant definitions and
+// tool registrations.
+let exitTelemetryCaptured = false;
+function captureExitOnce(reason, err) {
+    if (exitTelemetryCaptured)
+        return;
+    exitTelemetryCaptured = true;
+    captureCliExited(reason, err, PACKAGE_VERSION);
+}
+process.on("uncaughtException", async (err) => {
+    console.error("Pattern: uncaught exception, exiting.", err);
+    captureExitOnce("uncaught_exception", err);
+    await shutdownTelemetry();
+    process.exit(1);
+});
+process.on("unhandledRejection", async (reason) => {
+    console.error("Pattern: unhandled rejection, exiting.", reason);
+    captureExitOnce("unhandled_rejection", reason);
+    await shutdownTelemetry();
+    process.exit(1);
+});
 export const ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY;
 // Only required for org-scoped keys (not tied to one workspace); unset for
 // legacy workspace-scoped keys, which don't need it.
@@ -3414,11 +3461,8 @@ export function extractJson(text) {
         return text;
     return text.slice(start, end + 1);
 }
-// Read from package.json rather than hardcoding, so $mcp_server_version in
-// PostHog's MCP tool-call analytics (and any client that reads the MCP
-// initialize response) reflects the version actually installed instead of
-// staying frozen at whatever it was when this line was first written.
-const PACKAGE_VERSION = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), "..", "package.json"), "utf8")).version;
+// PACKAGE_VERSION is defined near the top of this file now (read as early
+// as possible, before the crash handlers -- see the comment there).
 const server = new Server({ name: "pattern-mcp", version: PACKAGE_VERSION }, { capabilities: { tools: {} } });
 // Standard MCP tool-call analytics (tool name, duration, success/failure,
 // unique installs/sessions) via PostHog's own MCP SDK -- separate from
@@ -3938,41 +3982,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 // they're still looking at the terminal, not five minutes after they
 // alt-tabbed away.
 const IDLE_CONNECT_NUDGE_MS = 20_000;
-// Registered once, at module load, so it covers the entire process
-// lifetime -- including a throw during main() itself, before the server
-// ever connects. Without this, a crash-on-start left no telemetry trace at
-// all: captureCliStarted fires, the process dies, and nothing explains why
-// (see project_pattern_activation_funnel memory -- the incident this
-// exists to make diagnosable next time). Both handlers exit(1) after
-// capturing: Node considers the process's state undefined past an uncaught
-// exception, so continuing to run is the wrong default regardless of
-// telemetry.
-let exitTelemetryCaptured = false;
-function captureExitOnce(reason, err) {
-    if (exitTelemetryCaptured)
-        return;
-    exitTelemetryCaptured = true;
-    captureCliExited(reason, err);
-}
-process.on("uncaughtException", async (err) => {
-    console.error("Pattern: uncaught exception, exiting.", err);
-    captureExitOnce("uncaught_exception", err);
-    await shutdownTelemetry();
-    process.exit(1);
-});
-process.on("unhandledRejection", async (reason) => {
-    console.error("Pattern: unhandled rejection, exiting.", reason);
-    captureExitOnce("unhandled_rejection", reason);
-    await shutdownTelemetry();
-    process.exit(1);
-});
+// captureExitOnce and the uncaughtException/unhandledRejection handlers
+// are registered near the top of this file now, before PACKAGE_VERSION's
+// definition -- see the comment there for why.
 async function main() {
     // `npx pattern-mcp init` -- the connect wizard -- exits without ever
     // starting the server. Checked before anything else so it can't be
     // shadowed by a tool name collision later.
     const argv = process.argv.slice(2);
     if (argv[0] === "init") {
-        captureCliStarted("init");
+        captureCliStarted("init", PACKAGE_VERSION);
         await runConnect(PROJECT_ROOT, { yes: argv.includes("--yes") });
         await shutdownTelemetry();
         // Explicit exit, not a bare return -- shutdownTelemetry races a
@@ -3982,7 +4001,7 @@ async function main() {
         // event loop to drain on its own if some other handle is lingering.
         process.exit(0);
     }
-    captureCliStarted("server");
+    captureCliStarted("server", PACKAGE_VERSION);
     warnIfAnthropicKeyLooksWrong();
     printTelemetryNoticeOnce();
     // Piggybacks on this same first-run moment (Option B, see

package/dist/telemetry.js

@@ -241,21 +241,30 @@ export function captureRecommendation(args) {
 // project_pattern_reddit_launch_spike memory for why that gap mattered:
 // a 2026-09-11 download spike showed almost no matching $mcp_initialize
 // growth, and there was no signal at all for the step in between.
-export function captureCliStarted(mode) {
-    capture("pattern_cli_started", { mode });
+// `version` is the running package.json version (see index.ts's
+// PACKAGE_VERSION) -- added 2026-09-14 after an incident where a caller
+// crashed on every launch attempt (~29 times in 4 minutes) in the few
+// minutes right after a version bump published, and telemetry had no way
+// to say whether the crashing process was the old or new version. Without
+// it, "did the fix actually ship before this happened" is unanswerable
+// from telemetry alone.
+export function captureCliStarted(mode, version) {
+    capture("pattern_cli_started", { mode, version });
 }
 // Paired with captureCliStarted so a start with no matching handshake is
 // diagnosable instead of silent -- added after a 2026-09-13 incident where
 // 33 starts in one hour produced exactly 1 successful handshake, and
 // telemetry had no way to say why the other 32 processes ended (see
-// project_pattern_activation_funnel memory). Only a coarse reason and the
-// thrown value's constructor name travel -- never the error message or
-// stack, which could contain a file path, a stray argument value, or other
-// local detail never sent by design (see this file's header).
-export function captureCliExited(reason, err) {
+// project_pattern_activation_funnel memory). Only a coarse reason, the
+// thrown value's constructor name, and the running version travel --
+// never the error message or stack, which could contain a file path, a
+// stray argument value, or other local detail never sent by design (see
+// this file's header).
+export function captureCliExited(reason, err, version) {
     capture("pattern_cli_exited", {
         exit_reason: reason,
         error_name: err instanceof Error ? err.name : null,
+        version,
     });
 }
 export function captureApiError(args) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pattern-mcp",
-  "version": "0.14.0",
+  "version": "0.14.1",
   "description": "MCP server that turns your design guidance into a checkable process -- evaluates UI components from external libraries (shadcn/ui, 21st.dev, ReUI) or your own registered design system against a requirements checklist, then tells the agent whether to reuse an existing component or build one from a concrete design reference.",
   "type": "module",
   "main": "dist/index.js",