neonctl 2.37.1 → 2.38.1

package/dist/commands/schema_diff.js

@@ -1,151 +0,0 @@
-import chalk from "chalk";
-import { createPatch } from "diff";
-import { sendError } from "../analytics.js";
-import { isNeonApiError, messageFromBody } from "../api.js";
-import { log } from "../log.js";
-import { branchIdFromProps } from "../utils/enrichers.js";
-import { parsePointInTime, } from "../utils/point_in_time.js";
-import { writer } from "../writer.js";
-const COLORS = {
-    added: chalk.green,
-    removed: chalk.red,
-    header: chalk.yellow,
-    section: chalk.magenta,
-};
-export const schemaDiff = async (props) => {
-    props.branch = props.baseBranch || props.branch;
-    const baseBranch = await branchIdFromProps(props);
-    let pointInTime = await parsePointInTime({
-        pointInTime: props.compareSource,
-        targetBranchId: baseBranch,
-        projectId: props.projectId,
-        api: props.apiClient,
-    });
-    // Swap base and compare points if comparing with parent branch
-    const comparingWithParent = props.compareSource.startsWith("^parent");
-    let baseBranchPoint = {
-        branchId: baseBranch,
-        tag: "head",
-    };
-    [baseBranchPoint, pointInTime] = comparingWithParent
-        ? [pointInTime, baseBranchPoint]
-        : [baseBranchPoint, pointInTime];
-    const baseDatabases = await fetchDatabases(baseBranch, props);
-    if (props.database) {
-        const database = baseDatabases.find((db) => db.name === props.database);
-        if (!database) {
-            throw new Error(`Database ${props.database} does not exist in base branch ${baseBranch}`);
-        }
-        const patch = await createSchemaDiff(baseBranchPoint, pointInTime, database, props);
-        writer(props).text(colorize(patch));
-        return;
-    }
-    await Promise.all(baseDatabases.map(async (database) => {
-        const patch = await createSchemaDiff(baseBranchPoint, pointInTime, database, props);
-        writer(props).text(colorize(patch));
-    }));
-};
-const fetchDatabases = async (branch, props) => {
-    return props.apiClient
-        .listProjectBranchDatabases(props.projectId, branch)
-        .then((response) => response.data.databases);
-};
-const createSchemaDiff = async (baseBranch, pointInTime, database, props) => {
-    const [baseSchema, compareSchema] = await Promise.all([
-        fetchSchema(baseBranch, database, props),
-        fetchSchema(pointInTime, database, props),
-    ]);
-    return createPatch(`Database: ${database.name}`, baseSchema, compareSchema, generateHeader(baseBranch), generateHeader(pointInTime));
-};
-const fetchSchema = async (pointInTime, database, props) => {
-    try {
-        const response = await props.apiClient.getProjectBranchSchema({
-            projectId: props.projectId,
-            branchId: pointInTime.branchId,
-            db_name: database.name,
-            ...pointInTimeParams(pointInTime),
-        });
-        return response.data.sql ?? "";
-    }
-    catch (error) {
-        if (isNeonApiError(error)) {
-            sendError(error, "API_ERROR");
-            throw new Error(messageFromBody(error.data) ??
-                `Error while fetching schema for branch ${pointInTime.branchId}`);
-        }
-        throw error;
-    }
-};
-const colorize = (patch) => {
-    return patch
-        .replace(/^([^\n]+)\n([^\n]+)\n/m, "") // Remove first two lines
-        .replace(/^-.*/gm, colorizer("removed"))
-        .replace(/^\+.*/gm, colorizer("added"))
-        .replace(/^@@.+@@.*/gm, colorizer("section"));
-};
-const colorizer = (colorId) => {
-    const color = COLORS[colorId];
-    return (line) => color(line);
-};
-const pointInTimeParams = (pointInTime) => {
-    switch (pointInTime.tag) {
-        case "timestamp":
-            return {
-                timestamp: pointInTime.timestamp,
-            };
-        case "lsn":
-            return {
-                lsn: pointInTime.lsn ?? undefined,
-            };
-        default:
-            return {};
-    }
-};
-const generateHeader = (pointInTime) => {
-    const header = `(Branch: ${pointInTime.branchId}`;
-    switch (pointInTime.tag) {
-        case "timestamp":
-            return `${header} at ${pointInTime.timestamp})`;
-        case "lsn":
-            return `${header} at ${pointInTime.lsn})`;
-        default:
-            return `${header})`;
-    }
-};
-/*
-  The command has two positional optional arguments - [base-branch] and [compare-source]
-  If only one argument is specified, we should consider it as `compare-source`
-    and `base-branch` will be either read from context or the default branch of project.
-  If no branches are specified, compare the context branch with its parent
-*/
-export const parseSchemaDiffParams = async (props) => {
-    if (!props.compareSource) {
-        if (props.baseBranch) {
-            props.compareSource = props.baseBranch;
-            props.baseBranch = props.branch;
-        }
-        else if (props.branch) {
-            const { data } = await props.apiClient.listProjectBranches({
-                projectId: props.projectId,
-            });
-            const contextBranch = data.branches.find((b) => b.id === props.branch || b.name === props.branch);
-            if (contextBranch?.parent_id == undefined) {
-                throw new Error(`No branch specified. Your context branch (${props.branch}) has no parent, so no comparison is possible.`);
-            }
-            log.info(`No branches specified. Comparing your context branch '${props.branch}' with its parent`);
-            props.compareSource = "^parent";
-        }
-        else {
-            const { data } = await props.apiClient.listProjectBranches({
-                projectId: props.projectId,
-            });
-            const defaultBranch = data.branches.find((b) => b.default);
-            if (defaultBranch?.parent_id == undefined) {
-                throw new Error("No branch specified. Include a base branch or add a set-context branch to continue. Your default branch has no parent, so no comparison is possible.");
-            }
-            log.info(`No branches specified. Comparing default branch with its parent`);
-            props.compareSource = "^parent";
-        }
-    }
-    return props;
-};

package/dist/commands/set_context.js

@@ -1,29 +0,0 @@
-import { applyContext } from "../context.js";
-import { log } from "../log.js";
-export const command = "set-context";
-export const describe = "Deprecated: use `neonctl link`. Set the .neon context (raw write).";
-export 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",
-    },
-});
-export const handler = (props) => {
-    log.warning("`neonctl set-context` is deprecated and will be removed in a future release. " +
-        "Use `neonctl link` instead — it verifies inputs and infers the org for you " +
-        "(or `neonctl link --no-checks` for the same write-without-checks behavior).");
-    const context = {
-        projectId: props.projectId,
-        orgId: props.orgId,
-        branchId: props.branchId,
-    };
-    applyContext(props.contextFile, context);
-};

package/dist/commands/snapshots.js

@@ -1,455 +0,0 @@
-import { retryOnLock } from "../api.js";
-import { log } from "../log.js";
-import { branchIdResolve, fillSingleProject, resolveBranchRef, } from "../utils/enrichers.js";
-import { looksLikeLSN, looksLikeTimestamp } from "../utils/formats.js";
-import { writer } from "../writer.js";
-import { BRANCH_FIELDS } from "./branches.js";
-export const SNAPSHOT_FIELDS = [
-    "id",
-    "name",
-    "source_branch_id",
-    "created_at",
-    "expires_at",
-];
-const SCHEDULE_FIELDS = [
-    "frequency",
-    "hour",
-    "day",
-    "month",
-    "retention_seconds",
-];
-const OPERATION_FIELDS = [
-    "id",
-    "action",
-    "status",
-];
-// The values the Neon API accepts for a backup-schedule entry's `frequency`
-// (per the OpenAPI `BackupScheduleItem` description). `satisfies` fails the
-// build if a value listed here leaves the SDK's `SnapshotFrequency` union, so
-// the CLI can never offer a frequency the API rejects.
-const SNAPSHOT_FREQUENCIES = [
-    "daily",
-    "weekly",
-    "monthly",
-];
-/** Narrow an arbitrary string to a supported {@link SnapshotFrequency}. */
-const isSnapshotFrequency = (value) => SNAPSHOT_FREQUENCIES.some((frequency) => frequency === value);
-export const command = "snapshots";
-export const describe = "Manage snapshots";
-export const aliases = ["snapshot"];
-export 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, (args) => get(args))
-    .command("create", "Create a snapshot from a branch", (yargs) => yargs
-    .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
-    .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, (args) => deleteSnapshot(args))
-    .command("restore <id>", "Restore a snapshot into a branch", (yargs) => yargs
-    .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))
-    .demandCommand(1, "Specify `get` or `set`."), () => { })
-    .demandCommand(1, "Specify a snapshots sub-command.");
-export 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);
-/** Normalize a user-supplied date to an ISO 8601 string, or throw a friendly error. */
-const toIso = (value, flag) => {
-    const ms = Date.parse(value);
-    if (Number.isNaN(ms)) {
-        throw new Error(`Invalid ${flag} value: "${value}". Use an RFC 3339 timestamp, e.g. 2025-12-31T23:59:59Z.`);
-    }
-    return new Date(ms).toISOString();
-};
-/**
- * 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"}`);
-};
-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 !== undefined && !looksLikeLSN(props.lsn)) {
-        throw new Error(`Invalid --lsn value: "${props.lsn}". Expected an LSN like 0/1F3C8A0.`);
-    }
-    if (props.timestamp !== undefined && !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 resolveBranchRef({
-        ...props,
-        branch: props.branch,
-    });
-    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")
-            : undefined,
-    }));
-    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 === undefined &&
-        props.expiresAt === undefined &&
-        !props.clearExpiration) {
-        throw new Error("Nothing to update. Pass --name, --expires-at, or --clear-expiration.");
-    }
-    const snapshot = await resolveSnapshot(props);
-    // `undefined` fields are dropped by JSON serialization, so an omitted
-    // `expires_at` leaves the expiration unchanged while an explicit `null`
-    // clears it.
-    const expiresAt = props.clearExpiration
-        ? null
-        : props.expiresAt !== undefined
-            ? toIso(props.expiresAt, "--expires-at")
-            : undefined;
-    const { data } = await retryOnLock(() => props.apiClient.updateSnapshot(props.projectId, snapshot.id, {
-        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));
-    // The delete endpoint returns the tracking operations (202), not the snapshot
-    // body, so echo the snapshot we just deleted for confirmation.
-    writer(props).end(snapshot, {
-        fields: SNAPSHOT_FIELDS,
-        renderColumns: {
-            expires_at: (s) => s.expires_at || "never",
-        },
-    });
-};
-const restore = async (props) => {
-    const snapshot = await resolveSnapshot(props);
-    const targetBranchId = props.targetBranch
-        ? await branchIdResolve({
-            branch: props.targetBranch,
-            projectId: props.projectId,
-            apiClient: props.apiClient,
-        })
-        : undefined;
-    const { data } = await retryOnLock(() => props.apiClient.restoreSnapshot(props.projectId, snapshot.id, {
-        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 } : undefined));
-    writer(props).end(data.operations ?? [], {
-        fields: OPERATION_FIELDS,
-        title: "operations",
-        emptyMessage: `Finalized restore for branch ${branchId}.`,
-    });
-};
-const scheduleGet = async (props) => {
-    const { branchId } = await resolveBranchRef({
-        ...props,
-        branch: props.branch,
-    });
-    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 === undefined) {
-                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) => {
-    const { branchId } = await resolveBranchRef({
-        ...props,
-        branch: props.branch,
-    });
-    let schedule;
-    if (props.schedule) {
-        schedule = parseScheduleJson(props.schedule);
-    }
-    else if (props.frequency) {
-        const item = { frequency: props.frequency };
-        if (props.hour !== undefined)
-            item.hour = props.hour;
-        if (props.day !== undefined)
-            item.day = props.day;
-        if (props.month !== undefined)
-            item.month = props.month;
-        if (props.retention !== undefined)
-            item.retention_seconds = props.retention;
-        schedule = [item];
-    }
-    else {
-        throw new Error("Provide --frequency (optionally with --hour/--day/--month/--retention) or --schedule <json>.");
-    }
-    await retryOnLock(() => props.apiClient.setSnapshotSchedule(props.projectId, branchId, {
-        schedule,
-    }));
-    writer(props).end(schedule, {
-        fields: SCHEDULE_FIELDS,
-        title: "schedule",
-    });
-};

package/dist/commands/status.js

@@ -1,40 +0,0 @@
-import { fillSingleProject } from "../utils/enrichers.js";
-import { status } from "./config.js";
-/**
- * `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`.
- */
-export const command = "status";
-export const describe = "Show the branch's live Neon state (alias of `config status`)";
-export 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);
-export const handler = (args) => status(args);

package/dist/commands/user.js

@@ -1,15 +0,0 @@
-import { writer } from "../writer.js";
-export const command = "me";
-export const describe = "Show current user";
-export const builder = (yargs) => yargs.option("context-file", {
-    hidden: true,
-});
-export const handler = async (args) => {
-    await me(args);
-};
-const me = async (props) => {
-    const { data } = await props.apiClient.getCurrentUserInfo();
-    writer(props).end(data, {
-        fields: ["login", "email", "name", "projects_limit"],
-    });
-};