neon 8.0.4 → 8.0.6

package/dist/analytics.js

@@ -75,8 +75,12 @@ const telemetryCredential = (authContext, apiKey, defaultCredentialsPath) => {
 };
 let client;
 let clientInitialized = false;
-let userId = "";
 let errorEventContext;
+/** Lets tests send to a local collector; the CLI itself always uses track.neon.tech. */
+const useAnalyticsClientForTests = (analytics) => {
+	client = analytics;
+	clientInitialized = true;
+};
 /**
 * Phase 1: Run before validation so the Segment client exists if any
 * middleware (e.g. auth) fails. Enables sendError() in the fail handler.
@@ -95,12 +99,37 @@ const initAnalyticsClientMiddleware = (args) => {
 	client.identify({ userId: ANONYMOUS });
 };
 /**
-* Phase 2: Run after auth. Resolves user id from credentials,
-* identifies the user, and sends CLI Started.
+* The attribution of the current attempt. A 401 retry runs the middleware again and starts a
+* new one; events keep the attempt they were tracked in, even while its lookup is in flight.
+*/
+let attribution = { userId: "" };
+/**
+* Every event goes out through this chain so events tracked while the account lookup is in
+* flight are sent after "CLI Started", with the user id the lookup resolves, in call order.
 */
-const analyticsMiddleware = async (args) => {
+let queue = Promise.resolve();
+const lookups = /* @__PURE__ */ new Set();
+const enqueue = (send) => {
+	const analytics = client;
+	if (!analytics) return;
+	const attempt = attribution;
+	queue = queue.then(() => {
+		try {
+			send(analytics, attempt);
+		} catch (err) {
+			log.debug("Could not queue a CLI analytics event: %s", err);
+		}
+	});
+};
+/**
+* Phase 2: Run after auth. Starts resolving the user id from credentials and returns; the
+* command does not wait for it. Identify and CLI Started go out once it settles.
+*/
+const analyticsMiddleware = (args) => {
 	if (!client || !args.analytics) return;
 	if (isCurrentBranchProbe(args)) return;
+	const attempt = { userId: attribution.userId };
+	attribution = attempt;
 	const { apiKey: keyToQuery, credentialsPath: fileToRead } = telemetryCredential(getAuthContext(), args.apiKey, credentialsPath(args.configDir));
 	if (fileToRead !== void 0) try {
 		const listing = storeFor(args.configDir).inspect({
@@ -108,7 +137,7 @@ const analyticsMiddleware = async (args) => {
 			storage: "file",
 			path: fileToRead
 		});
-		if (typeof listing.credentials?.user_id === "string") userId = listing.credentials.user_id;
+		if (typeof listing.credentials?.user_id === "string") attempt.userId = listing.credentials.user_id;
 		else log.debug("No usable credentials at %s", fileToRead);
 	} catch (err) {
 		log.debug("Could not read %s: %s", fileToRead, err);
@@ -118,50 +147,76 @@ const analyticsMiddleware = async (args) => {
 			profile: getAuthContext()?.profile ?? "DEFAULT",
 			storage: "keyring"
 		});
-		if (typeof listing.credentials?.user_id === "string") userId = listing.credentials.user_id;
+		if (typeof listing.credentials?.user_id === "string") attempt.userId = listing.credentials.user_id;
 	} catch (err) {
 		log.debug("Could not read the OS keyring item: %s", err);
 	}
-	try {
-		if (keyToQuery) {
-			const apiClient = getApiClient({
-				apiKey: keyToQuery,
-				apiHost: args.apiHost
-			});
-			const authDetails = (await apiClient.getAuthDetails()).data;
-			args.accountId = authDetails.account_id;
-			args.authMethod = authDetails.auth_method;
-			args.authData = authDetails.auth_data;
-			if (!userId && authDetails.auth_method !== "api_key_org") userId = (await apiClient?.getCurrentUserInfo?.())?.data?.id;
-		} else {
-			const { accountId, authMethod } = storedCredentialAttribution(userId);
-			args.accountId = accountId;
-			args.authMethod = authMethod;
+	const startedProperties = getAnalyticsEventProperties(args);
+	const controller = new AbortController();
+	lookups.add(controller);
+	const lookup = (async () => {
+		try {
+			if (keyToQuery) {
+				const apiClient = getApiClient({
+					apiKey: keyToQuery,
+					apiHost: args.apiHost
+				});
+				const { data: authDetails } = await apiClient.getAuthDetails({ signal: controller.signal });
+				attempt.accountId = authDetails.account_id;
+				attempt.authMethod = authDetails.auth_method;
+				attempt.authData = authDetails.auth_data;
+				if (!attempt.userId && authDetails.auth_method !== "api_key_org") {
+					const resp = await apiClient.getCurrentUserInfo({ signal: controller.signal });
+					attempt.userId = resp.data.id;
+				}
+			} else Object.assign(attempt, storedCredentialAttribution(attempt.userId));
+		} catch (err) {
+			log.debug("Failed to get user id from api", err);
+		} finally {
+			lookups.delete(controller);
 		}
-	} catch (err) {
-		log.debug("Failed to get user id from api", err);
-	}
-	client.identify({ userId: analyticsUserId(userId) });
-	client.track({
-		userId: analyticsUserId(userId),
-		event: "CLI Started",
-		properties: getAnalyticsEventProperties(args),
-		context: { direct: true }
+	})();
+	queue = queue.then(() => lookup);
+	enqueue((analytics, { userId }) => {
+		analytics.identify({ userId: analyticsUserId(userId) });
+		analytics.track({
+			userId: analyticsUserId(userId),
+			event: "CLI Started",
+			properties: startedProperties,
+			context: { direct: true }
+		});
 	});
 };
+/** How long closing waits for an unfinished account lookup before aborting it. */
+const ATTRIBUTION_WAIT_MS = 1e3;
 let closing;
 /**
-* Close the client and flush queued events. Later calls share the first flush: the psql
-* launcher starts one while psql runs, and a second `closeAndFlush` would only make the SDK
-* warn about overlapping flushes.
+* Send queued events, then close the client and flush. Later calls share the first close: the
+* psql launcher starts one while psql runs, and a second `closeAndFlush` would only make the SDK
+* warn about overlapping flushes. `timeout` bounds the whole close, lookup wait included.
 */
 const closeAnalytics = (opts) => {
-	if (!client) return Promise.resolve();
+	const analytics = client;
+	if (!analytics) return Promise.resolve();
 	if (!closing) {
-		log.debug("Flushing CLI analytics");
-		closing = client.closeAndFlush(opts).then(() => {
+		const started = Date.now();
+		closing = (async () => {
+			const wait = Math.min(ATTRIBUTION_WAIT_MS, (opts?.timeout ?? Infinity) / 2);
+			let timer;
+			const timedOut = await Promise.race([queue.then(() => false), new Promise((resolve) => {
+				timer = setTimeout(() => resolve(true), wait);
+			})]);
+			clearTimeout(timer);
+			if (timedOut) {
+				log.debug("Account lookup unfinished; sending events without it");
+				for (const controller of lookups) controller.abort();
+				await queue;
+			}
+			log.debug("Flushing CLI analytics");
+			const flush = opts?.timeout === void 0 ? void 0 : { timeout: Math.max(1, opts.timeout - (Date.now() - started)) };
+			await analytics.closeAndFlush(flush);
 			log.debug("Flushed CLI analytics");
-		});
+		})();
 	}
 	return closing;
 };
@@ -188,22 +243,47 @@ const sendError = (err, errCode) => {
 	if (!client) return;
 	const requestId = (isNeonApiError(err) ? err : void 0)?.headers?.["x-neon-ret-request-id"];
 	if (requestId) log.debug("Failed request ID: %s", requestId);
-	client.track({
-		event: "CLI Error",
-		userId: analyticsUserId(userId),
-		properties: getErrorAnalyticsEventProperties(err, errCode, errorEventContext)
+	const properties = getErrorAnalyticsEventProperties(err, errCode, errorEventContext);
+	enqueue((analytics, { userId }) => {
+		analytics.track({
+			event: "CLI Error",
+			userId: analyticsUserId(userId),
+			properties
+		});
 	});
 	log.debug("Sent CLI error event: %s", errCode);
 };
 const trackEvent = (event, properties) => {
 	if (!client) return;
-	client.track({
-		event,
-		userId: analyticsUserId(userId),
-		properties
+	enqueue((analytics, { userId }) => {
+		analytics.track({
+			event,
+			userId: analyticsUserId(userId),
+			properties
+		});
 	});
 	log.debug("Sent CLI event: %s", event);
 };
+/**
+* Tracks cli_command_success. The account fields come from the lookup, which may still be in
+* flight when the command finishes, so they are read when the event is sent.
+*/
+const trackCommandSuccess = (args) => {
+	if (!client) return;
+	const properties = commandSuccessProperties(args);
+	enqueue((analytics, { userId, accountId, authMethod, authData }) => {
+		analytics.track({
+			event: "cli_command_success",
+			userId: analyticsUserId(userId),
+			properties: {
+				...properties,
+				accountId,
+				authMethod,
+				authData
+			}
+		});
+	});
+};
 let commandSuccessExtras = {};
 const recordCommandSuccessExtras = (patch) => {
 	commandSuccessExtras = {
@@ -242,4 +322,4 @@ const getAnalyticsEventProperties = (args) => ({
 	githubEnvVars: getGithubEnvVars(process.env)
 });
 //#endregion
-export { analyticsMiddleware, analyticsUserId, closeAnalytics, commandSuccessProperties, getAnalyticsEventProperties, getErrorAnalyticsEventProperties, initAnalyticsClientMiddleware, recordCommandSuccessExtras, recordScaffoldedTemplate, sendError, storedCredentialAttribution, takeCommandSuccessExtras, telemetryCredential, trackEvent };
+export { analyticsMiddleware, analyticsUserId, closeAnalytics, commandSuccessProperties, getAnalyticsEventProperties, getErrorAnalyticsEventProperties, initAnalyticsClientMiddleware, recordCommandSuccessExtras, recordScaffoldedTemplate, sendError, storedCredentialAttribution, takeCommandSuccessExtras, telemetryCredential, trackCommandSuccess, trackEvent, useAnalyticsClientForTests };

package/dist/api.js

@@ -333,9 +333,15 @@ const getApiClient = ({ apiKey, apiHost, requestTimeoutMs = REQUEST_TIMEOUT_MS }
 	}
 	return {
 		request,
-		getCurrentUserInfo: () => call(() => raw.getCurrentUserInfo({ client })),
+		getCurrentUserInfo: (options = {}) => call(() => raw.getCurrentUserInfo({
+			client,
+			signal: options.signal
+		})),
 		getCurrentUserOrganizations: () => call(() => raw.getCurrentUserOrganizations({ client })),
-		getAuthDetails: () => call(() => raw.getAuthDetails({ client })),
+		getAuthDetails: (options = {}) => call(() => raw.getAuthDetails({
+			client,
+			signal: options.signal
+		})),
 		getActiveRegions: () => call(() => raw.getActiveRegions({ client })),
 		listApiKeys: () => call(() => raw.listApiKeys({ client })),
 		createApiKey: (body) => call(() => raw.createApiKey({

package/dist/commands/config.js

@@ -559,11 +559,96 @@ const status = async (props) => {
 		process.stdout.write(`${JSON.stringify(configView, null, 2)}\n`);
 		return;
 	}
-	writer(props).end({
-		project: live.project,
-		branch: live.branch,
-		config: configView
-	}, { fields: INSPECT_FIELDS });
+	if (props.output !== "table") {
+		writer(props).end({
+			project: live.project,
+			branch: live.branch,
+			config: configView
+		}, { fields: INSPECT_FIELDS });
+		return;
+	}
+	writeStatusTables(props, live, configView);
+};
+const STATUS_FIELDS = [
+	"project",
+	"region",
+	"postgres_version",
+	"organization",
+	"branch",
+	"parent",
+	"default",
+	"protected",
+	"expires_at",
+	"auth",
+	"data_api",
+	"compute",
+	"scale_to_zero",
+	"ttl"
+];
+const formatComputeUnits = (settings) => {
+	const min = settings?.autoscalingLimitMinCu;
+	const max = settings?.autoscalingLimitMaxCu;
+	if (min === void 0 && max === void 0) return void 0;
+	if (min === void 0) return `max ${max} CU`;
+	if (max === void 0) return `min ${min} CU`;
+	return min === max ? `${min} CU` : `${min}-${max} CU`;
+};
+/** Human `status`: one summary block, then a table per reported resource kind. */
+const writeStatusTables = (props, live, view) => {
+	const compute = view.branch?.postgres?.computeSettings;
+	const suspend = compute?.suspendTimeout;
+	const out = writer(props);
+	out.write({
+		project: `${live.project.name} (${live.project.id})`,
+		region: live.project.region,
+		postgres_version: live.project.pgVersion,
+		organization: live.project.orgId,
+		branch: `${live.branch.name} (${live.branch.id})`,
+		parent: live.branch.parent,
+		default: live.branch.isDefault ? "yes" : "no",
+		protected: live.branch.protected ? "yes" : "no",
+		expires_at: live.branch.expiresAt,
+		auth: view.auth ? "enabled" : void 0,
+		data_api: view.dataApi ? "enabled" : void 0,
+		compute: formatComputeUnits(compute),
+		scale_to_zero: suspend === void 0 ? void 0 : suspend === false ? "off" : String(suspend),
+		ttl: view.branch?.ttl
+	}, {
+		fields: STATUS_FIELDS,
+		humanTitle: "Status"
+	});
+	const functions = Object.entries(view.preview?.functions ?? {}).map(([slug, fn]) => ({
+		slug,
+		name: fn.name
+	}));
+	if (functions.length > 0) out.write(functions, {
+		fields: ["slug", "name"],
+		humanTitle: "Functions"
+	});
+	const buckets = Object.entries(view.preview?.buckets ?? {}).map(([name, bucket]) => ({
+		name,
+		access: bucket.access
+	}));
+	if (buckets.length > 0) out.write(buckets, {
+		fields: ["name", "access"],
+		humanTitle: "Buckets"
+	});
+	const credentials = (view.preview?.credentials ?? []).map((credential) => ({
+		id: credential.id,
+		name: credential.name,
+		scopes: credential.scopes.join(", "),
+		last_used_at: credential.lastUsedAt
+	}));
+	if (credentials.length > 0) out.write(credentials, {
+		fields: [
+			"id",
+			"name",
+			"scopes",
+			"last_used_at"
+		],
+		humanTitle: "Credentials"
+	});
+	out.end();
 };
 const planCmd = async (props) => {
 	const config = await loadConfig(props);

package/dist/commands/dev.js

@@ -4,11 +4,11 @@ import { isClaimableEnvTarget } from "../claimable/state.js";
 import { getCliName } from "../utils/cli_name.js";
 import { readEnvFile, resolveEnvFilePath } from "../env_file.js";
 import { l as functionBaseUrlKey } from "../_chunks/env-N19A7qND.js";
-import { branchIdResolve } from "../utils/enrichers.js";
-import { bundleEntry } from "../utils/esbuild.js";
 import { a as resolveDevEnv } from "../_chunks/env-BgiaRNT1.js";
 import { findConfigFunctionBySource, resolveFunctionsFromConfig } from "../dev/functions.js";
 import { resolveWatchInputs } from "../dev/inputs.js";
+import { branchIdResolve } from "../utils/enrichers.js";
+import { bundleEntry } from "../utils/esbuild.js";
 import { existsSync, mkdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";

package/dist/commands/env.js

@@ -7,10 +7,10 @@ import { deprecatedServiceMessage, parseServices, servicesFlagValue, servicesOpt
 import { mergeEnvFile, readEnvFile, resolveEnvFilePath } from "../env_file.js";
 import { t as NEON_ENV_VAR_KEYS, u as isFunctionBaseUrlKey } from "../_chunks/env-N19A7qND.js";
 import { ENV_PULL_KEY_HELP, ENV_PULL_SERVICES, envKeysForSelection, envPullFlagValue, ownedEnvServiceKeys, parseEnvPullKeys } from "../env_services.js";
+import { i as dropClaimableUnsupported, o as resolveNeonEnvVars } from "../_chunks/env-BgiaRNT1.js";
 import { fillSingleProject, resolveBranchRef } from "../utils/enrichers.js";
 import { warnAiGateway } from "../utils/ai_gateway_notice.js";
 import { announceTargetBranch } from "../utils/branch_notice.js";
-import { i as dropClaimableUnsupported, o as resolveNeonEnvVars } from "../_chunks/env-BgiaRNT1.js";
 import { existsSync } from "node:fs";
 import chalk from "chalk";
 //#region src/commands/env.ts

package/dist/index.js

@@ -5,7 +5,7 @@ import { getAuthContext } from "./auth_context.js";
 import { r as defaultDir } from "./_chunks/paths-DMq0Lt7a.js";
 import { ensureConfigDir } from "./config.js";
 import { currentContextFile, enrichFromContext } from "./context.js";
-import { analyticsMiddleware, closeAnalytics, commandSuccessProperties, initAnalyticsClientMiddleware, sendError, takeCommandSuccessExtras, trackEvent } from "./analytics.js";
+import { analyticsMiddleware, closeAnalytics, initAnalyticsClientMiddleware, sendError, takeCommandSuccessExtras, trackCommandSuccess } from "./analytics.js";
 import { NETWORK_ERROR_MESSAGE, isNetworkError, matchErrorCode } from "./errors.js";
 import { AuthRefreshError, defaultClientID } from "./auth.js";
 import { getCliName } from "./utils/cli_name.js";
@@ -199,7 +199,7 @@ async function handleError(msg, err, canRetry) {
 	await preloadCommand(builder, hideBin(process.argv));
 	while (attempts < MAX_ATTEMPTS) try {
 		const args = await builder.argv;
-		trackEvent("cli_command_success", commandSuccessProperties(args));
+		trackCommandSuccess(args);
 		if (args._.length === 0 || args.help) {
 			await showHelp(builder);
 			process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neon",
-  "version": "8.0.4",
+  "version": "8.0.6",
   "description": "CLI tool for Neon, the cloud backend primitives built around Lakebase Postgres",
   "keywords": [
     "neon",
@@ -64,9 +64,9 @@
     "yaml": "^2.9.0",
     "yargs": "17.7.2",
     "yoctocolors": "^2.1.2",
-    "@neon/config": "1.8.3",
-    "@neon/config-runtime": "1.7.3",
-    "@neon/sdk": "7.0.0"
+    "@neon/config-runtime": "1.7.4",
+    "@neon/sdk": "7.0.0",
+    "@neon/config": "1.8.3"
   },
   "optionalDependencies": {
     "@napi-rs/keyring": "1.3.0",
@@ -99,8 +99,8 @@
     "tsx": "4.22.3",
     "typescript": "^5.9.0",
     "vitest": "^3.0.9",
-    "@neon-internals/cli-core": "0.0.0",
     "@neon-internals/env-core": "0.0.26",
+    "@neon-internals/cli-core": "0.0.0",
     "@neon/e2e-harness": "0.0.0",
     "@neon/functions": "0.11.0"
   },