neon 8.11.0 → 8.11.2

package/dist/_chunks/set_context-DbrwoImy.js

@@ -0,0 +1,38 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { log } from "../log.js";
+import { applyContext } from "../context.js";
+import { getCliName } from "../utils/cli_name.js";
+//#region src/commands/set_context.ts
+var set_context_exports = /* @__PURE__ */ __exportAll({
+	builder: () => builder,
+	command: () => command,
+	describe: () => describe,
+	handler: () => handler
+});
+const command = "set-context";
+const describe = `Deprecated: use \`${getCliName()} link\`. Set the .neon context (raw write).`;
+const builder = (argv) => argv.usage("$0 set-context [options]").options({
+	"project-id": {
+		describe: "Project ID",
+		type: "string"
+	},
+	"org-id": {
+		describe: "Organization ID",
+		type: "string"
+	},
+	"branch-id": {
+		describe: "Branch ID",
+		type: "string"
+	}
+});
+const handler = (props) => {
+	log.warning(`\`${getCliName()} set-context\` is deprecated and will be removed in a future release. Use \`${getCliName()} link\` instead — it verifies inputs and writes a complete context (or \`${getCliName()} link --no-checks --org-id … --project-id … --branch …\` for an offline write).`);
+	const context = {
+		projectId: props.projectId,
+		orgId: props.orgId,
+		branchId: props.branchId
+	};
+	applyContext(props.contextFile, context);
+};
+//#endregion
+export { set_context_exports as a, handler as i, command as n, describe as r, builder as t };

package/dist/_chunks/skills-DyiBXKS3.js

@@ -0,0 +1,255 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { log } from "../log.js";
+import { recordCommandSuccessExtras } from "../analytics.js";
+import { helpCsv, helpEpilogue } from "../utils/help_text.js";
+import { getAgentDisplayName } from "../mcp/agents.js";
+import "../init/agents.js";
+import { mappedSkillsAgentNames, skillsInstallableAgents } from "../skills/targets.js";
+import { writer } from "../writer.js";
+import { noPassthrough } from "../utils/flags.js";
+import { AGENT_SKILLS_SKIP_MESSAGE } from "../init/copy.js";
+import { canPickAgentsInteractively, skippableAgentPicker } from "../utils/agent_picker.js";
+import { skillsHelpValues, skillsYesHelp } from "../skills/catalog.js";
+import { confirmSkillsUpdate } from "../skills/wizard.js";
+import { assertSkillsCanRun, resolveSkillsPlan } from "../skills/plan.js";
+import { assertSkillsNode, neonSkillsRetryCommand, neonSkillsUpdateRetryCommand, runSkillsCli, skillsAddArgs, skillsMetadata, skillsUpdateArgs, skillsUpdateDetail, skillsUpdateHadNothing } from "../skills/run.js";
+//#region src/commands/skills.ts
+var skills_exports = /* @__PURE__ */ __exportAll({
+	aliases: () => aliases,
+	builder: () => builder,
+	command: () => command,
+	describe: () => describe,
+	handler: () => handler,
+	installSkills: () => installSkills,
+	reportSkillsInstall: () => reportSkillsInstall,
+	skillsInstallError: () => skillsInstallError
+});
+const scopeLabel = (scope) => scope === "project" ? "this directory" : "user-level";
+const coerceAgents = (value) => {
+	if (value === void 0) return [];
+	const list = Array.isArray(value) ? value : [value];
+	if (list.length === 0) throw new Error("--agent needs a value. Pass one, or omit the flag entirely.");
+	return list.map((item) => {
+		if (typeof item !== "string" || item.trim() === "") throw new Error("--agent needs a value. Pass one, or omit the flag entirely.");
+		return item;
+	});
+};
+const coerceSkills = (value) => {
+	if (value === void 0) return [];
+	const list = Array.isArray(value) ? value : [value];
+	if (list.length === 0) throw new Error("--skill needs a value. Pass one, or omit the flag entirely.");
+	return list.map((item) => {
+		if (typeof item !== "string" || item.trim() === "") throw new Error("--skill needs a value. Pass one, or omit the flag entirely.");
+		return item;
+	});
+};
+const command = "skills";
+const aliases = ["skill"];
+const describe = "Install Neon agent skills into coding agents";
+const builder = (argv) => argv.usage("$0 skills [command] [options]").command("update", "Update installed skills to the latest versions", (yargs) => yargs.usage("$0 skills update [options]").options({
+	yes: { describe: "Skip the confirm prompt" },
+	global: {
+		type: "boolean",
+		default: false,
+		describe: "Update user-level skills (skills CLI -g). Default is this directory"
+	}
+}).example("$0 skills update", "Interactive: confirm, then update skills in this directory").example("$0 skills update -y", "Update skills in this directory without prompting").example("$0 skills update --global -y", "Update user-level skills").strict().hide("agent").hide("skill").check((args) => {
+	noPassthrough("skills update")(args);
+	const agents = args.agent;
+	if (Array.isArray(agents) && agents.length > 0) throw new Error("neon skills update does not take --agent. It refreshes every installed skill in this directory (or --global).");
+	const skills = args.skill;
+	if (Array.isArray(skills) && skills.length > 0) throw new Error("neon skills update does not take --skill. It refreshes every installed skill in this directory (or --global).");
+	return true;
+}), (args) => updateHandler(args)).options({
+	yes: {
+		alias: "y",
+		type: "boolean",
+		default: false,
+		describe: "Skip prompts. Detected agents (project folders, else the host CLI agent). --global uses installed apps, else the host CLI agent"
+	},
+	global: {
+		type: "boolean",
+		default: false,
+		describe: "Install user-level skills (skills CLI -g). Default is this directory"
+	},
+	agent: {
+		alias: "a",
+		type: "array",
+		string: true,
+		describe: "Coding agent to install into (repeatable). Skips the agent picker. Values listed below",
+		coerce: coerceAgents
+	},
+	skill: {
+		alias: "s",
+		type: "array",
+		string: true,
+		describe: "Skill to install (repeatable). Skips the skill picker. Does not select agents. Values listed below",
+		coerce: coerceSkills
+	}
+}).example("$0 skills", "Interactive: this directory, then agents, then skills").example("$0 skills -y", "This directory, detected agents (project folders, else the host CLI agent), the default skills").example("$0 skills -y -s neon -s neon-ai-gateway", "Named skills into detected agents").example("$0 skills -s neon -s neon-ai-gateway --agent cursor", "Named skills into a named agent").example("$0 skills --global", "Install user-level skills").epilogue(helpEpilogue(helpCsv("Supported agents", skillsInstallableAgents()), "Supported skills, by source repo:", skillsHelpValues(), skillsYesHelp())).strict().check(noPassthrough("skills"));
+/**
+* Plans and runs the skills install for every resolved source/invocation. No CLI-only
+* concerns here (no `writer` table, no `recordCommandSuccessExtras`): a caller that only
+* wants the outcome — `neon init` / `neon bootstrap` — gets it without rendering a table.
+*/
+const installSkills = async (options) => {
+	assertSkillsNode();
+	const cwd = options.cwd ?? process.cwd();
+	const yes = options.yes === true;
+	const interactive = canPickAgentsInteractively() && !yes;
+	const plan = await resolveSkillsPlan({
+		global: options.global === true,
+		agents: options.agents ?? [],
+		skills: options.skills ?? [],
+		yes,
+		cwd,
+		interactive,
+		pickAgents: skippableAgentPicker(options.allowAgentSkip, AGENT_SKILLS_SKIP_MESSAGE)
+	});
+	const mapped = mappedSkillsAgentNames(plan.agents);
+	for (const agent of plan.skipped) log.warning("Skipping %s: no skills mapping.", getAgentDisplayName(agent));
+	const metadata = skillsMetadata("skills");
+	const rows = [];
+	const failed = [];
+	const scope = scopeLabel(plan.scope);
+	for (const invocation of plan.invocations) {
+		const skills = invocation.skills.join(", ");
+		const args = skillsAddArgs({
+			source: invocation.source,
+			skills: invocation.skills,
+			agents: mapped,
+			global: plan.scope === "global",
+			metadata
+		});
+		try {
+			await runSkillsCli({
+				args,
+				cwd
+			});
+			rows.push({
+				scope,
+				skills,
+				agents: mapped.join(", "),
+				status: "installed"
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			rows.push({
+				scope,
+				skills,
+				agents: mapped.join(", "),
+				status: "failed",
+				error: "skills CLI failed"
+			});
+			failed.push({
+				label: skills,
+				message,
+				skills: invocation.skills
+			});
+		}
+	}
+	return {
+		scope: plan.scope,
+		agents: plan.agents,
+		rows,
+		failed
+	};
+};
+/** The exact error `neon skills` throws for a failed outcome, or `undefined` on success. */
+const skillsInstallError = (outcome) => {
+	const { failed, rows, scope, agents } = outcome;
+	if (failed.length === 0) return;
+	const first = failed[0];
+	if (first === void 0) return /* @__PURE__ */ new Error("Failed to install Neon agent skills.");
+	const retry = neonSkillsRetryCommand({
+		skills: failed.flatMap((row) => row.skills),
+		agents,
+		global: scope === "global"
+	});
+	if (first.message.includes("needs npx (Node.js)") || first.message.includes("needs Node.js")) return new Error(first.message);
+	if (failed.length === rows.length) return /* @__PURE__ */ new Error(`${first.message}\nRetry with: ${retry}`);
+	return /* @__PURE__ */ new Error(`Failed to install Neon agent skills for: ${failed.map((row) => row.label).join(", ")}.\n${first.message}\nRetry with: ${retry}`);
+};
+/** Writes the results table and, on success, the "Wrote ... skills" line. Shared by `neon skills` and any in-process caller that wants the same human output. */
+const reportSkillsInstall = (props, outcome) => {
+	const out = writer(props);
+	out.write(outcome.rows, {
+		fields: [
+			"scope",
+			"skills",
+			"agents",
+			"status",
+			"error"
+		],
+		title: "Skills"
+	});
+	out.end();
+	if (outcome.failed.length === 0) log.info(outcome.scope === "project" ? "Wrote skills in this directory." : "Wrote user-level skills.");
+};
+const handler = async (props) => {
+	const outcome = await installSkills({
+		cwd: props.cwd,
+		yes: props.yes,
+		global: props.global,
+		agents: props.agent,
+		skills: props.skill
+	});
+	reportSkillsInstall(props, outcome);
+	const error = skillsInstallError(outcome);
+	if (error) throw error;
+	recordCommandSuccessExtras({ scope: outcome.scope });
+};
+const updateHandler = async (props) => {
+	assertSkillsNode();
+	const cwd = process.cwd();
+	const yes = props.yes === true;
+	const interactive = canPickAgentsInteractively() && !yes;
+	assertSkillsCanRun({
+		yes,
+		interactive,
+		action: "update"
+	});
+	const scope = props.global === true ? "global" : "project";
+	if (interactive) {
+		if (!await confirmSkillsUpdate({ scope })) {
+			log.info("Aborted. Nothing was written.");
+			return;
+		}
+	}
+	const rows = [];
+	const args = skillsUpdateArgs({ global: scope === "global" });
+	let failure;
+	try {
+		const result = await runSkillsCli({
+			args,
+			cwd
+		});
+		const output = `${result.stdout}\n${result.stderr}`;
+		rows.push({
+			scope: scopeLabel(scope),
+			status: skillsUpdateHadNothing(output) ? "none" : "updated",
+			detail: skillsUpdateDetail(output)
+		});
+	} catch (error) {
+		failure = error instanceof Error ? error.message : String(error);
+		rows.push({
+			scope: scopeLabel(scope),
+			status: "failed",
+			error: "skills CLI failed"
+		});
+	}
+	const out = writer(props);
+	out.write(rows, {
+		fields: [
+			"scope",
+			"status",
+			"detail",
+			"error"
+		],
+		title: "Skills"
+	});
+	out.end();
+	if (failure !== void 0) throw new Error(failure.includes("needs npx (Node.js)") || failure.includes("needs Node.js") ? failure : `${failure}\nRetry with: ${neonSkillsUpdateRetryCommand(scope === "global")}`);
+};
+//#endregion
+export { handler as a, skillsInstallError as c, describe as i, skills_exports as l, builder as n, installSkills as o, command as r, reportSkillsInstall as s, aliases as t };

package/dist/_chunks/snapshots-RJBzW8GM.js

@@ -0,0 +1,338 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { log } from "../log.js";
+import { isNeonApiError, retryOnLock } from "../api.js";
+import { writer } from "../writer.js";
+import { looksLikeBranchId, looksLikeLSN, looksLikeSnapshotId, looksLikeTimestamp, toIso } from "../utils/formats.js";
+import { branchIdResolve, fillSingleProject, resolveBranchRef } from "../utils/enrichers.js";
+import { t as BRANCH_FIELDS } from "./branches-BNa1xX1L.js";
+//#region src/commands/snapshots.ts
+var snapshots_exports = /* @__PURE__ */ __exportAll({
+	SNAPSHOT_FIELDS: () => SNAPSHOT_FIELDS,
+	aliases: () => aliases,
+	builder: () => builder,
+	command: () => command,
+	describe: () => describe,
+	handler: () => handler
+});
+const SNAPSHOT_FIELDS = [
+	"id",
+	"name",
+	"source_branch_id",
+	"expires_at",
+	"created_at"
+];
+const SCHEDULE_FIELDS = [
+	"frequency",
+	"hour",
+	"day",
+	"month",
+	"retention_seconds"
+];
+const OPERATION_FIELDS = [
+	"id",
+	"action",
+	"status"
+];
+const SNAPSHOT_FREQUENCIES = [
+	"daily",
+	"weekly",
+	"monthly"
+];
+const SNAPSHOT_REF = {
+	describe: "Snapshot id or name. An id match wins over a name.",
+	type: "string"
+};
+/** Narrow an arbitrary string to a supported {@link SnapshotFrequency}. */
+const isSnapshotFrequency = (value) => SNAPSHOT_FREQUENCIES.some((frequency) => frequency === value);
+const command = "snapshots";
+const describe = "Manage snapshots";
+const aliases = ["snapshot"];
+const builder = (argv) => argv.usage("$0 snapshots <sub-command> [options]").options({ "project-id": {
+	describe: "Project ID",
+	type: "string"
+} }).middleware(fillSingleProject).command("list", "List snapshots in the project", (yargs) => yargs, (args) => list(args)).command("get <id>", "Get a snapshot by id or name", (yargs) => yargs.positional("id", SNAPSHOT_REF), (args) => get(args)).command("create", "Create a snapshot from a branch", (yargs) => yargs.strict().options({
+	branch: {
+		alias: "b",
+		describe: "Branch id or name to snapshot. Defaults to the branch in your context, or the project's default branch.",
+		type: "string"
+	},
+	name: {
+		describe: "A name for the snapshot",
+		type: "string"
+	},
+	timestamp: {
+		describe: "Take the snapshot at this point in time (RFC 3339, e.g. 2025-01-01T00:00:00Z). Must fall within the branch's restore window. Mutually exclusive with --lsn.",
+		type: "string"
+	},
+	lsn: {
+		describe: "Take the snapshot at this LSN (e.g. 0/1F3C8A0). Must fall within the branch's restore window. Mutually exclusive with --timestamp.",
+		type: "string"
+	},
+	"expires-at": {
+		describe: "When the snapshot is automatically deleted (RFC 3339, e.g. 2025-12-31T23:59:59Z). Omit to keep it indefinitely.",
+		type: "string"
+	}
+}).conflicts("timestamp", "lsn").example([
+	["$0 snapshots create", "Snapshot the head of the context/default branch"],
+	["$0 snapshots create --branch main --name pre-migration", "Snapshot the head of main with a name"],
+	["$0 snapshots create --branch main --timestamp 2025-01-01T00:00:00Z", "Snapshot main at a point in time"],
+	["$0 snapshots create --branch main --lsn 0/1F3C8A0 --expires-at 2025-12-31T23:59:59Z", "Snapshot main at an LSN, auto-deleting at the given time"]
+]), (args) => create(args)).command("update <id>", "Update a snapshot's name or expiration", (yargs) => yargs.positional("id", SNAPSHOT_REF).options({
+	name: {
+		describe: "Rename the snapshot",
+		type: "string"
+	},
+	"expires-at": {
+		describe: "Set when the snapshot expires (RFC 3339). Mutually exclusive with --clear-expiration.",
+		type: "string"
+	},
+	"clear-expiration": {
+		describe: "Clear the expiration so the snapshot is kept indefinitely.",
+		type: "boolean"
+	}
+}).conflicts("expires-at", "clear-expiration"), (args) => update(args)).command("delete <id>", "Delete a snapshot by id or name", (yargs) => yargs.positional("id", SNAPSHOT_REF), (args) => deleteSnapshot(args)).command("restore <id>", "Restore a snapshot into a branch", (yargs) => yargs.positional("id", SNAPSHOT_REF).options({
+	name: {
+		describe: "Name for the newly restored branch. Auto-generated when omitted.",
+		type: "string"
+	},
+	"target-branch": {
+		describe: "Branch id or name to restore the snapshot onto. Defaults to the snapshot's source branch. Recommended when you intend to finalize (replace an existing branch).",
+		type: "string"
+	},
+	finalize: {
+		describe: "Finalize the restore immediately: move computes onto the restored branch and swap it in for the target. Without this, the restore is left un-finalized so you can inspect it first, then run `snapshots finalize <branch>`.",
+		type: "boolean",
+		default: false
+	}
+}).example([
+	["$0 snapshots restore snap-1234 --name recovered", "Restore a snapshot to a new branch named 'recovered'"],
+	["$0 snapshots restore snap-1234 --target-branch main --finalize", "Restore onto main and swap it in immediately"],
+	["$0 snapshots restore snap-1234 --target-branch main", "Restore onto main un-finalized to preview, then run `snapshots finalize`"]
+]), (args) => restore(args)).command("finalize <branch>", "Finalize a previewed snapshot restore (swap the restored branch in)", (yargs) => yargs.options({ name: {
+	describe: "Name to give the replaced (old) branch. Auto-generated when omitted.",
+	type: "string"
+} }), (args) => finalize(args)).command("schedule", "Manage the automatic snapshot (backup) schedule of a branch", (yargs) => yargs.usage("$0 snapshots schedule <sub-command> [options]").command("get", "Get a branch's automatic snapshot schedule", (yargs) => yargs.options({ branch: {
+	alias: "b",
+	describe: "Branch id or name. Defaults to the branch in your context, or the project's default branch.",
+	type: "string"
+} }), (args) => scheduleGet(args)).command("set", "Set a branch's automatic snapshot schedule", (yargs) => yargs.options({
+	branch: {
+		alias: "b",
+		describe: "Branch id or name. Defaults to the branch in your context, or the project's default branch.",
+		type: "string"
+	},
+	frequency: {
+		describe: "How often to take snapshots. Builds a single-entry schedule together with --hour/--day/--month/--retention.",
+		choices: SNAPSHOT_FREQUENCIES,
+		type: "string"
+	},
+	hour: {
+		describe: "Hour of the day (0-23) to take the snapshot (used with --frequency).",
+		type: "number"
+	},
+	day: {
+		describe: "Day of the week/month (1-31) to take the snapshot (used with --frequency).",
+		type: "number"
+	},
+	month: {
+		describe: "Month of the year (1-12) to take the snapshot (used with --frequency).",
+		type: "number"
+	},
+	retention: {
+		describe: "How long to keep each snapshot, in seconds (min 3600). Omit to keep indefinitely.",
+		type: "number"
+	},
+	schedule: {
+		describe: "Full schedule as JSON, for multi-entry schedules, e.g. '[{\"frequency\":\"daily\",\"hour\":3,\"retention_seconds\":604800}]'. Overrides the single-entry flags.",
+		type: "string"
+	}
+}).example([["$0 snapshots schedule set --branch main --frequency daily --hour 3 --retention 604800", "A daily 03:00 snapshot kept for 7 days"], ["$0 snapshots schedule set --branch main --schedule '[{\"frequency\":\"weekly\",\"day\":1,\"hour\":2},{\"frequency\":\"daily\",\"hour\":3}]'", "A multi-entry schedule via JSON"]]), (args) => scheduleSet(args)), () => {});
+const handler = (args) => {
+	return args;
+};
+/** Narrow an unknown parsed JSON value to a plain object without type casting. */
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+* Resolve a snapshot from an id **or** a name. Snapshot names are not guaranteed
+* unique, so an id match wins; a name that resolves to more than one snapshot is a
+* hard error asking the user to disambiguate by id.
+*/
+const resolveSnapshot = async (props) => {
+	const { data: { snapshots } } = await props.apiClient.listSnapshots(props.projectId);
+	const byId = snapshots.find((s) => s.id === props.id);
+	if (byId) return byId;
+	const byName = snapshots.filter((s) => s.name === props.id);
+	if (byName.length === 1) return byName[0];
+	if (byName.length > 1) throw new Error(`Multiple snapshots are named "${props.id}". Re-run with the snapshot id:\n${byName.map((s) => `  ${s.id}`).join("\n")}`);
+	throw new Error(`Snapshot "${props.id}" not found.\nAvailable snapshots: ${snapshots.map((s) => `${s.name} (${s.id})`).join(", ") || "none"}`);
+};
+/**
+* Runs `call` on the snapshot `props.id` names. An id goes straight to the API without the
+* listing; a 404 sends it through {@link resolveSnapshot}, since a name can look like an id.
+* When the listing has that id, the 404 was about something else (a target branch), so it stands.
+*/
+const withSnapshotId = async (props, call) => {
+	let notFound;
+	if (looksLikeSnapshotId(props.id)) try {
+		return await call(props.id);
+	} catch (err) {
+		if (!(isNeonApiError(err) && err.status === 404)) throw err;
+		notFound = err;
+	}
+	const snapshot = await resolveSnapshot(props);
+	if (notFound && snapshot.id === props.id) throw notFound;
+	return call(snapshot.id);
+};
+/** A `br-…` id needs no branch listing; a name or the context/default branch does. */
+const snapshotBranchId = async (props) => props.branch && looksLikeBranchId(props.branch) ? props.branch : (await resolveBranchRef(props)).branchId;
+const list = async (props) => {
+	const { data: { snapshots } } = await props.apiClient.listSnapshots(props.projectId);
+	writer(props).end(snapshots, {
+		fields: SNAPSHOT_FIELDS,
+		title: "snapshots",
+		emptyMessage: "No snapshots found. Create one with:\n> neon snapshots create --help",
+		renderColumns: { expires_at: (s) => s.expires_at || "never" }
+	});
+};
+const get = async (props) => {
+	const snapshot = await resolveSnapshot(props);
+	writer(props).end(snapshot, {
+		fields: SNAPSHOT_FIELDS,
+		renderColumns: { expires_at: (s) => s.expires_at || "never" }
+	});
+};
+const create = async (props) => {
+	if (props.lsn !== void 0 && !looksLikeLSN(props.lsn)) throw new Error(`Invalid --lsn value: "${props.lsn}". Expected an LSN like 0/1F3C8A0.`);
+	if (props.timestamp !== void 0 && !looksLikeTimestamp(props.timestamp)) throw new Error(`Invalid --timestamp value: "${props.timestamp}". Use an RFC 3339 timestamp, e.g. 2025-01-01T00:00:00Z.`);
+	const branchId = await snapshotBranchId(props);
+	const { data } = await retryOnLock(() => props.apiClient.createSnapshot(props.projectId, branchId, {
+		name: props.name,
+		timestamp: props.timestamp,
+		lsn: props.lsn,
+		expires_at: props.expiresAt ? toIso(props.expiresAt, "--expires-at") : void 0
+	}));
+	writer(props).end(data.snapshot, {
+		fields: SNAPSHOT_FIELDS,
+		title: "snapshot",
+		renderColumns: { expires_at: (s) => s.expires_at || "never" }
+	});
+};
+const update = async (props) => {
+	if (props.name === void 0 && props.expiresAt === void 0 && !props.clearExpiration) throw new Error("Nothing to update. Pass --name, --expires-at, or --clear-expiration.");
+	const expiresAt = props.clearExpiration ? null : props.expiresAt !== void 0 ? toIso(props.expiresAt, "--expires-at") : void 0;
+	const { data } = await withSnapshotId(props, (snapshotId) => retryOnLock(() => props.apiClient.updateSnapshot(props.projectId, snapshotId, { snapshot: {
+		name: props.name,
+		expires_at: expiresAt
+	} })));
+	writer(props).end(data.snapshot, {
+		fields: SNAPSHOT_FIELDS,
+		renderColumns: { expires_at: (s) => s.expires_at || "never" }
+	});
+};
+const deleteSnapshot = async (props) => {
+	const snapshot = await resolveSnapshot(props);
+	await retryOnLock(() => props.apiClient.deleteSnapshot(props.projectId, snapshot.id));
+	writer(props).end(snapshot, {
+		fields: SNAPSHOT_FIELDS,
+		renderColumns: { expires_at: (s) => s.expires_at || "never" }
+	});
+};
+const restore = async (props) => {
+	const { data } = await withSnapshotId(props, async (snapshotId) => {
+		const targetBranchId = props.targetBranch ? await branchIdResolve({
+			branch: props.targetBranch,
+			projectId: props.projectId,
+			apiClient: props.apiClient
+		}) : void 0;
+		return retryOnLock(() => props.apiClient.restoreSnapshot(props.projectId, snapshotId, {
+			name: props.name,
+			target_branch_id: targetBranchId,
+			finalize_restore: props.finalize
+		}));
+	});
+	const out = writer(props).write(data.branch, {
+		fields: BRANCH_FIELDS,
+		title: "restored branch"
+	});
+	if (data.operations?.length) out.write(data.operations, {
+		fields: OPERATION_FIELDS,
+		title: "operations"
+	});
+	out.end();
+	if (!props.finalize) log.info(`Restore left un-finalized. Inspect branch ${data.branch.id}, then run:\n  neon snapshots finalize ${data.branch.id} --project-id ${props.projectId}`);
+};
+const finalize = async (props) => {
+	const branchId = await branchIdResolve({
+		branch: props.branch,
+		projectId: props.projectId,
+		apiClient: props.apiClient
+	});
+	const { data } = await retryOnLock(() => props.apiClient.finalizeRestoreBranch(props.projectId, branchId, props.name ? { name: props.name } : void 0));
+	writer(props).end(data.operations ?? [], {
+		fields: OPERATION_FIELDS,
+		title: "operations",
+		emptyMessage: `Finalized restore for branch ${branchId}.`
+	});
+};
+const scheduleGet = async (props) => {
+	const branchId = await snapshotBranchId(props);
+	const { data } = await props.apiClient.getSnapshotSchedule(props.projectId, branchId);
+	writer(props).end(data.schedule, {
+		fields: SCHEDULE_FIELDS,
+		title: "schedule",
+		emptyMessage: "No automatic snapshot schedule is configured."
+	});
+};
+/**
+* Validate an untrusted parsed value as a {@link BackupScheduleItem}[] without any
+* type casting, throwing a clear error for the first invalid field it finds.
+*/
+const parseScheduleJson = (raw) => {
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		throw new Error("--schedule must be valid JSON.");
+	}
+	if (!Array.isArray(parsed)) throw new Error("--schedule must be a JSON array of schedule entries, e.g. '[{\"frequency\":\"daily\",\"hour\":3}]'.");
+	return parsed.map((entry, index) => {
+		if (!isRecord(entry)) throw new Error(`--schedule entry ${index} must be an object.`);
+		const record = entry;
+		const frequency = record.frequency;
+		if (typeof frequency !== "string") throw new Error(`--schedule entry ${index} is missing a string "frequency".`);
+		if (!isSnapshotFrequency(frequency)) throw new Error(`--schedule entry ${index} has an unsupported "frequency": "${frequency}". Use one of: ${SNAPSHOT_FREQUENCIES.join(", ")}.`);
+		const item = { frequency };
+		for (const key of [
+			"hour",
+			"day",
+			"month",
+			"retention_seconds"
+		]) {
+			const value = record[key];
+			if (value === void 0) continue;
+			if (typeof value !== "number") throw new Error(`--schedule entry ${index} field "${key}" must be a number.`);
+			item[key] = value;
+		}
+		return item;
+	});
+};
+const scheduleSet = async (props) => {
+	let schedule;
+	if (props.schedule) schedule = parseScheduleJson(props.schedule);
+	else if (props.frequency) {
+		const item = { frequency: props.frequency };
+		if (props.hour !== void 0) item.hour = props.hour;
+		if (props.day !== void 0) item.day = props.day;
+		if (props.month !== void 0) item.month = props.month;
+		if (props.retention !== void 0) item.retention_seconds = props.retention;
+		schedule = [item];
+	} else throw new Error("Provide --frequency (optionally with --hour/--day/--month/--retention) or --schedule <json>.");
+	const branchId = await snapshotBranchId(props);
+	await retryOnLock(() => props.apiClient.setSnapshotSchedule(props.projectId, branchId, { schedule }));
+	writer(props).end(schedule, {
+		fields: SCHEDULE_FIELDS,
+		title: "schedule"
+	});
+};
+//#endregion
+export { describe as a, command as i, aliases as n, handler as o, builder as r, snapshots_exports as s, SNAPSHOT_FIELDS as t };

package/dist/_chunks/status-DV8Z2kw3.js

@@ -0,0 +1,44 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { fillSingleProject } from "../utils/enrichers.js";
+import { y as status } from "./config-BH_qRHiG.js";
+//#region src/commands/status.ts
+var status_exports = /* @__PURE__ */ __exportAll({
+	builder: () => builder,
+	command: () => command,
+	describe: () => describe,
+	handler: () => handler
+});
+/**
+* `neon status` is a top-level alias for `neon config status` — the most-reached-for
+* config subcommand. It mirrors that command's options (including `--current-branch`,
+* the offline branch probe) and delegates to the same `status` handler.
+*
+* Because it has a handler but no subcommands, `status` must also be listed in
+* `NO_SUBCOMMANDS_VERBS` (see index.ts) so the help-fallback middleware doesn't
+* intercept a bare `neon status`.
+*/
+const command = "status";
+const describe = "Show the branch's live Neon state (alias of `config status`)";
+const builder = (argv) => argv.usage("$0 status [options]").options({
+	"project-id": {
+		describe: "Project ID",
+		type: "string"
+	},
+	branch: {
+		describe: "Branch ID or name",
+		type: "string"
+	},
+	"config-json": {
+		describe: "Print only the branch's live config as neon.ts-shaped JSON (services + branch tuning + preview), to stdout. Useful for scripting or copying into a neon.ts.",
+		type: "boolean",
+		default: false
+	},
+	"current-branch": {
+		describe: "Print only the linked branch name from the local .neon file (no network). Exits non-zero when no branch is pinned.",
+		type: "boolean",
+		default: false
+	}
+}).middleware(fillSingleProject);
+const handler = (args) => status(args);
+//#endregion
+export { status_exports as a, handler as i, command as n, describe as r, builder as t };