neon 6.2.4 → 6.4.0

package/dist/config_edit.js

@@ -0,0 +1,237 @@
+import { SourceScanError, classify, entryObject, findConfigObject, findEntry, isCodeAt, isCommentAt, lineIndent, lineStart, scanObject } from "./config_source.js";
+import { renderKey } from "./config_template.js";
+//#region src/config_edit.ts
+/**
+* Edits to an existing `neon.ts`, applied as text splices so comments, formatting, and every
+* property the edit does not name survive untouched. The file is never regenerated.
+*
+* Each edit either declares something new, flips a disabled toggle on, or reports that the
+* file already declares it (`changes` is empty). A file whose layout the scanner cannot
+* place an edit into is refused with the exact lines to add by hand.
+*/
+var ConfigEditError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ConfigEditError";
+	}
+};
+/** Top-level keys in the order the starter policy writes them. New keys land in this order. */
+const KEY_ORDER = [
+	"auth",
+	"dataApi",
+	"aiGateway",
+	"functions",
+	"buckets",
+	"triggers",
+	"preview",
+	"branch",
+	"experimental"
+];
+const keyRank = (key) => key === void 0 ? -1 : KEY_ORDER.indexOf(key);
+const unsupported = (reason, snippet) => {
+	throw new ConfigEditError(`Cannot edit this neon.ts automatically: ${reason}\nDeclare it by hand:\n\n${snippet.map((line) => `  ${line}`).join("\n")}`);
+};
+const parse = (source) => {
+	try {
+		const kinds = classify(source);
+		const root = assertPlain(scanObject(source, kinds, findConfigObject(source, kinds)));
+		const first = root.entries[0];
+		const base = lineIndent(source, root.open);
+		const firstIndent = first ? lineIndent(source, first.start) : base;
+		const unit = firstIndent.startsWith(base) && firstIndent.length > base.length ? firstIndent.slice(base.length) : "  ";
+		return {
+			source,
+			kinds,
+			root,
+			eol: source.includes("\r\n") ? "\r\n" : "\n",
+			unit
+		};
+	} catch (error) {
+		if (error instanceof SourceScanError) throw new ConfigEditError(`Cannot edit this neon.ts automatically: ${error.message}.`);
+		throw error;
+	}
+};
+/**
+* A spread, a computed key, or a repeated key can override the property an edit just wrote,
+* so the effective value cannot be read from the text.
+*/
+const assertPlain = (scan) => {
+	const seen = /* @__PURE__ */ new Set();
+	for (const entry of scan.entries) {
+		if (entry.key === void 0 || seen.has(entry.key)) throw new ConfigEditError("Cannot edit this neon.ts automatically: an object it edits has a spread, computed, or repeated property that could override the edit.");
+		seen.add(entry.key);
+	}
+	return scan;
+};
+/** The object literal `entry` holds, or `undefined` when its value is anything else. */
+const objectOf = (parsed, entry) => {
+	const scan = entry.keyed ? entryObject(parsed.source, parsed.kinds, entry) : void 0;
+	return scan && assertPlain(scan);
+};
+const startsLine = (source, index) => source.slice(lineStart(source, index), index).trim() === "";
+/**
+* Where a new entry goes, as a splice into `parsed.source`. `before` places it above that
+* entry (and above the comment lines that describe it); without it the entry is appended.
+*/
+const insertEntry = (parsed, scan, lines, snippet, before) => {
+	const { source, kinds, eol, unit } = parsed;
+	const baseIndent = lineIndent(source, scan.open);
+	const first = scan.entries[0];
+	if (!first) {
+		if (source.slice(scan.open + 1, scan.close).trim() !== "") return unsupported("the object it goes in holds only comments.", snippet);
+		const indent = baseIndent + unit;
+		return source.slice(0, scan.open + 1) + eol + lines.map((line) => indent + line).join(eol) + eol + baseIndent + source.slice(scan.close);
+	}
+	const last = scan.entries[scan.entries.length - 1];
+	if (!startsLine(source, first.start) || !source.slice(last.end, scan.close).includes("\n")) return unsupported("the object it goes in is not laid out one property per line.", snippet);
+	const indent = lineIndent(source, first.start);
+	if (before) {
+		if (!startsLine(source, before.start)) return unsupported("a property sharing its line with another one.", snippet);
+		let at = lineStart(source, before.start);
+		while (at > 0) {
+			const previous = lineStart(source, at - 1);
+			const text = source.slice(previous, at);
+			const marker = previous + text.search(/\S|$/);
+			if (previous <= scan.open || !text.trim().startsWith("//") || !isCommentAt(kinds, marker)) break;
+			at = previous;
+		}
+		return source.slice(0, at) + lines.map((line) => indent + line + eol).join("") + source.slice(at);
+	}
+	let lineEnd = source.indexOf("\n", last.end);
+	if (source[lineEnd - 1] === "\r") lineEnd--;
+	let hasComma = false;
+	for (let i = last.end; i < scan.close; i++) {
+		if (!isCodeAt(kinds, i) || source[i] !== ",") continue;
+		if (i >= lineEnd) return unsupported("a trailing comma on a line of its own.", snippet);
+		hasComma = true;
+	}
+	return source.slice(0, last.end) + (hasComma ? "" : ",") + source.slice(last.end, lineEnd) + eol + lines.map((line) => indent + line).join(eol) + source.slice(lineEnd);
+};
+/** The first top-level entry that belongs after `key` in the starter policy's order. */
+const entryAfter = (parsed, key) => parsed.root.entries.find((entry) => keyRank(entry.key) > keyRank(key));
+/**
+* `preview` still accepts `aiGateway`, `functions`, and `buckets`, and declaring the same key
+* in both places fails validation. Adding to the other home would break the file.
+*/
+const assertNotUnderPreview = (parsed, key, snippet) => {
+	const preview = findEntry(parsed.root, "preview");
+	if (!preview) return;
+	const scan = objectOf(parsed, preview);
+	if (!scan) {
+		unsupported(`preview is not an object literal, so it may already declare ${key}.`, snippet);
+		return;
+	}
+	if (findEntry(scan, key)) unsupported(`${key} is declared under the deprecated \`preview\` block. Lift it to the top level first.`, snippet);
+};
+const readToggle = (parsed, entry, key, snippet) => {
+	const { source } = parsed;
+	const value = source.slice(entry.valueStart, entry.valueEnd);
+	if (entry.keyed && value === "true") return { on: true };
+	if (entry.keyed && value === "false") return {
+		on: false,
+		span: [entry.valueStart, entry.valueEnd],
+		path: key
+	};
+	const object = objectOf(parsed, entry);
+	if (!object) return unsupported(`${key} is set to an expression, not true or false.`, snippet);
+	const enabled = findEntry(object, "enabled");
+	if (!enabled) return { on: true };
+	const flag = source.slice(enabled.valueStart, enabled.valueEnd);
+	if (enabled.keyed && flag === "true") return { on: true };
+	if (enabled.keyed && flag === "false") return {
+		on: false,
+		span: [enabled.valueStart, enabled.valueEnd],
+		path: `${key}.enabled`
+	};
+	return unsupported(`${key}.enabled is set to an expression, not true or false.`, snippet);
+};
+const setToggle = (parsed, key) => {
+	const snippet = [`${key}: true,`];
+	if (key === "aiGateway") assertNotUnderPreview(parsed, key, snippet);
+	const entry = findEntry(parsed.root, key);
+	if (!entry) return {
+		source: insertEntry(parsed, parsed.root, snippet, snippet, entryAfter(parsed, key)),
+		change: `added ${key}: true`
+	};
+	const toggle = readToggle(parsed, entry, key, snippet);
+	if (toggle.on) return { source: parsed.source };
+	const [from, to] = toggle.span;
+	return {
+		source: parsed.source.slice(0, from) + "true" + parsed.source.slice(to),
+		change: `set ${toggle.path}: false → true`
+	};
+};
+/**
+* Whether `dataApi` verifies a third-party IdP, in which case it does not need Neon Auth. An
+* `authProvider` that is neither literal is refused rather than assumed to be Neon's.
+*/
+const dataApiIsExternal = (parsed) => {
+	const entry = findEntry(parsed.root, "dataApi");
+	const object = entry ? objectOf(parsed, entry) : void 0;
+	const provider = object ? findEntry(object, "authProvider") : void 0;
+	if (!provider) return false;
+	const value = parsed.source.slice(provider.valueStart, provider.valueEnd).replace(/\s+as\s+const$/, "");
+	if (provider.keyed && /^["']external["']$/.test(value)) return true;
+	if (provider.keyed && /^["']neon["']$/.test(value)) return false;
+	return unsupported("dataApi.authProvider is set to an expression.", ["auth: true,", "dataApi: true,"]);
+};
+/** A named entry (a function or a bucket) inside `functions` / `buckets`. */
+const addNamed = (parsed, container, name, entryLines) => {
+	const block = [
+		`${container}: {`,
+		...entryLines.map((line) => parsed.unit + line),
+		"},"
+	];
+	assertNotUnderPreview(parsed, container, block);
+	const entry = findEntry(parsed.root, container);
+	if (!entry) return {
+		source: insertEntry(parsed, parsed.root, block, block, entryAfter(parsed, container)),
+		change: `added ${container}.${name}`
+	};
+	const object = objectOf(parsed, entry);
+	if (!object) return unsupported(`${container} is not an object literal.`, block);
+	if (findEntry(object, name)) return { source: parsed.source };
+	return {
+		source: insertEntry(parsed, object, entryLines, block),
+		change: `added ${container}.${name}`
+	};
+};
+const apply = (source, edit) => {
+	const steps = [];
+	let current = source;
+	const run = (build) => {
+		const step = build(parse(current));
+		current = step.source;
+		steps.push(step);
+	};
+	switch (edit.kind) {
+		case "service":
+			if (edit.service === "auth") run((parsed) => setToggle(parsed, "auth"));
+			else if (edit.service === "ai-gateway") run((parsed) => setToggle(parsed, "aiGateway"));
+			else {
+				if (!dataApiIsExternal(parse(current))) run((parsed) => setToggle(parsed, "auth"));
+				run((parsed) => setToggle(parsed, "dataApi"));
+			}
+			break;
+		case "function":
+			run((parsed) => addNamed(parsed, "functions", edit.slug, [`${renderKey(edit.slug)}: { name: ${JSON.stringify(edit.name)}, source: ${JSON.stringify(edit.source)} },`]));
+			break;
+		case "bucket": run((parsed) => addNamed(parsed, "buckets", edit.name, [`${renderKey(edit.name)}: { access: ${JSON.stringify(edit.access)} },`]));
+	}
+	return {
+		source: current,
+		changes: steps.flatMap((step) => step.change ? [step.change] : [])
+	};
+};
+/**
+* Apply `edit` to the text of a `neon.ts`. The result is re-read before it is returned: a
+* splice the scanner cannot find its own edit in is a bug in the splice, and it throws
+* instead of handing back a file that does not declare what was asked for.
+*/
+const editNeonConfig = (source, edit) => {
+	const result = apply(source, edit);
+	if (result.changes.length > 0 && apply(result.source, edit).changes.length > 0) throw new ConfigEditError("Editing neon.ts would not produce a file that declares the requested change. Nothing was written.");
+	return result;
+};
+//#endregion
+export { ConfigEditError, editNeonConfig };

package/dist/config_source.js

@@ -0,0 +1,270 @@
+//#region src/config_source.ts
+/**
+* A scanner for the shape of a `neon.ts` file, just deep enough to find the config object
+* literal and the spans of its properties, so an edit can splice text into the file and leave
+* everything else byte-for-byte alone.
+*
+* It is not a JavaScript parser. It classifies every character as code, comment, or literal
+* (string, template text, regex), matches brackets over the code characters, and splits an
+* object literal on its top-level commas. Anything it cannot place with confidence throws
+* {@link SourceScanError}; callers turn that into "edit it by hand" rather than guessing.
+*/
+var SourceScanError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "SourceScanError";
+	}
+};
+const CODE = 0;
+const COMMENT = 1;
+const LITERAL = 2;
+const REGEX_MAY_FOLLOW = /* @__PURE__ */ new Set([..."(,=:[!&|?{};+-*%<>~^"]);
+const REGEX_KEYWORDS = /* @__PURE__ */ new Set([
+	"return",
+	"typeof",
+	"case",
+	"in",
+	"of",
+	"delete",
+	"void",
+	"throw",
+	"new",
+	"else",
+	"do",
+	"yield",
+	"await"
+]);
+const isIdentChar = (char) => /[\w$]/.test(char);
+const isSpace = (char) => /\s/.test(char);
+const unterminated = (what, at) => new SourceScanError(`unterminated ${what} at offset ${at}`);
+/** Whether the `/` at `index` opens a regex literal rather than dividing. */
+const opensRegex = (source, kinds, index) => {
+	let prev = index - 1;
+	while (prev >= 0 && (isSpace(source[prev]) || kinds[prev] === COMMENT)) prev--;
+	if (prev < 0) return true;
+	if (kinds[prev] === LITERAL) return false;
+	const char = source[prev];
+	if (isIdentChar(char)) {
+		let start = prev;
+		while (start > 0 && isIdentChar(source[start - 1])) start--;
+		return REGEX_KEYWORDS.has(source.slice(start, prev + 1));
+	}
+	return REGEX_MAY_FOLLOW.has(char);
+};
+/** Classify every character of `source` as code, comment, or literal. */
+const classify = (source) => {
+	const kinds = new Uint8Array(source.length);
+	const length = source.length;
+	const templateDepths = [];
+	const mark = (from, to, kind) => {
+		kinds.fill(kind, from, to);
+	};
+	const scanTemplateText = (from) => {
+		let i = from + 1;
+		while (i < length) if (source[i] === "\\") i += 2;
+		else if (source[i] === "`") {
+			mark(from, i + 1, LITERAL);
+			return i + 1;
+		} else if (source[i] === "$" && source[i + 1] === "{") {
+			mark(from, i + 2, LITERAL);
+			templateDepths.push({
+				start: i,
+				depth: 0
+			});
+			return i + 2;
+		} else i++;
+		throw unterminated("template literal", from);
+	};
+	let i = 0;
+	while (i < length) {
+		const char = source[i];
+		const next = source[i + 1];
+		if (char === "/" && next === "/") {
+			const newline = source.indexOf("\n", i);
+			const end = newline === -1 ? length : newline;
+			mark(i, end, COMMENT);
+			i = end;
+		} else if (char === "/" && next === "*") {
+			const close = source.indexOf("*/", i + 2);
+			if (close === -1) throw unterminated("block comment", i);
+			mark(i, close + 2, COMMENT);
+			i = close + 2;
+		} else if (char === "\"" || char === "'") {
+			let j = i + 1;
+			while (j < length && source[j] !== char) {
+				if (source[j] === "\n") throw unterminated("string", i);
+				j += source[j] === "\\" ? 2 : 1;
+			}
+			if (j >= length) throw unterminated("string", i);
+			mark(i, j + 1, LITERAL);
+			i = j + 1;
+		} else if (char === "`") i = scanTemplateText(i);
+		else if (char === "/") {
+			if (!opensRegex(source, kinds, i)) {
+				i++;
+				continue;
+			}
+			let j = i + 1;
+			let inClass = false;
+			while (j < length) {
+				const c = source[j];
+				if (c === "\n") throw unterminated("regular expression", i);
+				if (c === "\\") {
+					j += 2;
+					continue;
+				}
+				if (c === "[") inClass = true;
+				else if (c === "]") inClass = false;
+				else if (c === "/" && !inClass) break;
+				j++;
+			}
+			if (j >= length) throw unterminated("regular expression", i);
+			j++;
+			while (j < length && /[a-z]/i.test(source[j])) j++;
+			mark(i, j, LITERAL);
+			i = j;
+		} else if (char === "{" && templateDepths.length > 0) {
+			templateDepths[templateDepths.length - 1].depth++;
+			i++;
+		} else if (char === "}" && templateDepths.length > 0) {
+			const top = templateDepths[templateDepths.length - 1];
+			if (top.depth === 0) {
+				templateDepths.pop();
+				mark(top.start, i, LITERAL);
+				i = scanTemplateText(i);
+			} else {
+				top.depth--;
+				i++;
+			}
+		} else i++;
+	}
+	if (templateDepths.length > 0) throw unterminated("template expression", length);
+	return kinds;
+};
+const isTrivia = (source, kinds, index) => isSpace(source[index]) || kinds[index] === COMMENT;
+const skipTrivia = (source, kinds, from, to) => {
+	let i = from;
+	while (i < to && isTrivia(source, kinds, i)) i++;
+	return i;
+};
+const trimTriviaEnd = (source, kinds, from, to) => {
+	let i = to;
+	while (i > from && isTrivia(source, kinds, i - 1)) i--;
+	return i;
+};
+const readEntry = (source, kinds, from, to) => {
+	const start = skipTrivia(source, kinds, from, to);
+	if (start >= to) return void 0;
+	const end = trimTriviaEnd(source, kinds, start, to);
+	const other = (key) => ({
+		key,
+		keyed: false,
+		start,
+		end,
+		valueStart: end,
+		valueEnd: end
+	});
+	let key;
+	let afterKey;
+	if (kinds[start] === LITERAL && (source[start] === "\"" || source[start] === "'")) {
+		let close = start;
+		while (close < end && kinds[close] === LITERAL) close++;
+		const inner = source.slice(start + 1, close - 1);
+		if (inner.includes("\\")) return other();
+		key = inner;
+		afterKey = close;
+	} else {
+		const ident = /^[A-Za-z_$][\w$]*/.exec(source.slice(start, end));
+		if (kinds[start] !== CODE || ident === null) return other();
+		key = ident[0];
+		afterKey = start + key.length;
+	}
+	const colon = skipTrivia(source, kinds, afterKey, end);
+	if (colon >= end || source[colon] !== ":" || kinds[colon] !== CODE) return other(key);
+	const valueStart = skipTrivia(source, kinds, colon + 1, end);
+	return {
+		key,
+		keyed: true,
+		start,
+		end,
+		valueStart,
+		valueEnd: end
+	};
+};
+/** Scan the object literal whose `{` is at `open`. */
+const scanObject = (source, kinds, open) => {
+	if (source[open] !== "{" || kinds[open] !== CODE) throw new SourceScanError(`expected an object literal at offset ${open}`);
+	const entries = [];
+	let depth = 0;
+	let entryStart = open + 1;
+	for (let i = open + 1; i < source.length; i++) {
+		if (kinds[i] !== CODE) continue;
+		const char = source[i];
+		if (char === "{" || char === "[" || char === "(") depth++;
+		else if (char === "}" || char === "]" || char === ")") {
+			if (depth > 0) {
+				depth--;
+				continue;
+			}
+			if (char !== "}") throw new SourceScanError(`unbalanced "${char}" at offset ${i}`);
+			const last = readEntry(source, kinds, entryStart, i);
+			if (last) entries.push(last);
+			return {
+				open,
+				close: i,
+				entries
+			};
+		} else if (char === "," && depth === 0) {
+			const entry = readEntry(source, kinds, entryStart, i);
+			if (entry) entries.push(entry);
+			entryStart = i + 1;
+		}
+	}
+	throw new SourceScanError(`object literal at offset ${open} is never closed`);
+};
+/** The entry named `key`, when the object has one. */
+const findEntry = (scan, key) => scan.entries.find((entry) => entry.key === key);
+/**
+* The object literal an entry's value is, or `undefined` when the value is anything else
+* (`true`, an identifier, `{ … } as const`, a call). Only a value that is exactly one object
+* literal can be edited in place.
+*/
+const entryObject = (source, kinds, entry) => {
+	if (!entry.keyed || source[entry.valueStart] !== "{") return void 0;
+	const scan = scanObject(source, kinds, entry.valueStart);
+	return scan.close + 1 === entry.valueEnd ? scan : void 0;
+};
+/**
+* The index of the `{` holding the policy: the argument of the `defineConfig(` call, or the
+* object a bare `export default { … }` exports. More than one candidate is refused, since
+* the first one in the text is not necessarily the one exported.
+*/
+const findConfigObject = (source, kinds) => {
+	const candidates = [];
+	for (const call of source.matchAll(/\bdefineConfig\s*\(/g)) {
+		if (kinds[call.index] !== CODE) continue;
+		const arg = skipTrivia(source, kinds, call.index + call[0].length, source.length);
+		if (source[arg] !== "{") throw new SourceScanError("defineConfig() is not called with an object literal");
+		candidates.push(arg);
+	}
+	for (const exported of source.matchAll(/\bexport\s+default\s+(?=\{)/g)) if (kinds[exported.index] === CODE) candidates.push(exported.index + exported[0].length);
+	if (candidates.length === 0) throw new SourceScanError("no defineConfig({ … }) call found");
+	if (candidates.length > 1) throw new SourceScanError("found more than one config object, so the exported one is ambiguous");
+	return candidates[0];
+};
+/** Start index of the line containing `index`. */
+const lineStart = (source, index) => source.lastIndexOf("\n", index - 1) + 1;
+/**
+* The whitespace that indents the line containing `index`, whatever else is on that line.
+*/
+const lineIndent = (source, index) => {
+	const start = lineStart(source, index);
+	const indent = /^[ \t]*/.exec(source.slice(start));
+	return indent ? indent[0] : "";
+};
+/** Whether the character at `index` is a comment character. */
+const isCommentAt = (kinds, index) => kinds[index] === COMMENT;
+/** Whether the character at `index` is code (not a comment, string, or regex). */
+const isCodeAt = (kinds, index) => kinds[index] === CODE;
+//#endregion
+export { SourceScanError, classify, entryObject, findConfigObject, findEntry, isCodeAt, isCommentAt, lineIndent, lineStart, scanObject };

package/dist/config_template.js

@@ -186,10 +186,18 @@ ${body}
 * `resolveFetchHandler`), and the bare function is less to read and less to get wrong. It is
 * named rather than anonymous so a project's linter has nothing to say about it, and takes no
 * parameter because a scaffold shipping an unused `req` fails a `noUnusedParameters` project.
+*
+* The name is the slug when that is a usable identifier (a slug may start with a digit or be a
+* reserved word such as `default`), and
+* the return type is dropped for a `.js` config, where it would not parse.
 */
-const FUNCTION_TEMPLATE = `export default async function hello(): Promise<Response> {
+const RESERVED_WORDS = new Set("await break case catch class const continue debugger default delete do else enum export extends false finally for function if import in instanceof new null return super switch this throw true try typeof var void while with yield let static implements interface package private protected public eval arguments".split(" "));
+const renderFunctionSource = (slug, language) => {
+	return `export default async function ${/^[A-Za-z_$][\w$]*$/.test(slug) && !RESERVED_WORDS.has(slug) ? slug : "handler"}()${language === "ts" ? ": Promise<Response>" : ""} {
   return new Response("Hello from Neon Functions");
 }
 `;
+};
+const FUNCTION_TEMPLATE = renderFunctionSource(FUNCTION_SLUG, "ts");
 //#endregion
-export { BUCKET_NAME, CONFIG_INIT_NONE_MEANS, CONFIG_INIT_SERVICES, CONFIG_INIT_UNAVAILABLE, CONFIG_PACKAGE, ENV_PACKAGE, FUNCTION_FILENAME, FUNCTION_NAME, FUNCTION_SLUG, FUNCTION_TEMPLATE, REQUIRED_PACKAGES, renderNeonConfig, renderNeonConfigFromView };
+export { BUCKET_NAME, CONFIG_INIT_NONE_MEANS, CONFIG_INIT_SERVICES, CONFIG_INIT_UNAVAILABLE, CONFIG_PACKAGE, ENV_PACKAGE, FUNCTION_FILENAME, FUNCTION_NAME, FUNCTION_SLUG, FUNCTION_TEMPLATE, REQUIRED_PACKAGES, renderFunctionSource, renderKey, renderNeonConfig, renderNeonConfigFromView };

package/dist/context.js

@@ -37,6 +37,11 @@ const isCurrentBranchProbe = (args) => args.currentBranch === true && (args._[0]
 */
 const isConfigInit = (args) => args._[0] === "config" && args._[1] === "init" && args.fromBranch !== true && !process.argv.includes("--from-branch");
 /**
+* `config add` edits the local `neon.ts` and never calls the Neon API, so the global auth
+* middleware and the single-project resolver skip it, like {@link isConfigInit}.
+*/
+const isConfigAdd = (args) => args._[0] === "config" && args._[1] === "add";
+/**
 * `neon profile …` manages credentials on disk and never calls the Neon API, so the global
 * auth middleware must skip it — mirroring {@link isConfigInit}.
 *
@@ -350,4 +355,4 @@ const globToRegExp = (pattern) => {
 	return new RegExp(`^${source}$`);
 };
 //#endregion
-export { CONTEXT_FILE, applyContext, contextBranch, currentContextFile, enrichFromContext, ensureDirectoryGitignored, ensureGitignored, gitBranchMap, gitBranchMapping, isApiKeysCommand, isAskCommand, isClaimCommand, isConfigInit, isCurrentBranchProbe, isGitLocalCommand, isInspectDbUrl, isMcpCommand, isMcpOauth, isPluginsCommand, isProfileCommand, isSkillsCommand, isUnfollowedGitHookSync, readContextFile, setContext, setGitBranchMap, setGitBranchMapping, setGitFollow, updateContextFile, walkContextFile };
+export { CONTEXT_FILE, applyContext, contextBranch, currentContextFile, enrichFromContext, ensureDirectoryGitignored, ensureGitignored, gitBranchMap, gitBranchMapping, isApiKeysCommand, isAskCommand, isClaimCommand, isConfigAdd, isConfigInit, isCurrentBranchProbe, isGitLocalCommand, isInspectDbUrl, isMcpCommand, isMcpOauth, isPluginsCommand, isProfileCommand, isSkillsCommand, isUnfollowedGitHookSync, readContextFile, setContext, setGitBranchMap, setGitBranchMapping, setGitFollow, updateContextFile, walkContextFile };

package/dist/index.js

@@ -1,6 +1,6 @@
 import { log } from "./log.js";
 import pkg_default from "./pkg.js";
-import { isNeonApiError, messageFromBody } from "./api.js";
+import { codeFromBody, isNeonApiError, messageFromBody } from "./api.js";
 import { getAuthContext } from "./auth_context.js";
 import { r as defaultDir } from "./_chunks/paths-DMq0Lt7a.js";
 import { ensureConfigDir } from "./config.js";
@@ -14,6 +14,7 @@ import { recoverFrom401 } from "./auth_recovery.js";
 import { showHelp } from "./help.js";
 import { rewriteUnknownAgentArg } from "./init/plan.js";
 import commands_default from "./commands/index.js";
+import { recoverFromSSO } from "./sso_recovery.js";
 import { notifyIfUpdateAvailable } from "./update_notifier.js";
 import { fillInArgs, resolveApiKeyFromEnv } from "./utils/middlewares.js";
 import yargs from "yargs";
@@ -165,6 +166,10 @@ async function handleError(msg, err, canRetry) {
 			log.error("Request timed out");
 			sendError(err, "REQUEST_TIMEOUT");
 			return false;
+		} else if (codeFromBody(err.data) === "SSO_AUTHORIZATION_REQUIRED" || codeFromBody(err.data) === "SSO_ORG_CREDS_ONLY") {
+			if (await recoverFromSSO(err, canRetry)) return true;
+			sendError(err, "AUTH_FAILED");
+			return false;
 		} else if (err.status === 401) {
 			sendError(err, "AUTH_FAILED");
 			return await recoverFrom401(canRetry);

package/dist/init/chrome.js

@@ -49,6 +49,8 @@ const printInitDone = (text) => {
 const agentSetupLabel = (setup) => {
 	if (setup === "plugin") return "plugin";
 	if (setup === "skills-mcp") return "skills and MCP";
+	if (setup === "skills") return "skills";
+	if (setup === "mcp") return "MCP";
 	return "skipped";
 };
 const agentSetupDoneLabel = (input) => {
@@ -56,13 +58,31 @@ const agentSetupDoneLabel = (input) => {
 	return agentSetupLabel(input.setup);
 };
 const formatAgentIds = (agents) => agents.join(", ");
+const SETUP_LABELS = {
+	skip: "skipped",
+	plugin: "Neon plugin",
+	skills: "skills",
+	"skills-mcp": "skills and MCP",
+	mixed: "plugin and skills/MCP"
+};
+/** Names the agents behind each mechanism, since init picks skills and MCP agents separately. */
 const agentsRowValue = (input) => {
-	if (input.setup === null || input.setup === "skip") return "skipped";
-	if (input.setup === "skills") return "default Neon skills in this directory";
-	const ids = formatAgentIds(input.agents);
-	if (input.setup === "plugin") return ids.length > 0 ? `Neon plugin: ${ids}` : "Neon plugin";
-	if (input.setup === "skills-mcp") return ids.length > 0 ? `skills and MCP: ${ids}` : "skills and MCP";
-	return ids.length > 0 ? `plugin and skills/MCP: ${ids}` : "plugin and skills/MCP";
+	const { tooling } = input;
+	const parts = [];
+	const add = (label, ids) => {
+		const ran = ids.filter((id) => input.installed.includes(id));
+		if (ran.length > 0) parts.push(`${label}: ${formatAgentIds(ran)}`);
+	};
+	if (tooling.setup === "plugin" || tooling.setup === "skills") add(SETUP_LABELS[tooling.setup], tooling.agents);
+	else if (tooling.setup === "skills-mcp" || tooling.setup === "mixed") {
+		if (tooling.setup === "mixed") add("Neon plugin", tooling.pluginAgents);
+		if (tooling.skillsAgents.length === tooling.mcpAgents.length && tooling.skillsAgents.every((id) => tooling.mcpAgents.includes(id))) add("skills and MCP", tooling.skillsAgents);
+		else {
+			add("skills", tooling.skillsAgents);
+			add("MCP", tooling.mcpAgents);
+		}
+	}
+	return parts.length > 0 ? parts.join("; ") : SETUP_LABELS[tooling.setup];
 };
 const projectRowValue = (link) => {
 	switch (link) {

package/dist/init/copy.js

@@ -16,6 +16,12 @@ const AGENT_SETUP_SKIP_DESCRIPTION = "Continue to project setup without changing
 const AGENT_PICKER_MESSAGE = "Which coding agents should receive Neon tooling? (space to toggle, enter to confirm)";
 const AGENT_DETECTED_DESCRIPTION = "Detected on this machine or in this directory.";
 const AGENT_OTHER_DESCRIPTION = "Install for this agent.";
+const agentMissingCommandDescription = (command) => `Detected, but "${command}" was not found on PATH. Its plugin cannot install.`;
+const AGENT_PLUGIN_SKIP_MESSAGE = "No agents selected. Continue without installing the Neon plugin?";
+const AGENT_SKILLS_PICKER_MESSAGE = "Which coding agents should receive Neon skills? (space to toggle, enter to confirm)";
+const AGENT_MCP_PICKER_MESSAGE = "Which coding agents should receive the Neon MCP server? (space to toggle, enter to confirm)";
+const AGENT_SKILLS_SKIP_MESSAGE = "No agents selected. Continue without installing Neon skills?";
+const AGENT_MCP_SKIP_MESSAGE = "No agents selected. Continue without configuring the Neon MCP server?";
 const SKILLS_PICKER_MESSAGE = "Which Neon skills should be installed? (space to toggle, enter to confirm)";
 const MCP_SCOPE_MESSAGE = "Where should the Neon MCP server be configured?";
 const MCP_SCOPE_GLOBAL_TITLE = "User configuration";
@@ -130,4 +136,4 @@ const headingForOutcome = (outcome) => {
 	}
 };
 //#endregion
-export { AGENT_DETECTED_DESCRIPTION, AGENT_OTHER_DESCRIPTION, AGENT_PICKER_MESSAGE, AGENT_SETUP_MESSAGE, AGENT_SETUP_PLUGIN_DESCRIPTION, AGENT_SETUP_PLUGIN_TITLE, AGENT_SETUP_SKILLS_DESCRIPTION, AGENT_SETUP_SKILLS_TITLE, AGENT_SETUP_SKIP_DESCRIPTION, AGENT_SETUP_SKIP_TITLE, CANCELLED_BODY, CLAIMABLE_ACCOUNT_FLAGS, CLAIMABLE_ALREADY_LINKED, CLAIMABLE_MCP_API_KEY, CLAIMABLE_NO_LINK, CONFIG_CONFIRM_HINT, CONFIG_CONFIRM_MESSAGE, HEADING_CANCELLED, HEADING_COMPLETE, HEADING_FAILED, HEADING_PENDING, INIT_SUBTITLE, MCP_AUTH_API_KEY_DESCRIPTION, MCP_AUTH_API_KEY_TITLE, MCP_AUTH_MESSAGE, MCP_AUTH_OAUTH_DESCRIPTION, MCP_AUTH_OAUTH_TITLE, MCP_SCOPED_NEEDS_PROJECT, MCP_SCOPE_GLOBAL_DESCRIPTION, MCP_SCOPE_GLOBAL_TITLE, MCP_SCOPE_MESSAGE, MCP_SCOPE_PROJECT_DESCRIPTION, MCP_SCOPE_PROJECT_TITLE, MODE_CUSTOM_DESCRIPTION, MODE_CUSTOM_TITLE, MODE_MESSAGE, MODE_RECOMMENDED_DESCRIPTION, MODE_RECOMMENDED_TITLE, NON_TTY_AGENT_SETUP, NON_TTY_LINK_NEEDS_AUTH, NO_AGENTS_FALLBACK_STATUS, NO_AGENT_SETUP_CONFLICT, PACKAGE_MANAGER_MESSAGE, PROGRESS, PROJECT_SETUP_CLAIMABLE_DESCRIPTION, PROJECT_SETUP_CLAIMABLE_TITLE, PROJECT_SETUP_LINK_DESCRIPTION, PROJECT_SETUP_LINK_TITLE, PROJECT_SETUP_MESSAGE, SERVICES_HINT, SERVICES_MESSAGE, SKILLS_PICKER_MESSAGE, YES_LINK_NEEDS_AUTH, claimableNext, claimableThenServicesNext, envPullFailedNext, existingConfigNext, extraServicesNext, headingForOutcome, installFailedNext, mcpConfigLocationSkipped, mcpConfigLocationUnavailable, namedAgentsUnavailable, skippedLinkNext, unattendedUnauthedNext };
+export { AGENT_DETECTED_DESCRIPTION, AGENT_MCP_PICKER_MESSAGE, AGENT_MCP_SKIP_MESSAGE, AGENT_OTHER_DESCRIPTION, AGENT_PICKER_MESSAGE, AGENT_PLUGIN_SKIP_MESSAGE, AGENT_SETUP_MESSAGE, AGENT_SETUP_PLUGIN_DESCRIPTION, AGENT_SETUP_PLUGIN_TITLE, AGENT_SETUP_SKILLS_DESCRIPTION, AGENT_SETUP_SKILLS_TITLE, AGENT_SETUP_SKIP_DESCRIPTION, AGENT_SETUP_SKIP_TITLE, AGENT_SKILLS_PICKER_MESSAGE, AGENT_SKILLS_SKIP_MESSAGE, CANCELLED_BODY, CLAIMABLE_ACCOUNT_FLAGS, CLAIMABLE_ALREADY_LINKED, CLAIMABLE_MCP_API_KEY, CLAIMABLE_NO_LINK, CONFIG_CONFIRM_HINT, CONFIG_CONFIRM_MESSAGE, HEADING_CANCELLED, HEADING_COMPLETE, HEADING_FAILED, HEADING_PENDING, INIT_SUBTITLE, MCP_AUTH_API_KEY_DESCRIPTION, MCP_AUTH_API_KEY_TITLE, MCP_AUTH_MESSAGE, MCP_AUTH_OAUTH_DESCRIPTION, MCP_AUTH_OAUTH_TITLE, MCP_SCOPED_NEEDS_PROJECT, MCP_SCOPE_GLOBAL_DESCRIPTION, MCP_SCOPE_GLOBAL_TITLE, MCP_SCOPE_MESSAGE, MCP_SCOPE_PROJECT_DESCRIPTION, MCP_SCOPE_PROJECT_TITLE, MODE_CUSTOM_DESCRIPTION, MODE_CUSTOM_TITLE, MODE_MESSAGE, MODE_RECOMMENDED_DESCRIPTION, MODE_RECOMMENDED_TITLE, NON_TTY_AGENT_SETUP, NON_TTY_LINK_NEEDS_AUTH, NO_AGENTS_FALLBACK_STATUS, NO_AGENT_SETUP_CONFLICT, PACKAGE_MANAGER_MESSAGE, PROGRESS, PROJECT_SETUP_CLAIMABLE_DESCRIPTION, PROJECT_SETUP_CLAIMABLE_TITLE, PROJECT_SETUP_LINK_DESCRIPTION, PROJECT_SETUP_LINK_TITLE, PROJECT_SETUP_MESSAGE, SERVICES_HINT, SERVICES_MESSAGE, SKILLS_PICKER_MESSAGE, YES_LINK_NEEDS_AUTH, agentMissingCommandDescription, claimableNext, claimableThenServicesNext, envPullFailedNext, existingConfigNext, extraServicesNext, headingForOutcome, installFailedNext, mcpConfigLocationSkipped, mcpConfigLocationUnavailable, namedAgentsUnavailable, skippedLinkNext, unattendedUnauthedNext };

package/dist/init/mode.js

@@ -18,10 +18,8 @@ const assertAgentSetupFlags = (input) => {
 };
 const inferInitAgentSetup = (input) => {
 	if (input.skipAgents) return { kind: "skip" };
-	const hasSkills = hasSkillsFlag(input.skills);
-	if (hasSkills && input.hasMcpFlags) return { kind: "skills-mcp" };
-	if (hasSkills) return { kind: "skills" };
 	if (input.hasMcpFlags) return { kind: "skills-mcp" };
+	if (hasSkillsFlag(input.skills)) return { kind: "skills" };
 	if (input.namedAgents || input.yes) return { kind: "auto" };
 	if (input.canAsk) return { kind: "ask" };
 	throw new Error(NON_TTY_AGENT_SETUP);