neonctl 2.24.2 → 2.25.1

package/commands/functions.js

@@ -1,4 +1,4 @@
-import { existsSync } from 'node:fs';
+import { existsSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { isAxiosError } from 'axios';
 import { retryOnLock } from '../api.js';
@@ -21,8 +21,27 @@ const DEPLOYMENT_FIELDS = [
     'memory_mib',
     'created_at',
 ];
+// Deploy emits the resolved deployment plus the function's invocation_url, so a
+// successful `functions deploy` tells the user exactly where to call the function.
+const DEPLOY_RESULT_FIELDS = [
+    'id',
+    'status',
+    'invocation_url',
+    'runtime',
+    'memory_mib',
+    'created_at',
+];
+// In table mode a failed build's reason gets its own "deployment error"
+// section after the deployment table; json/yaml carry the raw `error` field.
+const writeDeploymentErrorSection = (out, dep) => {
+    if (dep.status === 'failed' && dep.error) {
+        out.write({ reason: dep.error }, { fields: ['reason'], title: 'deployment error' });
+    }
+};
 const SLUG_PATTERN = /^[a-z0-9]{1,20}$/;
 const SLUG_HELP = 'Use 1-20 lowercase letters and digits (no hyphens or other characters).';
+// Entry-point discovery order inside --src.
+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
@@ -52,13 +71,19 @@ export const builder = (argv) => argv
     demandOption: true,
 })
     .options({
+    src: {
+        describe: 'Function source: a directory containing index.ts, index.mjs, or index.js, or a path to the entry file',
+        type: 'string',
+    },
+    // Removed flags, kept hidden so old invocations fail loudly instead
+    // of being silently ignored (the CLI has no .strictOptions()).
     path: {
-        describe: 'Base directory for the function (resolves --entry)',
         type: 'string',
+        hidden: true,
     },
     entry: {
-        describe: 'Entry file to bundle, relative to --path',
         type: 'string',
+        hidden: true,
     },
     runtime: {
         describe: 'Function runtime',
@@ -77,10 +102,19 @@ export const builder = (argv) => argv
     },
 }), (args) => deploy(args))
     .command('list', 'List functions on the branch', (yargs) => yargs, (args) => list(args))
-    .command('get <slug>', "Show a function's details", (yargs) => yargs.positional('slug', {
+    .command('get <slug>', "Show a function's details", (yargs) => yargs
+    .positional('slug', {
     describe: 'Function slug',
     type: 'string',
     demandOption: true,
+})
+    .options({
+    'list-env-variables': {
+        describe: 'List the environment variable names of the active deployment',
+        type: 'boolean',
+        alias: 'E',
+        default: false,
+    },
 }), (args) => get(args))
     .command('delete <slug>', 'Delete a function on the branch', (yargs) => yargs.positional('slug', {
     describe: 'Function slug',
@@ -104,6 +138,15 @@ const parseEnv = (entries) => {
     return JSON.stringify(map);
 };
 const statusHint = (slug, projectId, branchId) => `Check status with: neonctl functions 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) => {
+    const out = writer(props).write({ ...deployment, invocation_url: fn?.invocation_url }, { fields: DEPLOY_RESULT_FIELDS });
+    if (props.output !== 'json' && props.output !== 'yaml') {
+        writeDeploymentErrorSection(out, deployment);
+    }
+    out.end();
+};
 // A poll error worth retrying: a network error (no HTTP response), a 5xx, or a
 // 404 from eventual consistency. Anything else (e.g. 401/403) is surfaced.
 const isTransient = (err) => isAxiosError(err) &&
@@ -111,27 +154,36 @@ const isTransient = (err) => isAxiosError(err) &&
         err.response.status === 404 ||
         err.response.status >= 500);
 const deploy = async (props) => {
+    if (props.path !== undefined || props.entry !== undefined) {
+        throw new Error('--path and --entry were removed. Use --src <dir>; the entry point ' +
+            'is discovered as index.ts, index.mjs, or index.js in that directory.');
+    }
     // At least one deploy option must be passed (--wait is excluded: it controls
     // output, not what gets deployed).
-    const hasOption = props.path !== undefined ||
-        props.entry !== undefined ||
+    const hasOption = props.src !== undefined ||
         props.env !== undefined ||
         props.runtime !== undefined;
     if (!hasOption) {
-        throw new Error('Provide at least one option to deploy, e.g. --path, --entry, or --env. ' +
+        throw new Error('Provide at least one option to deploy, e.g. --src or --env. ' +
             'See: neonctl functions deploy --help.');
     }
     // Cheap, offline validation first - fail before any network round-trip.
     if (!SLUG_PATTERN.test(props.slug)) {
         throw new Error(`Invalid function slug "${props.slug}". ${SLUG_HELP}`);
     }
-    const path = props.path ?? '.';
-    const entry = props.entry ?? 'index.ts';
+    const src = props.src ?? '.';
     const runtime = props.runtime ?? 'nodejs24';
     const environment = parseEnv(props.env);
-    const source = join(path, entry);
-    if (!existsSync(source)) {
-        throw new Error(`Entry file not found: ${source}. Pass --entry to point at your function's entry file (defaults to index.ts).`);
+    const srcStat = statSync(src, { throwIfNoEntry: false });
+    if (srcStat === undefined) {
+        throw new Error(`--src path not found: ${src}.`);
+    }
+    // A file is used as the entry point directly; a directory triggers discovery.
+    const source = srcStat.isFile()
+        ? src
+        : ENTRY_CANDIDATES.map((name) => join(src, name)).find((p) => existsSync(p));
+    if (source === undefined) {
+        throw new Error(`No entry file found in ${src}. Expected one of: ${ENTRY_CANDIDATES.join(', ')}.`);
     }
     // Bundle before any network round-trip so a bundling failure fails fast.
     const zip = zipBundle(await bundleEntry(source));
@@ -165,6 +217,9 @@ const deploy = async (props) => {
     // 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.
+    let resolvedFn;
     const deadline = Date.now() + POLL_TIMEOUT_MS;
     try {
         while (!interrupted && Date.now() < deadline) {
@@ -173,18 +228,20 @@ const deploy = async (props) => {
                 break;
             // The deploy already succeeded server-side; tolerate transient poll
             // failures and retry on the next interval. Surface anything else.
-            let dep;
+            let fn;
             try {
-                dep = (await getFunction(props.apiClient, props.projectId, branchId, props.slug)).active_deployment;
+                fn = await getFunction(props.apiClient, props.projectId, branchId, props.slug);
             }
             catch (err) {
                 if (isTransient(err))
                     continue;
                 throw err;
             }
+            const dep = fn.active_deployment;
             const isNew = dep !== undefined && (before === undefined || dep.id > before);
             if (isNew && dep) {
                 resolved = dep;
+                resolvedFn = fn;
                 if (!props.wait)
                     break;
                 if (dep.status === 'completed' || dep.status === 'failed')
@@ -199,14 +256,14 @@ const deploy = async (props) => {
     if (interrupted) {
         log.info(statusHint(props.slug, props.projectId, branchId));
         if (resolved)
-            writer(props).end(resolved, { fields: DEPLOYMENT_FIELDS });
+            emitDeployResult(props, resolved, resolvedFn);
         return;
     }
     if (resolved === undefined) {
         log.info(statusHint(props.slug, props.projectId, branchId));
         throw new Error(`Timed out waiting for the deployment of ${props.slug} to start. It may still be in progress.`);
     }
-    writer(props).end(resolved, { fields: DEPLOYMENT_FIELDS });
+    emitDeployResult(props, resolved, resolvedFn);
     if (!props.wait) {
         log.info(statusHint(props.slug, props.projectId, branchId));
         return;
@@ -238,6 +295,14 @@ const get = async (props) => {
             fields: DEPLOYMENT_FIELDS,
             title: 'active deployment',
         });
+        writeDeploymentErrorSection(out, fn.active_deployment);
+    }
+    if (props.listEnvVariables) {
+        out.write((fn.active_deployment?.environment ?? []).map((name) => ({ name })), {
+            fields: ['name'],
+            title: 'environment',
+            emptyMessage: 'No environment variables on the active deployment.',
+        });
     }
     out.end();
 };

package/commands/index.js

@@ -22,6 +22,7 @@ import * as config from './config.js';
 import * as deploy from './deploy.js';
 import * as env from './env.js';
 import * as bucket from './bucket.js';
+import * as bootstrap from './bootstrap.js';
 export default [
     auth,
     users,
@@ -47,4 +48,5 @@ export default [
     deploy,
     env,
     bucket,
+    bootstrap,
 ];