@aixle/insights 0.2.0 → 0.2.1-staging

package/dist/server.js

@@ -27,6 +27,12 @@ export const SYNC_NOW_INPUT_SCHEMA = z
     }
 })
     .strict();
+const AUTHENTICATE_INPUT_SCHEMA = z.object({
+    keycloakUrl: z.string().optional(),
+    clientId: z.string().optional(),
+});
+/** DB90DV-569: `db90_*` names are deprecated aliases kept for one release for existing callers. */
+const DEPRECATED_ALIAS_NOTE = "(Deprecated — use `{name}` instead; kept temporarily for backward compatibility, see DB90DV-569.) ";
 function jsonContent(value) {
     return {
         content: [
@@ -56,6 +62,16 @@ function migrateAllLegacyState(creds) {
 function syncResultOk(result) {
     return !result.locked && result.failed === 0;
 }
+/**
+ * Whether a `credential_validation_failed` warning should mirror to stderr.
+ * Mirrors for one-shot/startup sources so an installed-but-uninitialized MCP is
+ * visible, but NOT for the recurring background `"interval"` tick — that fires
+ * every SYNC_INTERVAL_MS for the whole process lifetime and would spam the logs.
+ * The event is always written to mcp.log regardless of this return value.
+ */
+export function shouldMirrorMissingCredentials(source) {
+    return source !== "interval";
+}
 // Process-lifetime cache keyed on the inputs that drive resolveProjectId: host,
 // lookup token, and the current repo's git remote. Re-resolve when any of them
 // changes (re-auth, repo cwd change). `source: "none"` is never cached so a
@@ -70,22 +86,22 @@ async function getProjectResolutionForSync(creds) {
     if (cachedProjectResolution?.key === cacheKey) {
         return cachedProjectResolution.value;
     }
-    const result = await resolveProjectId(undefined, undefined, creds.host, token, false);
+    const result = await resolveProjectId(undefined, undefined, creds.host, token, false, creds.insecureHttpAllowed === true);
     mcpLog.info("project_attribution_resolved", { project_id: result.projectId, source: result.source }, false);
     if (result.source !== "none") {
         cachedProjectResolution = { key: cacheKey, value: result };
     }
     return result;
 }
-/** Structured status for `db90_status` — tolerates missing/malformed credentials and state. */
-export async function buildDb90StatusPayload() {
+/** Structured status for `aixle_insights_status` — tolerates missing/malformed credentials and state. */
+export async function buildAixleInsightsStatusPayload() {
     const snapshot = await buildHealthSnapshot();
     return healthSnapshotToStatusPayload(snapshot);
 }
 async function executeSync(parsed) {
     const creds = await loadCredentials();
     if (!creds || !credentialsHaveAnyToken(creds)) {
-        mcpLog.warn("credential_validation_failed", { source: "db90_sync_now", reason: "missing_credentials" }, false);
+        mcpLog.warn("credential_validation_failed", { source: "aixle_insights_sync_now", reason: "missing_credentials" }, shouldMirrorMissingCredentials("aixle_insights_sync_now"));
         return { ok: false, error: "missing_credentials" };
     }
     migrateAllLegacyState(creds);
@@ -104,79 +120,96 @@ async function executeSync(parsed) {
     });
     return { ok: syncResultOk(result), result };
 }
-/** In-process MCP server instance (stdio not attached). */
-export function createDb90McpServer() {
-    const server = new McpServer({ name: SERVER_NAME, version: SERVER_VERSION }, { capabilities: { tools: {} } });
-    server.registerTool("db90_status", {
-        description: "Returns Aixle Insights MCP connectivity and last sync metadata from disk (credentials + state). No arguments.",
-    }, async () => jsonContent(await buildDb90StatusPayload()));
-    server.registerTool("db90_sync_now", {
-        description: "Runs one DB90 ingest sync cycle for enabled tools immediately (matches background cadence). " +
-            "Optional `tools` subset filter: omit to sync every tool credential you have authenticated (Claude transcripts + Cursor telemetry).",
-        inputSchema: SYNC_NOW_INPUT_SCHEMA,
-    }, async (input) => {
-        try {
-            const parsed = SYNC_NOW_INPUT_SCHEMA.parse(input ?? {});
-            return jsonContent(await executeSync(parsed));
-        }
-        catch (err) {
-            if (err instanceof z.ZodError) {
-                return jsonContent({
-                    ok: false,
-                    error: "validation_error",
-                    details: err.flatten(),
-                });
-            }
+async function statusHandler() {
+    return jsonContent(await buildAixleInsightsStatusPayload());
+}
+async function syncNowHandler(input) {
+    try {
+        const parsed = SYNC_NOW_INPUT_SCHEMA.parse(input ?? {});
+        return jsonContent(await executeSync(parsed));
+    }
+    catch (err) {
+        if (err instanceof z.ZodError) {
             return jsonContent({
                 ok: false,
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
-    });
-    server.registerTool("db90_authenticate", {
-        description: "Starts Keycloak device login and returns the visit URL/code for the user. Use aixle-insights init for the full terminal flow that saves credentials.",
-        inputSchema: z.object({
-            keycloakUrl: z.string().optional(),
-            clientId: z.string().optional(),
-        }),
-    }, async (input) => {
-        try {
-            const args = input;
-            const kc = (args.keycloakUrl?.trim() || defaultKeycloakIssuer()).trim();
-            if (!kc) {
-                return jsonContent({
-                    ok: false,
-                    error: "keycloakUrl or KEYCLOAK_ISSUER / DB90_KEYCLOAK_ISSUER is required",
-                });
-            }
-            const clientId = args.clientId?.trim() || defaultKeycloakClientId();
-            const device = await startDeviceAuthorization({
-                issuer: kc,
-                clientId,
-            });
-            return jsonContent({
-                ok: true,
-                verificationUri: device.verification_uri,
-                verificationUriComplete: device.verification_uri_complete ?? null,
-                userCode: device.user_code,
-                expiresIn: device.expires_in,
-                interval: device.interval ?? 5,
-                issuer: kc,
-                clientId,
-                message: `Visit ${device.verification_uri} and enter code ${device.user_code}`,
+                error: "validation_error",
+                details: err.flatten(),
             });
         }
-        catch (err) {
+        return jsonContent({
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+}
+async function authenticateHandler(args) {
+    try {
+        const kc = (args.keycloakUrl?.trim() || defaultKeycloakIssuer()).trim();
+        if (!kc) {
             return jsonContent({
                 ok: false,
-                error: err instanceof Error ? err.message : String(err),
+                error: "keycloakUrl or KEYCLOAK_ISSUER / DB90_KEYCLOAK_ISSUER is required",
             });
         }
-    });
+        const clientId = args.clientId?.trim() || defaultKeycloakClientId();
+        const device = await startDeviceAuthorization({
+            issuer: kc,
+            clientId,
+        });
+        return jsonContent({
+            ok: true,
+            verificationUri: device.verification_uri,
+            verificationUriComplete: device.verification_uri_complete ?? null,
+            userCode: device.user_code,
+            expiresIn: device.expires_in,
+            interval: device.interval ?? 5,
+            issuer: kc,
+            clientId,
+            message: `Visit ${device.verification_uri} and enter code ${device.user_code}`,
+        });
+    }
+    catch (err) {
+        return jsonContent({
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+}
+/** In-process MCP server instance (stdio not attached). */
+export function createAixleInsightsMcpServer() {
+    const server = new McpServer({ name: SERVER_NAME, version: SERVER_VERSION }, { capabilities: { tools: {} } });
+    const statusDescription = "Returns Aixle Insights MCP connectivity and last sync metadata from disk (credentials + state). No arguments.";
+    server.registerTool("aixle_insights_status", { description: statusDescription }, statusHandler);
+    server.registerTool("db90_status", { description: DEPRECATED_ALIAS_NOTE.replace("{name}", "aixle_insights_status") + statusDescription }, statusHandler);
+    const syncNowDescription = "Runs one DB90 ingest sync cycle for enabled tools immediately (matches background cadence). " +
+        "Optional `tools` subset filter: omit to sync every tool credential you have authenticated (Claude transcripts + Cursor telemetry).";
+    server.registerTool("aixle_insights_sync_now", { description: syncNowDescription, inputSchema: SYNC_NOW_INPUT_SCHEMA }, syncNowHandler);
+    server.registerTool("db90_sync_now", {
+        description: DEPRECATED_ALIAS_NOTE.replace("{name}", "aixle_insights_sync_now") + syncNowDescription,
+        inputSchema: SYNC_NOW_INPUT_SCHEMA,
+    }, syncNowHandler);
+    const authenticateDescription = "Starts Keycloak device login and returns the visit URL/code for the user. Use aixle-insights init for the full terminal flow that saves credentials.";
+    server.registerTool("aixle_insights_authenticate", { description: authenticateDescription, inputSchema: AUTHENTICATE_INPUT_SCHEMA }, authenticateHandler);
+    server.registerTool("db90_authenticate", {
+        description: DEPRECATED_ALIAS_NOTE.replace("{name}", "aixle_insights_authenticate") + authenticateDescription,
+        inputSchema: AUTHENTICATE_INPUT_SCHEMA,
+    }, authenticateHandler);
     return server;
 }
+/**
+ * Subscribes `shutdown` to the given stream's "end" and "close" events.
+ * Closing stdin is how the OS signals a stdio-transport MCP server that its
+ * parent process is gone — this fires even when the parent can't deliver a
+ * signal (e.g. it was itself SIGKILL'd, or the OS reparented this process
+ * without ever sending one). Exported standalone so it's testable with a
+ * plain EventEmitter instead of the real process.stdin.
+ */
+export function wireParentExitShutdown(stdin, shutdown) {
+    stdin.on("end", shutdown);
+    stdin.on("close", shutdown);
+}
 export async function startServer() {
-    const server = createDb90McpServer();
+    const server = createAixleInsightsMcpServer();
     const transport = new StdioServerTransport();
     await server.connect(transport);
     let intervalId;
@@ -195,12 +228,13 @@ export async function startServer() {
     };
     process.on("SIGINT", onSignal);
     process.on("SIGTERM", onSignal);
+    wireParentExitShutdown(process.stdin, onSignal);
     const runBackground = async (source) => {
         if (shuttingDown)
             return;
         const creds = await loadCredentials();
         if (!creds || !credentialsHaveAnyToken(creds)) {
-            mcpLog.warn("credential_validation_failed", { source, reason: "missing_credentials" }, false);
+            mcpLog.warn("credential_validation_failed", { source, reason: "missing_credentials" }, shouldMirrorMissingCredentials(source));
             return;
         }
         try {

package/dist/state.js

@@ -2,6 +2,7 @@ import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { createHash, randomBytes } from "node:crypto";
+import { mcpLog } from "./log.js";
 export function getAppDir() {
     const override = process.env["AIXLE_INSIGHTS_HOME"]?.trim();
     if (override && override.length > 0)
@@ -123,8 +124,12 @@ export function readState(dir, host, token) {
             }
         }
     }
-    catch {
-        // missing or malformed state file — start fresh
+    catch (err) {
+        const code = err?.code;
+        if (code !== "ENOENT") {
+            // State file exists but failed to parse — distinguishes tampering from "never created".
+            mcpLog.warn("state_parse_failed", { path: filePath, error: err instanceof Error ? err.message : String(err) }, false);
+        }
     }
     return { version: 1, sessions: {} };
 }

package/dist/sync.d.ts

@@ -2,7 +2,7 @@ import type { TelemetryToolId, StoredCredentials } from "./auth/credentials.js";
 import { type PricingTable } from "./pricing.js";
 import type { PricingConfig } from "./readers/cursor.js";
 import { type ProjectResolution } from "./lib/index.js";
-import type { CursorDb90Payload } from "./readers/cursor.js";
+import type { CursorPayload } from "./readers/cursor.js";
 /** Prefix for Claude Code session keys in shared MCP state. */
 export declare const CLAUDE_STATE_PREFIX: "claude_code:";
 export { CURSOR_WATERMARK_KEY, CURSOR_EVENTS_WATERMARK_KEY, CURSOR_DAILY_STATS_WATERMARK_KEY, CURSOR_RECENT_COMMIT_WATERMARK_KEY, CURSOR_TRANSCRIPT_TURN_PREFIX, cursorTranscriptTurnStateKey, filterRecentCommitsByHashDedup, } from "./cursor-checkpoints.js";
@@ -24,6 +24,8 @@ export interface SyncOptions {
     verbose: boolean;
     projectId: string | null;
     projectIdSource?: ProjectResolution["source"];
+    /** Mirrors StoredCredentials.insecureHttpAllowed — set when `init --insecure` was used for this host. */
+    allowInsecureHttp?: boolean;
     pricing: PricingTable;
     appDir?: string;
     transcriptBaseDirs?: string[];
@@ -65,7 +67,7 @@ export declare function getSyncTelemetry(): {
     lastResult: SyncResult | null;
     recentErrors: string[];
 };
-export declare function cursorRepoPathFromPayload(payload: CursorDb90Payload): string | undefined;
+export declare function cursorRepoPathFromPayload(payload: CursorPayload): string | undefined;
 /**
  * Parallel multi-tool cycle under the global advisory ingest lock (`state.lock`).
  */

package/dist/sync.js

@@ -102,7 +102,7 @@ function explicitProjectId(projectId, projectIdSource) {
         ? projectId
         : undefined;
 }
-async function resolveProjectIdForRepoPathCached(repoPath, host, token, verbose, cache) {
+async function resolveProjectIdForRepoPathCached(repoPath, host, token, verbose, cache, allowInsecureHttp = false) {
     const normalized = repoPath?.trim();
     if (!normalized)
         return null;
@@ -113,7 +113,7 @@ async function resolveProjectIdForRepoPathCached(repoPath, host, token, verbose,
         cache.set(normalized, null);
         return null;
     }
-    const result = await lookupProjectByRemote(canonicalRemote, host, token, verbose);
+    const result = await lookupProjectByRemote(canonicalRemote, host, token, verbose, allowInsecureHttp);
     const projectId = result && typeof result === "object" && "project_id" in result ? result.project_id : null;
     cache.set(normalized, projectId);
     return projectId;
@@ -131,7 +131,7 @@ export function cursorRepoPathFromPayload(payload) {
     return undefined;
 }
 async function runClaudeSlice(options) {
-    const { token, host, dryRun, verbose, projectId, pricing } = options;
+    const { token, host, dryRun, verbose, projectId, pricing, allowInsecureHttp = false } = options;
     const appDir = options.appDir ?? getAppDir();
     const backoffKey = credentialStateKey(host, token);
     const errors = [];
@@ -222,13 +222,16 @@ async function runClaudeSlice(options) {
         // effectively one network call per unique cwd per sync.
         const resolvedProjectId = scopeDir
             ? (projectId ??
-                (await resolveProjectIdForRepoPathCached(turn.cwd, host, token, verbose, projectLookupCache)) ??
+                (await resolveProjectIdForRepoPathCached(turn.cwd, host, token, verbose, projectLookupCache, allowInsecureHttp)) ??
                 undefined)
             : (explicitProject ??
-                (await resolveProjectIdForRepoPathCached(turn.cwd, host, token, verbose, projectLookupCache)) ??
+                (await resolveProjectIdForRepoPathCached(turn.cwd, host, token, verbose, projectLookupCache, allowInsecureHttp)) ??
                 undefined);
-        const payload = mapClaudeTranscriptTurn(turn, { projectId: resolvedProjectId, pricing });
-        if (verbose && payload.cost_usd === null) {
+        const payloads = mapClaudeTranscriptTurn(turn, { projectId: resolvedProjectId, pricing });
+        if (!payloads?.length)
+            continue;
+        const parentPayload = payloads[0];
+        if (verbose && parentPayload?.cost_usd === null) {
             if (!turn.model) {
                 if (turn.tokensIn > 0 || turn.tokensOut > 0) {
                     console.warn(`[warn] Claude turn ${turn.turnId} has usage but no model — cost_usd will be null`);
@@ -241,45 +244,53 @@ async function runClaudeSlice(options) {
             }
         }
         if (dryRun) {
-            console.log(`[dry-run] Would send Claude turn ${turn.turnId}:`);
-            console.log(JSON.stringify(payload, null, 2));
-            totalSent++;
+            for (const payload of payloads) {
+                console.log(`[dry-run] Would send Claude ${payload.event_type} ${payload.metadata.session_id}:`);
+                console.log(JSON.stringify(payload, null, 2));
+            }
+            totalSent += payloads.length;
             continue;
         }
-        if (verbose) {
-            console.log(`[verbose] Sending Claude turn ${turn.turnId} (${turn.tokensIn + turn.tokensOut} tokens)`);
-        }
-        const ok = await postEvent(payload, host, token, {
-            on429: (retryAfter, quotaExceeded) => {
-                const currentBackoff = backoffUntilByCredential.get(backoffKey);
-                const nextBackoff = new Date(Math.max(currentBackoff?.getTime() ?? 0, Date.now() + retryAfter * 1000));
-                backoffUntilByCredential.set(backoffKey, nextBackoff);
-                shouldStopForBackoff = true;
-                const reason = quotaExceeded ? "Monthly quota exceeded" : "Rate limited";
-                mcpLog.warn("sync_rate_limit_pause", {
-                    tool: "claude_code",
-                    retry_until: nextBackoff.toISOString(),
-                    quota_exceeded: quotaExceeded,
-                }, true);
-                console.warn(`[aixle-insights] ${reason}. Pausing until ${nextBackoff.toISOString()}.`);
-                // Persist backoff to state so it survives process restarts
-                state = { ...state, rate_limited_until: nextBackoff.toISOString() };
-                writeState(state, appDir, host, token);
-            },
-        });
-        if (ok) {
+        let allOk = true;
+        for (const payload of payloads) {
+            if (verbose) {
+                console.log(`[verbose] Sending Claude ${payload.event_type} ${payload.metadata.session_id}`);
+            }
+            const ok = await postEvent(payload, host, token, {
+                on429: (retryAfter, quotaExceeded) => {
+                    const currentBackoff = backoffUntilByCredential.get(backoffKey);
+                    const nextBackoff = new Date(Math.max(currentBackoff?.getTime() ?? 0, Date.now() + retryAfter * 1000));
+                    backoffUntilByCredential.set(backoffKey, nextBackoff);
+                    shouldStopForBackoff = true;
+                    const reason = quotaExceeded ? "Monthly quota exceeded" : "Rate limited";
+                    mcpLog.warn("sync_rate_limit_pause", {
+                        tool: "claude_code",
+                        retry_until: nextBackoff.toISOString(),
+                        quota_exceeded: quotaExceeded,
+                    }, true);
+                    console.warn(`[aixle-insights] ${reason}. Pausing until ${nextBackoff.toISOString()}.`);
+                    // Persist backoff to state so it survives process restarts
+                    state = { ...state, rate_limited_until: nextBackoff.toISOString() };
+                    writeState(state, appDir, host, token);
+                },
+            });
+            if (!ok) {
+                allOk = false;
+                totalFailed++;
+                errors.push(`Failed to post Claude ${payload.event_type} for turn ${turn.turnId}`);
+                mcpLog.error("sync_ingest_final_failure", { tool: "claude_code", session_id: turn.turnId }, true);
+                break;
+            }
+        }
+        if (allOk) {
+            totalSent += payloads.length;
             state = markSessionSent(state, sKey, turn.fileSize);
             writeState(state, appDir, host, token);
-            totalSent++;
         }
-        else {
-            totalFailed++;
-            errors.push(`Failed to post Claude turn ${turn.turnId}`);
-            mcpLog.error("sync_ingest_final_failure", { tool: "claude_code", session_id: turn.turnId }, true);
-            if (shouldStopForBackoff) {
-                break;
-            }
+        else if (shouldStopForBackoff) {
+            break;
         }
+        // Non-backoff failure: continue to next turn (failed turn will retry next sync)
     }
     const result = { sent: totalSent, failed: totalFailed, skipped: totalSkipped };
     const currentBackoff = backoffUntilByCredential.get(backoffKey);
@@ -290,7 +301,7 @@ async function runClaudeSlice(options) {
     return result;
 }
 async function runCursorSlice(params) {
-    const { token, host, dryRun, verbose, projectId, projectIdSource, projectLookupToken, appDir, cursorBaseDir, cursorTranscriptProjectDirs, scopeDir, fullScan = false, cursorPricing = resolveCursorPricing(undefined, appDir), } = params;
+    const { token, host, dryRun, verbose, projectId, projectIdSource, projectLookupToken, allowInsecureHttp = false, appDir, cursorBaseDir, cursorTranscriptProjectDirs, scopeDir, fullScan = false, cursorPricing = resolveCursorPricing(undefined, appDir), } = params;
     const backoffKey = credentialStateKey(host, token);
     // Read state first so we can restore a persisted rate-limit backoff from a prior process.
     const stateBefore = readState(appDir, host, token);
@@ -331,6 +342,7 @@ async function runCursorSlice(params) {
         host,
         token,
         projectLookupToken: lookupToken,
+        allowInsecureHttp,
         verbose,
         cursorBaseDir,
         cursorTranscriptProjectDirs,
@@ -345,7 +357,7 @@ async function runCursorSlice(params) {
                     // Same fallback as Claude: when the pre-resolved projectId is null, do a
                     // per-payload lookup from the payload's workspace. Cache dedupes by path.
                     const resolved = projectId ??
-                        (await resolveProjectIdForRepoPathCached(ws, host, lookupToken, verbose, projectLookupCache));
+                        (await resolveProjectIdForRepoPathCached(ws, host, lookupToken, verbose, projectLookupCache, allowInsecureHttp));
                     if (resolved)
                         payload.project_id = resolved;
                     else
@@ -365,7 +377,7 @@ async function runCursorSlice(params) {
                 continue;
             for (const payload of group.payloads) {
                 const repoPath = cursorRepoPathFromPayload(payload);
-                const resolvedProjectId = await resolveProjectIdForRepoPathCached(repoPath, host, lookupToken, verbose, projectLookupCache);
+                const resolvedProjectId = await resolveProjectIdForRepoPathCached(repoPath, host, lookupToken, verbose, projectLookupCache, allowInsecureHttp);
                 if (resolvedProjectId)
                     payload.project_id = resolvedProjectId;
                 else
@@ -438,7 +450,7 @@ async function runCursorSlice(params) {
                     totalSkipped++;
                     continue;
                 }
-                const ok = await postEvent(payload, host, token, { on429 });
+                const ok = await postEvent(payload, host, token, { on429, allowInsecureHttp });
                 if (ok) {
                     totalSent++;
                     const turnId = payload.metadata.session_id;
@@ -455,7 +467,7 @@ async function runCursorSlice(params) {
             }
             continue;
         }
-        const batchResult = await postEvents(group.payloads, host, token, { on429 });
+        const batchResult = await postEvents(group.payloads, host, token, { on429, allowInsecureHttp });
         totalSent += batchResult.sent;
         totalFailed += batchResult.failed;
         if (batchResult.failed > 0) {
@@ -501,10 +513,11 @@ async function runCursorSlice(params) {
                 state: stateMut,
                 host,
                 token,
+                allowInsecureHttp,
                 on429,
                 resolveProjectId: explicitProject
                     ? undefined
-                    : (workspace) => resolveProjectIdForRepoPathCached(workspace, host, lookupToken, verbose, projectLookupCache),
+                    : (workspace) => resolveProjectIdForRepoPathCached(workspace, host, lookupToken, verbose, projectLookupCache, allowInsecureHttp),
                 verbose,
             });
             totalSent += hooksResult.sent;
@@ -590,6 +603,7 @@ export async function syncTelemetryTools(options) {
                 dryRun,
                 verbose,
                 projectId,
+                allowInsecureHttp: credentials.insecureHttpAllowed === true,
                 pricing,
                 appDir,
                 transcriptBaseDirs: options.transcriptBaseDirs,
@@ -606,6 +620,7 @@ export async function syncTelemetryTools(options) {
                 projectId,
                 projectIdSource,
                 projectLookupToken,
+                allowInsecureHttp: credentials.insecureHttpAllowed === true,
                 appDir,
                 cursorBaseDir: options.cursorBaseDir,
                 cursorTranscriptProjectDirs: options.cursorTranscriptProjectDirs,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aixle/insights",
-  "version": "0.2.0",
+  "version": "0.2.1-staging",
   "description": "stdio MCP server for AI coding-assistant telemetry — Claude transcript sync + Cursor SQLite ingest.",
   "type": "module",
   "bin": {
@@ -19,7 +19,7 @@
     "provenance": false
   },
   "engines": {
-    "node": ">=20.19.0"
+    "node": ">=20"
   },
   "license": "MIT",
   "repository": {