neon 2.45.0 → 2.47.0

package/dist/init/vsix.js

@@ -0,0 +1,111 @@
+/**
+ * Shared VSIX download utilities for extension installation.
+ * Supports corporate proxy via NEON_VSX_GALLERY_URL env var.
+ */
+import { createWriteStream } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pipeline } from "node:stream/promises";
+import { INTERNAL_VSX_GALLERY } from "./build_config.js";
+export const NEON_EXTENSION_ID = "databricks.neon-local-connect";
+const OPEN_VSX_API = "https://open-vsx.org/api";
+/**
+ * Downloads a .vsix file for the Neon extension.
+ *
+ * Strategy:
+ * 1. If NEON_VSX_GALLERY_URL is set, download from the corporate proxy gallery
+ * 2. Otherwise, download from the public Open VSX API
+ *
+ * Returns the path to the temp .vsix file, or null on failure.
+ */
+export async function downloadVsix() {
+    // Runtime env var takes priority, then build-time baked value
+    const proxyGallery = process.env.NEON_VSX_GALLERY_URL || INTERNAL_VSX_GALLERY || "";
+    if (proxyGallery) {
+        return downloadFromGallery(proxyGallery);
+    }
+    return downloadFromOpenVsx();
+}
+/**
+ * Downloads from a VS Code marketplace-compatible gallery API (corporate proxy).
+ * Uses the VS Code extensionquery POST API to find the VSIX download URL.
+ */
+async function downloadFromGallery(galleryUrl) {
+    const [publisher, name] = NEON_EXTENSION_ID.split(".");
+    const baseUrl = galleryUrl.replace(/\/+$/, "");
+    const queryUrl = `${baseUrl}/extensionquery`;
+    try {
+        // Query the marketplace API for the extension
+        const queryRes = await fetch(queryUrl, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Accept: "application/json;api-version=6.1-preview.1",
+            },
+            body: JSON.stringify({
+                filters: [
+                    {
+                        criteria: [
+                            { filterType: 7, value: `${publisher}.${name}` },
+                        ],
+                    },
+                ],
+                flags: 914,
+            }),
+            signal: AbortSignal.timeout(15000),
+        });
+        if (!queryRes.ok)
+            return null;
+        const data = (await queryRes.json());
+        // Find the VSIX download URL from the response
+        const extension = data.results?.[0]?.extensions?.[0];
+        const latestVersion = extension?.versions?.[0];
+        const vsixFile = latestVersion?.files?.find((f) => f.assetType === "Microsoft.VisualStudio.Services.VSIXPackage");
+        if (!vsixFile?.source)
+            return null;
+        // Download the VSIX
+        const vsixRes = await fetch(vsixFile.source, {
+            signal: AbortSignal.timeout(30000),
+            redirect: "follow",
+        });
+        if (!vsixRes.ok || !vsixRes.body)
+            return null;
+        const tmpPath = join(tmpdir(), `${NEON_EXTENSION_ID}-proxy.vsix`);
+        const fileStream = createWriteStream(tmpPath);
+        await pipeline(vsixRes.body, fileStream);
+        return tmpPath;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Downloads from the public Open VSX API.
+ */
+async function downloadFromOpenVsx() {
+    const [publisher, name] = NEON_EXTENSION_ID.split(".");
+    const metaUrl = `${OPEN_VSX_API}/${publisher}/${name}/latest`;
+    try {
+        const metaRes = await fetch(metaUrl, {
+            signal: AbortSignal.timeout(10000),
+        });
+        if (!metaRes.ok)
+            return null;
+        const meta = (await metaRes.json());
+        const downloadUrl = meta.files?.download;
+        if (!downloadUrl)
+            return null;
+        const vsixRes = await fetch(downloadUrl, {
+            signal: AbortSignal.timeout(30000),
+        });
+        if (!vsixRes.ok || !vsixRes.body)
+            return null;
+        const tmpPath = join(tmpdir(), `${NEON_EXTENSION_ID}-${meta.version ?? "latest"}.vsix`);
+        const fileStream = createWriteStream(tmpPath);
+        await pipeline(vsixRes.body, fileStream);
+        return tmpPath;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/neon_services.js

@@ -0,0 +1,143 @@
+/**
+ * Every Neon service a `--service` flag can name, spelled the way a user types it — one
+ * vocabulary for the whole CLI.
+ *
+ * Kebab-case rather than the `neon.ts` field names (`aiGateway`, `buckets`) so a flag reads
+ * like a flag, and the full product name rather than a shortening (`object-storage`, not
+ * `storage`) so nothing is ambiguous when read on its own.
+ *
+ * Commands take a **subset** of this via {@link ParseServicesOptions.allowed} — `config init`
+ * can only declare what a `neon.ts` has a field for, `env pull` can only pull what produces
+ * env vars — but the spelling of a service never varies between them. The order here is the
+ * canonical one: parsing sorts into it, so a command's output never depends on the order the
+ * flags were typed in.
+ *
+ * Not to be confused with `NeonFeature` in `init/bootstrap.ts`, which is what a *template*
+ * requires. That list comes from remote manifests (`neondatabase/examples/bootstrap.yaml`),
+ * spells Postgres `database`, and is not ours to rename.
+ */
+export const NEON_SERVICES = [
+    "postgres",
+    "auth",
+    "data-api",
+    "functions",
+    "object-storage",
+    "ai-gateway",
+];
+/**
+ * Spellings that used to be canonical, and the service they now mean. Accepted so a scripted
+ * `--services storage` keeps working, warned about so it does not quietly become a second
+ * vocabulary, and absent from help text, errors, and docs so nobody learns it fresh.
+ */
+const DEPRECATED_SERVICE_ALIASES = {
+    // `config init --services storage` shipped before the vocabulary was unified.
+    storage: "object-storage",
+};
+/** An explicit empty selection, for commands where "declare nothing" is a real answer. */
+export const NO_SERVICES = "none";
+/**
+ * What to tell someone still using a retired spelling. A message rather than a log call, so
+ * the parser stays free of the CLI's writer and each command can surface it in its own voice.
+ */
+export const deprecatedServiceMessage = (used, canonical) => `"${used}" is the old name for "${canonical}" and still works, but it will be removed. ` +
+    `Use "${canonical}".`;
+/**
+ * Parse the raw values of a services flag into a canonical selection.
+ *
+ * Accepts the flag repeated (`-s auth -s postgres`) and comma-separated
+ * (`-s auth,postgres`), since both read naturally and users will try either. The result is
+ * deduplicated and sorted into {@link NEON_SERVICES} order, so what a command does never
+ * depends on typing order.
+ *
+ * An unrecognized name is rejected rather than dropped: a typo would otherwise act on
+ * everything *except* the service that was asked for, and report success. A name that is a
+ * real service but not one this command supports says so specifically — "functions has no env
+ * variables" is a different problem from a typo, and has a different fix.
+ */
+export const parseServices = (raw, options) => {
+    const { allowed, flag, noneMeans, whyUnavailable = {}, onDeprecated, } = options;
+    const supported = `Supported values: ${allowed.join(", ")}${noneMeans !== undefined ? `, ${NO_SERVICES}` : ""}.`;
+    const names = raw
+        .flatMap((value) => value.split(","))
+        .map((name) => name.trim())
+        .filter((name) => name !== "");
+    if (names.length === 0) {
+        throw new Error(`${flag} needs at least one service. ${supported}`);
+    }
+    if (noneMeans !== undefined && names.includes(NO_SERVICES)) {
+        // Deduplicate before deciding it was combined with something: a repeated value is
+        // a no-op everywhere else in this parser, so `-s none -s none` must be too.
+        if (new Set(names).size > 1) {
+            throw new Error(`${flag} ${NO_SERVICES} cannot be combined with other services.`);
+        }
+        return [];
+    }
+    // Canonicalize first and unconditionally, so a retired spelling is reported against the
+    // service it means rather than as a word nobody recognizes.
+    const deprecated = new Map();
+    const resolved = names.map((name) => {
+        const canonical = DEPRECATED_SERVICE_ALIASES[name];
+        if (canonical === undefined)
+            return name;
+        deprecated.set(name, canonical);
+        return canonical;
+    });
+    const unsupported = resolved.filter((name) => !allowed.some((service) => service === name));
+    if (unsupported.length > 0) {
+        throw new Error(`${unsupportedMessage(unsupported, flag, whyUnavailable)} ${supported}`);
+    }
+    // Warned only once the selection is valid: a run that fails validation should not also
+    // carry a "still works" claim about a value that never took effect.
+    for (const [used, canonical] of deprecated)
+        onDeprecated?.(used, canonical);
+    return NEON_SERVICES.filter((service) => allowed.includes(service) && resolved.includes(service));
+};
+/**
+ * The sentences explaining why a selection was refused. A real Neon service this command
+ * cannot act on is a different mistake from a typo — different cause, different fix — so the
+ * two are never answered with the same word, and each service carries its reason where the
+ * command supplied one.
+ */
+const unsupportedMessage = (unsupported, flag, whyUnavailable) => {
+    const known = unsupported.filter((name) => NEON_SERVICES.some((service) => service === name));
+    const unknown = unsupported.filter((name) => !known.some((service) => service === name));
+    return [
+        unknown.length > 0
+            ? `Unknown service${unknown.length === 1 ? "" : "s"} ${unknown.join(", ")}.`
+            : undefined,
+        ...known.map((service) => {
+            const why = whyUnavailable[service];
+            return `${service} is not something ${flag} can select${why ? `: ${why}` : ""}.`;
+        }),
+    ]
+        .filter((part) => part !== undefined)
+        .join(" ");
+};
+/** Every spelling of the services flag, so a habit picked up on one command works on another. */
+const SERVICE_FLAG_NAMES = ["s", "service", "services"];
+/**
+ * The yargs option for a services flag, so every command that has one accepts the same
+ * spellings (`-s`, `--service`, `--services`) and the same value syntax. `key` is the name the
+ * command reads off `argv`; the rest become aliases.
+ */
+export const servicesOption = (params) => ({
+    alias: SERVICE_FLAG_NAMES.filter((name) => name !== params.key),
+    describe: [
+        `${params.describe}: ${params.allowed.join(", ")}.`,
+        params.noneMeans !== undefined
+            ? `Pass "${NO_SERVICES}" for ${params.noneMeans}.`
+            : undefined,
+        "Repeat the flag or comma-separate.",
+        params.also,
+    ]
+        .filter((part) => part !== undefined)
+        .join(" "),
+    type: "array",
+    string: true,
+});
+/**
+ * Narrow a yargs value for a services flag to the raw strings, or `undefined` when the flag
+ * was not given. `argv` is untyped at the handler, and `string: true` only guarantees the
+ * element type when the flag was actually parsed as an array.
+ */
+export const servicesFlagValue = (value) => Array.isArray(value) ? value.map(String) : undefined;

package/dist/psql/command/cmd_meta.js

@@ -754,12 +754,12 @@ PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  * here on purpose (see the project's LICENSE file for terms).
  */
 const NEON_NOTICE = `
-This is an embedded psql reimplementation that ships with neonctl, the
+This is an embedded psql reimplementation that ships with neon, the
 command-line interface for Neon (https://neon.tech). Neon is part of
 Databricks (https://www.databricks.com).
 
 It is an independent reimplementation of psql and is not affiliated with
-or endorsed by the PostgreSQL Global Development Group. See the neonctl
+or endorsed by the PostgreSQL Global Development Group. See the neon
 LICENSE file for distribution terms.
 `;
 /**

package/dist/psql/core/mainloop.js

@@ -246,7 +246,7 @@ const isHelpKeyword = (line) => {
     const stripped = trimmed.replace(/;+\s*$/u, "").trimEnd();
     return stripped === "help";
 };
-const HELP_TEXT = "You are using psql-ts, the embedded TypeScript psql in neonctl.\n" +
+const HELP_TEXT = "You are using psql-ts, the embedded TypeScript psql in neon.\n" +
     "Type:  \\copyright for distribution terms\n" +
     "       \\h for help with SQL commands\n" +
     "       \\? for help with psql commands\n" +

package/dist/psql/core/startup.js

@@ -223,7 +223,7 @@ export const CLIENT_VERSION = "1.0.0";
 // `embedded-ts` label in place of a real PG build number since this is a
 // reimplementation, not a compiled psql. Distinct from the `:VERSION` psql
 // variable (the client-identity string seeded from CLIENT_VERSION).
-const VERSION_STRING = `psql (PostgreSQL) embedded-ts (neonctl ${CLIENT_VERSION})`;
+const VERSION_STRING = `psql (PostgreSQL) embedded-ts (neon ${CLIENT_VERSION})`;
 const pushAction = (acts, a) => {
     acts.push(a);
 };

package/dist/psql/core/syncVars.js

@@ -85,16 +85,16 @@ export const syncConnectionVars = (vars, conn) => {
  * identifier is real and traceable to the shipped binary, while keeping
  * upstream's variable *shapes*:
  *
- *   - `VERSION`      → `psql-ts (neonctl) <clientVersion>` — a banner that
+ *   - `VERSION`      → `psql-ts (neon) <clientVersion>` — a banner that
  *     names the implementation so users can tell they are on the embedded
- *     TS port, mirroring the startup banner's `psql-ts (neonctl, …)` shape.
+ *     TS port, mirroring the startup banner's `psql-ts (neon, …)` shape.
  *   - `VERSION_NAME` → `<clientVersion>` (e.g. `2.22.0`).
  *   - `VERSION_NUM`  → the same version mapped into PG's NNMMPP integer form
  *     (`2.22.0` → `22200`) via {@link clientVersionNum}, so a script doing a
  *     numeric `:VERSION_NUM` comparison gets a monotonic integer.
  */
 export const setStartupVars = (vars, clientVersion) => {
-    vars.set("VERSION", `psql-ts (neonctl) ${clientVersion}`);
+    vars.set("VERSION", `psql-ts (neon) ${clientVersion}`);
     vars.set("VERSION_NAME", clientVersion);
     vars.set("VERSION_NUM", String(clientVersionNum(clientVersion)));
 };

package/dist/psql/index.js

@@ -337,7 +337,7 @@ const writeStartupBanner = (connection, out) => {
     // Client identifier. Matches upstream's `psql (18.4, server X.Y)` shape
     // but signals that this is the embedded TS implementation so users can tell
     // when they're on the fallback path.
-    out.write(`psql-ts (neonctl, server ${serverVersion})\n`);
+    out.write(`psql-ts (neon, server ${serverVersion})\n`);
     const tls = connection.getTlsInfo();
     if (tls) {
         const parts = [

package/dist/utils/cli_name.js

@@ -0,0 +1,14 @@
+import { basename } from "node:path";
+/**
+ * The name this CLI was invoked as: `neon` (current) or `neonctl` (legacy alias).
+ *
+ * Use this for any user-facing string that suggests a command to run — help text,
+ * error hints, and especially `--agent` `next_command_template` values, which an agent
+ * executes verbatim. Hardcoding `neonctl` breaks those on installs of the `neon` package,
+ * which no longer ships a `neonctl` binary (removed in `neon@2.38.0`).
+ *
+ * Derived from `process.argv[1]`, which is fixed for the process lifetime, so the result
+ * is stable whether this is called at module load or per invocation. Mirrors the name used
+ * for yargs `.scriptName()` in `index.ts`.
+ */
+export const getCliName = () => basename(process.argv[1] ?? "") === "neonctl" ? "neonctl" : "neon";

package/dist/utils/esbuild.js

@@ -3,7 +3,7 @@ import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
 import which from "which";
-const NOT_FOUND = "esbuild not found. neonctl ships esbuild for most platforms; if you see " +
+const NOT_FOUND = "esbuild not found. neon ships esbuild for most platforms; if you see " +
     "this, install esbuild and ensure it is on your PATH (e.g. `npm i -g " +
     "esbuild`), or set NEON_ESBUILD_PATH to an esbuild binary.";
 // Prepended to the ESM bundle. Bundled dependencies are frequently CommonJS, but an ESM

package/dist/utils/package_manager.js

@@ -1,4 +1,6 @@
 import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
 import which from "which";
 import { log } from "../log.js";
 // npm first so it's the default/preselected choice; the rest follow in rough
@@ -9,6 +11,42 @@ export const PACKAGE_MANAGERS = [
     "yarn",
     "bun",
 ];
+/**
+ * Lockfiles, and the package manager each one belongs to. npm is last on
+ * purpose: a repo with both a pnpm lockfile and a leftover `package-lock.json`
+ * (which a failed run like the one this fixes can leave behind) is a pnpm repo.
+ */
+const LOCKFILES = [
+    ["pnpm-lock.yaml", "pnpm"],
+    ["yarn.lock", "yarn"],
+    // bun 1.2+ writes the text `bun.lock`; older versions the binary `bun.lockb`.
+    ["bun.lock", "bun"],
+    ["bun.lockb", "bun"],
+    ["package-lock.json", "npm"],
+];
+/**
+ * The package manager the project at `cwd` uses, from its lockfile. Searches
+ * `cwd` and then each parent up to the repo root: in a monorepo the lockfile
+ * sits at the root while we scaffold into a package. Stopping at the root keeps
+ * a stray lockfile above the repository from deciding how we install into it.
+ */
+export const detectProjectPackageManager = (cwd) => {
+    let dir = cwd;
+    for (;;) {
+        for (const [file, pm] of LOCKFILES) {
+            if (existsSync(join(dir, file)))
+                return pm;
+        }
+        // After the lockfiles, not before: the repo root's own lockfile counts.
+        // `.git` is a file rather than a directory in a worktree or submodule.
+        if (existsSync(join(dir, ".git")))
+            return undefined;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+};
 /**
  * The package manager the CLI was invoked through, read from the
  * `npm_config_user_agent` npm sets for `npm exec`/`npx`, `pnpm dlx`, `yarn
@@ -32,11 +70,20 @@ export const detectPackageManager = () => {
 /** The package managers actually on PATH, in {@link PACKAGE_MANAGERS} order. */
 export const installedPackageManagers = () => PACKAGE_MANAGERS.filter((pm) => which.sync(pm, { nothrow: true }) !== null);
 /**
- * Pick a package manager without prompting: the one the CLI was invoked through,
- * else the first one installed, else npm. Used by non-interactive flows (e.g.
- * `config init`) where there's no scaffold prompt to hang a picker off.
+ * Pick a package manager without prompting: the one the project at `cwd` uses,
+ * else the one the CLI was invoked through, else the first one installed, else
+ * npm. Used by non-interactive flows (e.g. `config init`) where there's no
+ * scaffold prompt to hang a picker off.
+ *
+ * The project wins over the invocation on purpose. `npx neon …` inside a pnpm
+ * repo should still install with pnpm — which tool launched us says nothing
+ * about which one owns that project's `node_modules`, and running npm against
+ * pnpm's symlinked tree is what this ordering exists to prevent.
  */
-export const resolvePackageManager = () => detectPackageManager() ?? installedPackageManagers()[0] ?? "npm";
+export const resolvePackageManager = (cwd) => detectProjectPackageManager(cwd) ??
+    detectPackageManager() ??
+    installedPackageManagers()[0] ??
+    "npm";
 /**
  * The argv that adds `packages` as runtime dependencies with `pm`. npm spells it
  * `install`; pnpm/yarn/bun use `add`.

package/dist/utils/service_picker.js

@@ -1,8 +1,8 @@
 import prompts from "prompts";
-import { NEON_SERVICES } from "../config_template.js";
+import { CONFIG_INIT_SERVICES } from "../config_template.js";
 /**
- * The picker's rows, in {@link NEON_SERVICES} order. Titles use the product names from the
- * CLI's README ("Managed Better Auth", "Object Storage") rather than the `neon.ts` field
+ * The picker's rows, in {@link CONFIG_INIT_SERVICES} order. Titles use the product names from
+ * the CLI's README ("Managed Better Auth", "Object Storage") rather than the `neon.ts` field
  * names, since this is the list a user reads before they've seen a policy.
  */
 const CHOICES = [
@@ -17,7 +17,7 @@ const CHOICES = [
         description: "Long-running, without timeouts, and closer to your database.",
     },
     {
-        value: "storage",
+        value: "object-storage",
         title: "Object Storage",
         description: "S3-compatible blob storage that branches with your projects.",
     },
@@ -58,7 +58,7 @@ export const pickServicesInteractively = async () => {
     if (!Array.isArray(services)) {
         throw new Error("Aborted: no services selected.");
     }
-    // Order by NEON_SERVICES rather than selection order so the rendered neon.ts is
+    // Order canonically rather than by selection order so the rendered neon.ts is
     // independent of the order the rows were toggled in.
-    return NEON_SERVICES.filter((service) => services.includes(service));
+    return CONFIG_INIT_SERVICES.filter((service) => services.includes(service));
 };

package/dist/utils/write_sync.js

@@ -0,0 +1,39 @@
+import { writeSync } from "node:fs";
+/**
+ * Write `text` to a file descriptor and do not return until all of it is out.
+ *
+ * `process.stdout.write` is asynchronous when stdout is a pipe — which it is whenever the
+ * caller is an agent or a script capturing output — so a `process.exit()` on the next line
+ * discards whatever has not been flushed. The caller sees an exit code and empty stdout.
+ *
+ * Use this for any final message that is followed by `process.exit`.
+ */
+export function writeAllSync(fd, text) {
+    let buffer = Buffer.from(text, "utf8");
+    while (buffer.length > 0) {
+        try {
+            buffer = buffer.subarray(writeSync(fd, buffer));
+        }
+        catch (err) {
+            const code = err.code;
+            if (code === "EAGAIN") {
+                // Wait for the reader rather than spinning on it. A pipe nobody is draining
+                // would otherwise burn a core until it is; failure output is small enough
+                // that this should never be reached, which is the reason to bound it rather
+                // than assume so.
+                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5);
+                continue;
+            }
+            // The reader closed the pipe (`neon … | head`). There is nobody left to tell,
+            // and this is the last thing the process does, so stop rather than throw.
+            if (code === "EPIPE")
+                return;
+            // Anything else means the write did not happen and the caller is about to exit
+            // as though it had. Swallowing it turns a lost payload into an apparent success.
+            throw err;
+        }
+    }
+}
+/** File descriptors, named so call sites read as the stream they mean. */
+export const STDOUT_FD = 1;
+export const STDERR_FD = 2;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neon",
-  "version": "2.45.0",
+  "version": "2.47.0",
   "description": "CLI tool for Neon, the cloud backend primitives built around Lakebase Postgres",
   "keywords": [
     "neon",
@@ -39,6 +39,8 @@
     "node": ">=20.19.0"
   },
   "dependencies": {
+    "@clack/core": "0.4.2",
+    "@clack/prompts": "0.10.1",
     "@hono/node-server": "2.0.4",
     "@segment/analytics-node": "1.3.0",
     "chalk": "5.3.0",
@@ -46,20 +48,22 @@
     "cli-table": "0.3.11",
     "cliui": "8.0.1",
     "diff": "5.2.0",
+    "execa": "^9.5.2",
     "fflate": "^0.8.3",
     "open": "^10.2.0",
     "openid-client": "6.8.1",
     "pg-protocol": "^1.14.0",
+    "picocolors": "^1.1.1",
     "prompts": "2.4.2",
     "undici": "^7.28.0",
     "which": "3.0.1",
     "yaml": "^2.9.0",
     "yargs": "17.7.2",
+    "yoctocolors": "^2.1.2",
     "@neon/sdk": "1.5.0",
-    "@neon/config": "0.14.0",
-    "@neon/config-runtime": "0.12.4",
-    "neon-init": "0.20.7",
-    "@neon/env": "0.14.0"
+    "@neon/config": "0.14.1",
+    "@neon/env": "0.15.0",
+    "@neon/config-runtime": "0.12.5"
   },
   "optionalDependencies": {
     "esbuild": "0.28.1"
@@ -111,15 +115,17 @@
   },
   "scripts": {
     "generateParams": "tsx generateOptionsFromSpec.ts",
+    "codegen": "node ../../scripts/sync-shared.mjs . && node scripts/set-vsx-gallery.mjs",
     "clean": "rm -rf dist",
-    "build": "node ../../scripts/sync-shared.mjs . && pnpm generateParams && pnpm clean && tsc -p tsconfig.build.json && cp src/*.html ./dist",
+    "build": "pnpm codegen && pnpm generateParams && pnpm clean && tsc -p tsconfig.build.json && cp src/*.html ./dist",
+    "build:internal": "node ../../scripts/sync-shared.mjs . && node scripts/set-vsx-gallery.mjs https://cursor-vsx-proxy.cloud.databricks.com/gallery && pnpm generateParams && pnpm clean && tsc -p tsconfig.build.json && cp src/*.html ./dist",
     "bundle": "node pkg.js",
-    "typecheck": "node ../../scripts/sync-shared.mjs . && tsc --noEmit",
-    "lint": "node ../../scripts/sync-shared.mjs . && pnpm typecheck && biome check src",
+    "typecheck": "pnpm codegen && tsc --noEmit",
+    "lint": "pnpm codegen && pnpm typecheck && biome check src",
     "lint:fix": "pnpm typecheck && biome check src --write",
-    "test": "node ../../scripts/sync-shared.mjs . && pnpm --filter neonctl... build && vitest run",
-    "test:ci": "node ../../scripts/sync-shared.mjs . && pnpm build && vitest run",
-    "test:e2e": "node ../../scripts/sync-shared.mjs . && pnpm build && vitest run --config vitest.e2e.config.ts",
-    "test:conformance": "node ../../scripts/sync-shared.mjs . && vitest run --config tests/psql-conformance/vitest.config.ts"
+    "test": "pnpm codegen && pnpm --filter neonctl... build && vitest run",
+    "test:ci": "pnpm codegen && pnpm build && vitest run",
+    "test:e2e": "pnpm codegen && pnpm build && vitest run --config vitest.e2e.config.ts",
+    "test:conformance": "pnpm codegen && vitest run --config tests/psql-conformance/vitest.config.ts"
   }
 }