neonctl 2.26.1 → 2.26.3

package/README.md

@@ -455,7 +455,7 @@ The target directory must be empty unless you pass `--force` (a lone `.git` is i
 | [me](https://neon.com/docs/reference/cli-me)                               |                                                                                                              | Show current user                  |
 | [branches](https://neon.com/docs/reference/cli-branches)                   | `list`, `create`, `rename`, `add-compute`, `set-default`, `set-expiration`, `delete`, `get`                  | Manage branches                    |
 | [databases](https://neon.com/docs/reference/cli-databases)                 | `list`, `create`, `delete`                                                                                   | Manage databases                   |
-| functions                                                                  | `deploy`, `list`, `get`, `delete`                                                                            | Manage Neon Functions              |
+| function                                                                   | `deploy`, `list`, `get`, `delete`                                                                            | Manage Neon Functions              |
 | [roles](https://neon.com/docs/reference/cli-roles)                         | `list`, `create`, `delete`                                                                                   | Manage roles                       |
 | [operations](https://neon.com/docs/reference/cli-operations)               | `list`                                                                                                       | Manage operations                  |
 | [connection-string](https://neon.com/docs/reference/cli-connection-string) |                                                                                                              | Get connection string              |

package/commands/auth.js

@@ -110,6 +110,9 @@ export const ensureAuth = async (props) => {
     // login. It uses an API key / stored credentials when present (harmless),
     // otherwise it proceeds with no API client.
     const isBootstrap = props._[0] === 'bootstrap';
+    // `init` manages its own auth flow (asks the user if they have an account,
+    // then triggers OAuth at the right time). Skip the global auth middleware.
+    const isInit = props._[0] === 'init';
     // Use existing API key or handle auth command
     if (props.apiKey || props._[0] === 'auth') {
         if (props.apiKey) {
@@ -162,6 +165,10 @@ export const ensureAuth = async (props) => {
         log.debug('bootstrap: no usable credentials; continuing without auth');
         return;
     }
+    if (isInit) {
+        log.debug('init: skipping global auth; init manages its own auth flow');
+        return;
+    }
     // Start new auth flow if no valid token exists or refresh failed
     const apiKey = await authFlow(props);
     props.apiKey = apiKey;

package/commands/bootstrap.js

@@ -6,7 +6,7 @@ import prompts from 'prompts';
 import which from 'which';
 import { isCi } from '../env.js';
 import { log } from '../log.js';
-import { FALLBACK_TEMPLATES, fetchFileBytes, fetchSymlinkTarget, fetchTemplates, findTemplate, resolveTemplate, templateIds, } from '../utils/bootstrap.js';
+import { FALLBACK_TEMPLATES, downloadTemplate, fetchTemplates, findTemplate, templateIds, } from '../utils/bootstrap.js';
 // The directory positional is optional: omitting it in an interactive terminal
 // prompts for one. In a non-interactive context a missing directory is an error.
 export const command = 'bootstrap [directory]';
@@ -101,18 +101,18 @@ const resolveTemplateList = async (props) => props.template && findTemplate(FALL
     ? FALLBACK_TEMPLATES
     : fetchTemplates();
 /**
- * The picker label for a template: the title prefixed with the Neon services it
- * uses as a dim badge, e.g. "[Postgres · Functions] Hono API …". The badge is
- * styled with chalk.dim only (never a foreground color) so it survives the
- * cyan/underline `prompts` paints over the focused row — dim resets with the
- * intensity SGR, leaving the row's color and underline intact. The one-line
- * description renders under the title on focus (handled by `prompts`).
+ * The picker label for a template: the title first, then the Neon services it
+ * uses as a dim, italic suffix, e.g. "Hono API …  Postgres · Functions". The
+ * suffix is styled with chalk.dim (and italic) only — never a foreground color —
+ * so it survives the cyan/underline `prompts` paints over the focused row: dim
+ * and italic reset with their own SGRs, leaving the row's color and underline
+ * intact. Descriptions are intentionally omitted to keep the picker uncluttered.
  */
 const formatTemplateTitle = (template) => {
     if (!template.services || template.services.length === 0) {
         return template.title;
     }
-    return `${chalk.dim(`[${template.services.join(' · ')}]`)} ${template.title}`;
+    return `${template.title}  ${chalk.dim.italic(template.services.join(' · '))}`;
 };
 const resolveSelectedTemplate = async (props, interactive, templates) => {
     if (props.template) {
@@ -141,7 +141,6 @@ const resolveSelectedTemplate = async (props, interactive, templates) => {
         message: 'Which template would you like to use?',
         choices: templates.map((template) => ({
             title: formatTemplateTitle(template),
-            description: template.description,
             value: template.id,
         })),
         initial: 0,
@@ -207,25 +206,23 @@ const ensureTargetUsable = (dir, force) => {
 };
 const scaffold = async (template, targetDir) => {
     log.info('Fetching template "%s" from GitHub…', template.id);
-    const { commitSha, entries } = await resolveTemplate(template);
+    const files = await downloadTemplate(template);
     mkdirSync(targetDir, { recursive: true });
-    log.info('Scaffolding %d files into %s…', entries.length, targetDir);
-    await mapWithConcurrency(entries, 8, async (entry) => {
-        const dest = join(targetDir, entry.path);
+    log.info('Scaffolding %d files into %s…', files.length, targetDir);
+    for (const file of files) {
+        const dest = join(targetDir, file.path);
         mkdirSync(dirname(dest), { recursive: true });
-        if (entry.kind === 'symlink') {
-            const target = await fetchSymlinkTarget(template, commitSha, entry.repoPath);
-            writeSymlink(dest, target);
+        if (file.kind === 'symlink') {
+            writeSymlink(dest, file.target);
         }
         else {
-            const bytes = await fetchFileBytes(template, commitSha, entry.repoPath);
-            writeFileSync(dest, bytes);
-            if (entry.executable) {
+            writeFileSync(dest, file.bytes);
+            if (file.executable) {
                 chmodSync(dest, 0o755);
             }
         }
-    });
-    return entries.length;
+    }
+    return files.length;
 };
 const writeSymlink = (dest, target) => {
     if (isSymlink(dest)) {
@@ -561,16 +558,6 @@ const displayDir = (targetDir) => {
     }
     return rel.startsWith('..') ? targetDir : rel;
 };
-const mapWithConcurrency = async (items, limit, fn) => {
-    const queue = [...items];
-    const worker = async () => {
-        for (let next = queue.shift(); next !== undefined; next = queue.shift()) {
-            await fn(next);
-        }
-    };
-    const workers = Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, () => worker());
-    await Promise.all(workers);
-};
 const isSymlink = (path) => {
     try {
         return lstatSync(path).isSymbolicLink();

package/commands/bucket.js

@@ -95,7 +95,7 @@ export const builder = (argv) => argv
     .command({
     command: 'list <target>',
     aliases: ['ls'],
-    describe: 'List objects in a bucket',
+    describe: 'List objects in a bucket. By default folders are collapsed (like "aws s3 ls"); pass --recursive for a flat listing of every key',
     builder: (yargs) => yargs
         .usage('$0 bucket object list <bucket>[/<prefix>] [options]')
         .positional('target', {
@@ -105,8 +105,13 @@ export const builder = (argv) => argv
     })
         .options({
         ...scopeOptions,
+        recursive: {
+            describe: 'List every key flat, descending into nested folders (no delimiter). Mutually exclusive with --delimiter. Mirrors "aws s3 ls --recursive"',
+            type: 'boolean',
+            default: false,
+        },
         delimiter: {
-            describe: 'Collapse keys sharing a common prefix (e.g. "/") into folders',
+            describe: 'Collapse keys sharing this prefix separator into folders. Defaults to "/" (folder view); ignored when --recursive is set',
             type: 'string',
         },
         cursor: {
@@ -223,7 +228,26 @@ const deleteBucket = async (props) => {
     }
     log.info(`Bucket "${props.name}" deleted from branch ${branchId}`);
 };
+// Resolve the delimiter to send to the backend, mirroring `aws s3 ls`:
+//   - default (neither flag): "/" so the listing is folder-collapsed;
+//   - --recursive: no delimiter, so every nested key is returned flat;
+//   - explicit --delimiter <x>: that value (an empty string lists flat too).
+// `--recursive` together with an explicit `--delimiter` is nonsensical and is
+// rejected client-side before any HTTP request is made.
+export const resolveListDelimiter = (props) => {
+    if (props.recursive && props.delimiter !== undefined) {
+        throw new Error('--recursive and --delimiter cannot be used together. Use --recursive for a flat listing, or --delimiter to collapse on a separator.');
+    }
+    if (props.recursive) {
+        return undefined;
+    }
+    if (props.delimiter !== undefined) {
+        return props.delimiter;
+    }
+    return '/';
+};
 const listObjects = async (props) => {
+    const delimiter = resolveListDelimiter(props);
     const branchId = await branchIdFromProps(props);
     const { bucket, rest } = splitBucketTarget(props.target);
     const { data } = await listProjectBranchBucketObjects(props.apiClient, {
@@ -231,7 +255,7 @@ const listObjects = async (props) => {
         branchId,
         bucketName: bucket,
         prefix: rest === '' ? undefined : rest,
-        delimiter: props.delimiter,
+        delimiter,
         cursor: props.cursor,
         limit: props.limit,
     });

package/commands/checkout.js

@@ -1,6 +1,7 @@
 import { isAxiosError } from 'axios';
+import chalk from 'chalk';
 import prompts from 'prompts';
-import { applyContext, readContextFile } from '../context.js';
+import { applyContext, contextBranch, readContextFile } from '../context.js';
 import { isCi } from '../env.js';
 import { log } from '../log.js';
 import { createBranch, pickBranchInteractively, } from '../utils/branch_picker.js';
@@ -47,6 +48,13 @@ export const builder = (argv) => argv
     ],
 ]);
 export const handler = async (props) => {
+    // Show where the context is pinned *before* we switch it, so the user sees the move
+    // ("currently on X" → "checked out Y") and can catch a checkout they didn't mean to make.
+    // Read straight from `.neon` (a name, no API call); silent when nothing is pinned yet.
+    const previousBranch = contextBranch(readContextFile(props.contextFile));
+    if (previousBranch) {
+        log.info('%s Currently on branch %s', chalk.dim('→'), chalk.cyan.bold(previousBranch));
+    }
     // Branch listing is project-scoped, so `projectId` is the only thing
     // `checkout` actually needs. Resolve it through the standard chain
     // (--project-id flag > .neon file > single-project auto-detect); when

package/commands/config.js

@@ -1,9 +1,12 @@
+import chalk from 'chalk';
 import { resolveConfig } from '@neondatabase/config';
 import { apply, createBranch as createBranchFromPolicy, inspect, loadConfigFromFile, plan, } from '@neondatabase/config-runtime';
 import { toNeonConfigView } from '../config_format.js';
 import { log } from '../log.js';
+import { isCi } from '../env.js';
 import { loadEnvFileIntoProcess } from '../env_file.js';
-import { branchIdFromProps, fillSingleProject } from '../utils/enrichers.js';
+import { fillSingleProject, resolveBranchRef } from '../utils/enrichers.js';
+import { announceTargetBranch } from '../utils/branch_notice.js';
 import { bundleEntry } from '../utils/esbuild.js';
 import { zipBundle } from '../utils/zip.js';
 import { writer } from '../writer.js';
@@ -16,8 +19,12 @@ import { autoPullEnvAfterPin } from './env.js';
  */
 const neonctlBundler = async (fn) => zipBundle(await bundleEntry(fn.source));
 const INSPECT_FIELDS = ['project', 'branch', 'config'];
-const APPLIED_FIELDS = ['action', 'kind', 'identifier', 'details'];
-const FUNCTION_FIELDS = ['slug', 'invocation_url'];
+// Deliberately minimal: action/kind/identifier are short and fixed-ish, so the table can
+// never overflow. Per-change `details` (a function's long invocationUrl in particular) are
+// intentionally NOT a column — they used to be JSON-stringified into a cell and blew the
+// table past 190 cols. Function URLs are printed below as a plain list (see reportPushResult),
+// and the full details are still available via `--output json`.
+const APPLIED_FIELDS = ['action', 'kind', 'identifier'];
 const CONFLICT_FIELDS = [
     'identifier',
     'field',
@@ -119,7 +126,13 @@ const loadConfig = async (props) => {
     return config;
 };
 export const status = async (props) => {
-    const branchId = await branchIdFromProps(props);
+    const branch = await resolveBranchRef(props);
+    // `--config-json` is a script-friendly mode that emits only JSON to stdout, so keep it
+    // pristine; the regular human view gets the "which branch am I inspecting" guardrail.
+    if (!props.configJson) {
+        announceTargetBranch(props, branch, 'Inspecting branch');
+    }
+    const branchId = branch.branchId;
     const live = await inspect({
         projectId: props.projectId,
         branchId,
@@ -152,7 +165,9 @@ export const status = async (props) => {
 };
 export const planCmd = async (props) => {
     const config = await loadConfig(props);
-    const branchId = await branchIdFromProps(props);
+    const branch = await resolveBranchRef(props);
+    announceTargetBranch(props, branch, 'Planning against branch');
+    const branchId = branch.branchId;
     // `plan` is a dry run that never bundles, so its options don't accept (or need)
     // an injected bundler — only `apply` does (it uses neonctlBundler).
     const result = await plan(config, {
@@ -166,7 +181,9 @@ export const planCmd = async (props) => {
 };
 export const applyCmd = async (props) => {
     const config = await loadConfig(props);
-    const branchId = await branchIdFromProps(props);
+    const branch = await resolveBranchRef(props);
+    announceTargetBranch(props, branch, 'Applying to branch');
+    const branchId = branch.branchId;
     const result = await apply(config, {
         projectId: props.projectId,
         branchId,
@@ -241,7 +258,6 @@ const reportPushResult = (props, result, mode, services) => {
         action: change.action,
         kind: change.kind,
         identifier: change.identifier,
-        details: change.details ? JSON.stringify(change.details) : '',
     }));
     const conflicts = result.conflicts.map((conflict) => ({
         identifier: conflict.identifier,
@@ -250,9 +266,9 @@ const reportPushResult = (props, result, mode, services) => {
         desired: stringify(conflict.desired),
         reason: conflict.reason,
     }));
-    // Deployed functions carry their invocation URL in the change details — pull them into a
-    // dedicated table so users can see where to call each function without digging through the
-    // raw details blob. Keyed by slug so a function never shows twice.
+    // Deployed functions carry their invocation URL in the change details — collect them so
+    // we can list where to call each function without digging through the raw details blob.
+    // Keyed by slug so a function never shows twice.
     const functionUrlBySlug = new Map();
     for (const change of result.applied) {
         if (change.action === 'noop')
@@ -263,10 +279,6 @@ const reportPushResult = (props, result, mode, services) => {
             functionUrlBySlug.set(slug, invocationUrl);
         }
     }
-    const functions = [...functionUrlBySlug].map(([slug, invocation_url]) => ({
-        slug,
-        invocation_url,
-    }));
     const out = writer(props);
     const noChanges = changes.length === 0 && conflicts.length === 0;
     if (changes.length > 0) {
@@ -275,17 +287,21 @@ const reportPushResult = (props, result, mode, services) => {
             title: mode === 'plan' ? 'Planned changes' : 'Applied changes',
         });
     }
-    if (functions.length > 0) {
-        out.write(functions, {
-            fields: FUNCTION_FIELDS,
-            title: mode === 'plan' ? 'Function URLs (after apply)' : 'Function URLs',
-        });
-    }
     if (conflicts.length > 0) {
         out.write(conflicts, { fields: CONFLICT_FIELDS, title: 'Conflicts' });
     }
-    // Flush any tables, then append the summary so it reads directly below them.
+    // Flush any tables, then append the lists/summary so they read directly below them.
     out.end();
+    // Function URLs are a plain list rather than a table: an invocation URL can be 70+ chars,
+    // which makes any bordered table overflow and wrap awkwardly in a normal terminal. A list
+    // lets each URL reflow on its own line, and stays copy-pasteable.
+    if (functionUrlBySlug.size > 0) {
+        const heading = mode === 'plan' ? 'Function URLs (after apply)' : 'Function URLs';
+        out.text(`\n${isCi() ? heading : chalk.bold(heading)}\n`);
+        for (const [slug, invocationUrl] of functionUrlBySlug) {
+            out.text(`  • ${slug}: ${invocationUrl}\n`);
+        }
+    }
     if (noChanges) {
         log.info(`No changes — branch ${result.branchName} already matches the policy.`);
     }

package/commands/dev.js

@@ -480,9 +480,8 @@ const spawnChild = (unit, runtimePath, bundlePath) => {
 const writeBundle = async (source, bundleDir) => {
     const files = await bundleEntry(source);
     mkdirSync(bundleDir, { recursive: true });
-    // bundleEntry emits `index.mjs` (+ `index.mjs.map`). The `.mjs` extension makes Node load
-    // it as ESM directly, so no `package.json` `"type": "module"` marker is needed, and esbuild
-    // points the sourcemap link at `index.mjs.map` for us.
+    // bundleEntry emits a single `index.mjs` (no source map). The `.mjs` extension makes Node
+    // load it as ESM directly, so no `package.json` `"type": "module"` marker is needed.
     for (const [name, contents] of Object.entries(files)) {
         writeFileSync(join(bundleDir, name), contents);
     }

package/commands/env.js

@@ -4,7 +4,8 @@ import { existsSync } from 'node:fs';
 import { log } from '../log.js';
 import { resolveNeonEnvVars } from '../dev/env.js';
 import { mergeEnvFile, readEnvFile, resolveEnvFilePath } from '../env_file.js';
-import { branchIdFromProps, fillSingleProject } from '../utils/enrichers.js';
+import { fillSingleProject, resolveBranchRef } from '../utils/enrichers.js';
+import { announceTargetBranch } from '../utils/branch_notice.js';
 export const command = 'env';
 export const describe = "Manage a branch's Neon env variables locally";
 /**
@@ -33,15 +34,45 @@ export const builder = (argv) => argv
 })
     .example('$0 env pull', "Write the linked branch's Neon vars into .env.local (or .env if present)")
     .example('$0 env pull --branch preview --file .env.preview', 'Pull a specific branch into a specific file'), async (args) => {
-    await pull(args);
+    // Explicit `env pull` announces the branch it's reading from up front so the user
+    // can catch "pulled env from the wrong branch" before it overwrites their .env. The
+    // bundled auto-pull (link / checkout / apply) stays quiet — those already report the
+    // branch they pinned/applied to.
+    await pull(args, { announce: true });
 })
     .demandCommand(1);
 export const handler = (args) => args;
 /** Every OS-level env var name `@neondatabase/env` can emit, used only for reporting. */
 const NEON_VAR_NAMES = Object.values(NEON_ENV_VAR_KEYS).flatMap((group) => Object.values(group));
-export const pull = async (props) => {
+/**
+ * The Neon env vars `env pull` *owns*, so it removes any that the branch no longer has when
+ * it reconciles the local `.env` (see {@link pull}). Scoped to the unambiguously Neon-named
+ * vars — the `NEON_*` aliases plus `DATABASE_URL[_UNPOOLED]` — so switching a working
+ * directory to a project/branch without Auth / the Data API drops the now-stale
+ * `NEON_AUTH_*` / `NEON_DATA_API_*` lines instead of leaving credentials for features that
+ * aren't enabled.
+ *
+ * Deliberately **excludes** the storage / AI Gateway vars Neon projects onto third-party SDK
+ * names (`AWS_*`, `OPENAI_*`): those collide with credentials a user may set by hand, so
+ * `env pull` only ever writes them, never prunes them. (Their Neon-branded siblings —
+ * `NEON_STORAGE_*` / `NEON_AI_GATEWAY_*` — are owned and pruned.)
+ */
+const NEON_OWNED_ENV_KEYS = [
+    ...Object.values(NEON_ENV_VAR_KEYS.postgres),
+    ...Object.values(NEON_ENV_VAR_KEYS.auth),
+    ...Object.values(NEON_ENV_VAR_KEYS.dataApi),
+    NEON_ENV_VAR_KEYS.storage.regionNeon,
+    NEON_ENV_VAR_KEYS.storage.forcePathStyle,
+    NEON_ENV_VAR_KEYS.aiGateway.neonToken,
+    NEON_ENV_VAR_KEYS.aiGateway.neonBaseUrl,
+];
+export const pull = async (props, opts = {}) => {
     const cwd = props.cwd ?? process.cwd();
-    const branchId = await branchIdFromProps(props);
+    const branch = await resolveBranchRef(props);
+    if (opts.announce) {
+        announceTargetBranch(props, branch, 'Pulling env from branch');
+    }
+    const branchId = branch.branchId;
     // Resolve the target file first and layer its current contents under the resolver's env
     // source. This lets `fetchEnv` reuse one-time secrets that are already on disk — Neon Auth
     // keys and the unified branch credential's `api_token` / `s3_secret_access_key`, which the
@@ -66,8 +97,16 @@ export const pull = async (props) => {
             'enabled Auth / Data API).');
         return { status: 'empty' };
     }
-    const { written } = mergeEnvFile(targetPath, neonVars);
+    // Reconcile rather than blindly merge: write the branch's current Neon vars and prune any
+    // Neon-owned vars the branch no longer has (e.g. NEON_AUTH_* / NEON_DATA_API_* carried over
+    // from a previous project/branch). Non-Neon lines are always preserved.
+    const { written, removed } = mergeEnvFile(targetPath, neonVars, {
+        managedKeys: NEON_OWNED_ENV_KEYS,
+    });
     log.info('Pulled %d Neon variable%s into %s: %s', written.length, written.length === 1 ? '' : 's', targetPath, written.join(', '));
+    if (removed.length > 0) {
+        log.info('Removed %d stale Neon variable%s not enabled on this branch: %s', removed.length, removed.length === 1 ? '' : 's', removed.join(', '));
+    }
     return { status: 'written', written, file: targetPath };
 };
 /**

package/commands/functions.js

@@ -14,6 +14,16 @@ const FUNCTION_FIELDS = [
     'invocation_url',
     'created_at',
 ];
+const FUNCTIONS_LIST_LIMIT = 100;
+// Table columns for `functions list`. `status` is a derived field (the
+// table writer reads flat fields only): the current deployment's status.
+const LIST_TABLE_FIELDS = [
+    'slug',
+    'name',
+    'status',
+    'invocation_url',
+    'created_at',
+];
 const DEPLOYMENT_FIELDS = [
     'id',
     'status',
@@ -45,14 +55,14 @@ const ENTRY_CANDIDATES = ['index.ts', 'index.mjs', 'index.js'];
 // Overridable so tests can poll fast; defaults to 2s in real use.
 const POLL_INTERVAL_MS = Number(process.env.NEON_FUNCTIONS_POLL_INTERVAL_MS) || 2000;
 // Upper bound on --wait polling so the CLI never hangs (e.g. if our deployment
-// never becomes active_deployment). Overridable so tests can time out fast;
+// never shows up as current_deployment). Overridable so tests can time out fast;
 // defaults to 10 minutes in real use.
 const POLL_TIMEOUT_MS = Number(process.env.NEON_FUNCTIONS_POLL_TIMEOUT_MS) || 600000;
-export const command = 'functions';
+export const command = 'function';
 export const describe = 'Manage Neon Functions';
-export const aliases = ['function'];
+export const aliases = ['functions'];
 export const builder = (argv) => argv
-    .usage('$0 functions <sub-command> [options]')
+    .usage('$0 function <sub-command> [options]')
     .options({
     'project-id': {
         describe: 'Project ID',
@@ -137,7 +147,7 @@ const parseEnv = (entries) => {
     }
     return JSON.stringify(map);
 };
-const statusHint = (slug, projectId, branchId) => `Check status with: neonctl functions get ${slug} --project-id ${projectId} --branch ${branchId}`;
+const statusHint = (slug, projectId, branchId) => `Check status with: neonctl function get ${slug} --project-id ${projectId} --branch ${branchId}`;
 // Emit the resolved deployment together with the function's invocation_url, so the
 // deploy output shows where the function is reachable (not just the deployment id).
 const emitDeployResult = (props, deployment, fn) => {
@@ -165,7 +175,7 @@ const deploy = async (props) => {
         props.runtime !== undefined;
     if (!hasOption) {
         throw new Error('Provide at least one option to deploy, e.g. --src or --env. ' +
-            'See: neonctl functions deploy --help.');
+            'See: neonctl function deploy --help.');
     }
     // Cheap, offline validation first - fail before any network round-trip.
     if (!SLUG_PATTERN.test(props.slug)) {
@@ -188,12 +198,12 @@ const deploy = async (props) => {
     // Bundle before any network round-trip so a bundling failure fails fast.
     const zip = zipBundle(await bundleEntry(source));
     const branchId = await branchIdFromProps(props);
-    // Snapshot the active version before deploy so we can detect the new one
-    // afterward. A missing function (404) or no active version → undefined.
+    // Snapshot the current version before deploy so we can detect the new one
+    // afterward. A missing function (404) or no deployment yet → undefined.
     let before;
     try {
         const fn = await getFunction(props.apiClient, props.projectId, branchId, props.slug);
-        before = fn.active_deployment?.id;
+        before = fn.current_deployment?.id;
     }
     catch (err) {
         if (!(isAxiosError(err) && err.response?.status === 404))
@@ -213,12 +223,12 @@ const deploy = async (props) => {
     };
     process.once('SIGINT', onSignal);
     process.once('SIGTERM', onSignal);
-    // Poll until a NEW active version appears (id greater than the snapshot, or
+    // Poll until a NEW version appears (id greater than the snapshot, or
     // any version if there was none). --no-wait stops there; --wait stops at a
     // terminal status. Bounded by POLL_TIMEOUT_MS so it never hangs.
     let resolved;
     // The function carries the invocation_url; keep the whole record (not just its
-    // active_deployment) so we can surface that URL on success.
+    // current_deployment) so we can surface that URL on success.
     let resolvedFn;
     const deadline = Date.now() + POLL_TIMEOUT_MS;
     try {
@@ -237,7 +247,7 @@ const deploy = async (props) => {
                     continue;
                 throw err;
             }
-            const dep = fn.active_deployment;
+            const dep = fn.current_deployment;
             const isNew = dep !== undefined && (before === undefined || dep.id > before);
             if (isNew && dep) {
                 resolved = dep;
@@ -290,12 +300,31 @@ const get = async (props) => {
         fields: FUNCTION_FIELDS,
         title: 'function',
     });
-    if (fn.active_deployment) {
-        out.write(fn.active_deployment, {
+    const current = fn.current_deployment;
+    const active = fn.active_deployment;
+    if (current && active && current.id === active.id) {
+        out.write(current, {
             fields: DEPLOYMENT_FIELDS,
-            title: 'active deployment',
+            title: 'deployment (current, active)',
         });
-        writeDeploymentErrorSection(out, fn.active_deployment);
+        writeDeploymentErrorSection(out, current);
+    }
+    else {
+        if (current) {
+            out.write(current, {
+                fields: DEPLOYMENT_FIELDS,
+                title: 'current deployment',
+            });
+            // The failure reason is shown only for the current deployment;
+            // the active one completed successfully by definition.
+            writeDeploymentErrorSection(out, current);
+        }
+        if (active) {
+            out.write(active, {
+                fields: DEPLOYMENT_FIELDS,
+                title: 'active deployment',
+            });
+        }
     }
     if (props.listEnvVariables) {
         out.write((fn.active_deployment?.environment ?? []).map((name) => ({ name })), {
@@ -321,13 +350,27 @@ const deleteFn = async (props) => {
 };
 const list = async (props) => {
     const branchId = await branchIdFromProps(props);
-    const functions = await listFunctions(props.apiClient, props.projectId, branchId);
+    const functions = [];
+    let cursor;
+    for (;;) {
+        const page = await listFunctions(props.apiClient, props.projectId, branchId, { cursor, limit: FUNCTIONS_LIST_LIMIT });
+        functions.push(...page.functions);
+        log.debug('Got %d functions, next cursor: %s', page.functions.length, page.next);
+        // A server echoing the same cursor would loop forever; treat it as
+        // the end of the list.
+        if (!page.next || page.next === cursor)
+            break;
+        cursor = page.next;
+    }
     if (props.output === 'json' || props.output === 'yaml') {
         writer(props).end(functions, { fields: FUNCTION_FIELDS });
         return;
     }
-    writer(props).end(functions, {
-        fields: FUNCTION_FIELDS,
+    writer(props).end(functions.map((fn) => ({
+        ...fn,
+        status: fn.current_deployment?.status ?? '',
+    })), {
+        fields: LIST_TABLE_FIELDS,
         emptyMessage: 'No functions found on this branch.',
     });
 };

package/commands/init.js

@@ -1,4 +1,4 @@
-import { interactiveInit, orchestrate } from 'neon-init';
+import { detectAgent, enrichResponse, interactiveInit, orchestrate, routeDataStep, } from 'neon-init';
 import { sendError } from '../analytics.js';
 import { log } from '../log.js';
 export const command = 'init';
@@ -11,6 +11,10 @@ export const builder = (yargs) => yargs
     alias: 'a',
     type: 'string',
     describe: 'Agent to configure (cursor, copilot, claude, etc.).',
+})
+    .option('data', {
+    type: 'string',
+    describe: 'JSON object with a "step" field to route to a specific phase and phase-specific options.',
 })
     .option('skip-neon-auth', {
     type: 'boolean',
@@ -30,14 +34,36 @@ export const builder = (yargs) => yargs
     .strict(false);
 export const handler = async (argv) => {
     try {
-        if (argv.agent !== undefined) {
+        // Auto-detect agent from environment if --agent not explicitly provided.
+        // For IDE-based detection (Cursor, VS Code, Windsurf), require non-TTY stdin
+        // to distinguish "agent spawned this" from "human typed this in terminal".
+        const agent = argv.agent || (!process.stdin.isTTY ? detectAgent() : null) || undefined;
+        const isAgentMode = agent !== undefined;
+        // --data with a "step" field routes to the appropriate phase
+        if (argv.data && isAgentMode) {
+            let data;
+            try {
+                data = JSON.parse(argv.data);
+            }
+            catch {
+                log.error('Invalid JSON in --data flag. Expected a JSON object.');
+                process.exit(1);
+                return;
+            }
+            if (typeof data.step === 'string') {
+                const result = await routeDataStep(data, agent);
+                log.info(JSON.stringify(enrichResponse(result), null, 2));
+                return;
+            }
+        }
+        if (isAgentMode) {
             const result = await orchestrate({
-                agent: argv.agent || undefined,
+                agent,
                 skipNeonAuth: argv.skipNeonAuth,
                 skipMigrations: argv.skipMigrations,
                 preview: argv.preview,
             });
-            log.info(JSON.stringify(result, null, 2));
+            log.info(JSON.stringify(enrichResponse(result), null, 2));
         }
         else {
             await interactiveInit({ preview: argv.preview });