naro-cli 0.22.0 → 0.24.0

package/dist/commands/confirm.d.ts

@@ -0,0 +1,12 @@
+import type { CommandContext } from "../context";
+/**
+ * Whether a question could be put to anyone: not with `--json`, and not
+ * without a terminal. Only `--yes` answers it then (`confirmOrAbort`).
+ */
+export declare function cannotAsk(context: CommandContext): boolean;
+/**
+ * Gate for destructive actions. Throws instead of silently returning so a
+ * declined/unavailable confirmation is a real failure (exit 1, structured
+ * JSON) — CI must never read "nothing happened" as success.
+ */
+export declare function confirmOrAbort(context: CommandContext, question: string): Promise<void>;

package/dist/commands/db.d.ts

@@ -0,0 +1,32 @@
+import type { CommandContext } from "../context";
+/** How `db query` sees stdin — injectable so tests never touch the real one. */
+export interface DbQueryDeps {
+    stdinIsTty(): boolean;
+    readStdin(): Promise<string>;
+}
+/** `512 B`, `1.5 KB`, `2.0 GB` — binary sizes, as `db dump` prints the file it wrote. */
+export declare function humanSize(bytes: number): string;
+/**
+ * `10 GB`, `100 KB`, `12.29 KB` — Cloudflare states D1's limits in decimal
+ * units, so `db info` prints them that way (PR D). Two decimals, rounded; a
+ * value that rounds to 1000 moves to the next unit (`999,995 B` is `1 MB`,
+ * not `1000 KB` — user review 3).
+ */
+export declare function decimalSize(bytes: number): string;
+/**
+ * A database's size on the `Size:` and `Storage:` lines. From 1 GB, decimal
+ * gigabytes FLOORED to two decimals: the 8 GB warning and the 10 GB limit are
+ * `>=` comparisons, and rounding showed `10.00 GB / 10 GB` for 9,996,000,000
+ * bytes that still took writes, and `8.00 GB` with no warning (user review
+ * 3). Under 1 GB, decimalSize — a new database is `12.29 KB`, not `0.00 GB`.
+ */
+export declare function storageSize(bytes: number): string;
+/** `naro db info` — provider, status, size, table count and the limits. */
+export declare function runDbInfo(context: CommandContext): Promise<void>;
+/** `naro db enable` — idempotent: creates the D1 if the project has none. */
+export declare function runDbEnable(context: CommandContext): Promise<void>;
+/**
+ * `naro db query <sql> | --file <path> | (stdin)` — runs the batch through the
+ * control plane, which classifies it, checks the role and executes it.
+ */
+export declare function runDbQuery(context: CommandContext, deps?: DbQueryDeps): Promise<void>;

package/dist/commands/migration.d.ts

@@ -0,0 +1,78 @@
+import { type MigrationInfo, type NaroClient } from "@next-deploy/sdk";
+import type { CommandContext } from "../context";
+import type { DbQueryDeps } from "./db";
+/** `--dir` wins; otherwise `<--root>/migrations` (or `./migrations`). */
+export declare function migrationsDir(context: CommandContext): string;
+/** `relative()` returns "" for the cwd itself; `migration list` prints "." instead. */
+export declare function relativeToCwd(context: CommandContext, path: string): string;
+/** The ledger, or [] while the project has no database yet — a push creates it. */
+export declare function appliedMigrations(client: NaroClient, projectId: string): Promise<MigrationInfo[]>;
+export declare function printable(text: string): string;
+/**
+ * Whether `printable` shows the text as it is. Text a command takes back —
+ * a CREATE POLICY statement, a condition — must not be printed with `?` in
+ * a character's place: pasted back, it would say something else (PR #74
+ * 리뷰 L2). What is not printable is not printed; `--json` has every byte.
+ */
+export declare function isPrintable(text: string): boolean;
+export declare const UNSHOWN_WARNING_LINE = "(a line of this warning has characters the terminal cannot show; run with --json to see it exactly)";
+/**
+ * A server warning as terminal lines: `⚠ ` and its first line, then each
+ * further line indented. A warning can carry SQL to paste back — the
+ * policies a table rebuild took, one statement a line (P2-7b) — so a line
+ * break starts a new line rather than becoming a `?`; every other control
+ * character does in the first line. A further line it cannot show as it is
+ * is not printed at all — pasted back with a `?` in a character's place, it
+ * would say something else (as `naro policy list` holds a CREATE POLICY to,
+ * PR #74 리뷰 L2) — and `--json` has it exactly.
+ */
+export declare function warningLines(message: string): string[];
+/** Something said about one migration file: a server warning, a refusal. */
+export interface MigrationMessage {
+    migration: string;
+    message: string;
+}
+/**
+ * What the control plane would refuse in each file before it runs any of
+ * it (P2-7b) — a policy statement its parser cannot read, DISABLE ROW LEVEL
+ * SECURITY, GRANT, REVOKE — said the way the server says it: its own
+ * planner over its own split. A file the split cannot read is left to the
+ * server, which says why. The guards (is the table there, is the policy)
+ * need the database and are not run.
+ */
+export declare function policyProblems(dir: string, names: string[]): MigrationMessage[];
+/**
+ * `naro migration new <name>` — creates `migrations/NNNN_<name>.sql` and
+ * never overwrites an existing file. No network: the file is all this writes.
+ */
+export declare function runMigrationNew(context: CommandContext, deps?: DbQueryDeps): Promise<void>;
+/** `naro migration list` — local files against the `d1_migrations` ledger. */
+export declare function runMigrationList(context: CommandContext): Promise<void>;
+/**
+ * Applies `names` from `dir` in order and answers with the ones that went
+ * through, and what the server warned about each (P2-7b: what their
+ * policies need — on stderr as `⚠` lines as they come). Each file is
+ * applied all-or-nothing (D1 runs it as one transaction); a failure stops
+ * the run and the files before it stay applied. Shared with `db reset`,
+ * which re-applies the same way after clearing the ledger — the apply loop
+ * exists once.
+ */
+export declare function applyMigrationFiles(context: CommandContext, client: NaroClient, projectId: string, dir: string, names: string[]): Promise<{
+    applied: string[];
+    warnings: MigrationMessage[];
+}>;
+/**
+ * `naro migration repair <name> --status applied|reverted` — edits the
+ * `d1_migrations` ledger and nothing else. It never runs the migration's SQL:
+ * this is for a ledger that stopped matching the database (a record step that
+ * failed after the file ran, a `db pull` baseline being taken back). To run
+ * SQL, use `db push`.
+ */
+export declare function runMigrationRepair(context: CommandContext): Promise<void>;
+/**
+ * `naro migration up` (= `naro db push`) — applies every pending migration in
+ * order. Each file is applied all-or-nothing (D1 runs it as one transaction);
+ * a failure rolls that file back and stops the run, and the files before it
+ * stay applied (see the ledger via `migration list`).
+ */
+export declare function runMigrationUp(context: CommandContext): Promise<void>;

package/dist/context.d.ts

@@ -0,0 +1,21 @@
+import { NaroClient, type ProjectLink, type ResolvedAuth } from "@next-deploy/sdk";
+import type { GlobalFlags } from "./args";
+import { Output } from "./output";
+import { type Prompter } from "./prompt";
+export interface CommandContext {
+    cwd: string;
+    flags: GlobalFlags;
+    /** Positional args after the (sub)command, e.g. the KEY in `env add KEY`. */
+    positionals: string[];
+    output: Output;
+    prompter: Prompter;
+    /** Returns the first `count` positionals or fails with a usage message. */
+    positionalOrThrow(count: number, usage: string): string[];
+    /** Lazily authenticates; interactive login only in a TTY without --json/--yes. */
+    auth(): Promise<ResolvedAuth>;
+    client(): Promise<NaroClient>;
+    /** Resolves the target project id: --project flag > .naro/project.json. */
+    resolveProjectId(): Promise<string>;
+    projectLink(): ProjectLink | null;
+}
+export declare function createContext(flags: GlobalFlags, positionals?: string[]): CommandContext;

package/dist/data-environment.d.ts

@@ -0,0 +1,36 @@
+import { type NaroClient } from "@next-deploy/sdk";
+import type { GlobalFlags } from "./args";
+import type { CommandContext } from "./context";
+export declare const DATA_ENV_MESSAGES: {
+    readonly name: "--env must be production or an environment name.";
+    readonly preview: "--env preview has no data of its own: preview deployments use production's. Drop --env, or name an environment.";
+    readonly projectWide: (command: string) => string;
+};
+/**
+ * The environment a data command acts on, or null for production. Throws for
+ * a value that names no environment — `preview`, an empty one, one that is no
+ * slug — before any request; whether the environment exists is the control
+ * plane's to answer (`ENVIRONMENT_NOT_FOUND`).
+ */
+export declare function dataEnvironment(flags: Pick<GlobalFlags, "env">): string | null;
+/** The command's client, acting on the data `--env` names. */
+export declare function dataClient(context: Pick<CommandContext, "client" | "flags">): Promise<NaroClient>;
+/** What a prompt and a result line call the database a command acts on. */
+export declare function databaseName(environment: string | null): string;
+/**
+ * The command that puts the backend (back) on: `naro backend enable` for
+ * production's, and for an environment `naro environments provision <slug>` —
+ * backend enable is project-wide and the router refuses it under `--env`.
+ */
+export declare function enableBackendCommand(environment: string | null): string;
+/** ` --env <name>` for a hint that names a command; nothing for production. */
+export declare function envFlag(environment: string | null): string;
+/**
+ * A hint, or a message the CLI prints, as the environment's: every command
+ * it names acts on that environment (`environmentGuidance`, PR #343 review
+ * 2) — a data command takes ` --env <slug>`, a backend repair becomes
+ * `naro environments provision <slug>`, and the backend's switch is said to
+ * be production's, which every environment follows. Production's text
+ * passes through byte for byte.
+ */
+export declare function forEnvironment(text: string, environment: string | null): string;

package/dist/deploy.d.ts

@@ -112,3 +112,4 @@ export interface DeployResult {
  * Shared by `naro deploy` and the MCP `deploy` tool.
  */
 export declare function deployDirectory(sourceDir: string, options: DeployOptions, log: (message: string) => void): Promise<DeployResult>;
+export { assertFunctionsNode, deployFunctions, type DeployedFunction, type DeployFunctionsOptions, type DeployFunctionsResult, } from "./functions/deploy";

package/dist/deploy.js

@@ -1,16 +1,20 @@
 #!/usr/bin/env node
 import {
+  assertFunctionsNode,
   deployDirectory,
+  deployFunctions,
   eventsObserver,
   localDependencies,
   parseDotenv,
   readProjectEnv,
   slugify,
   workingTreeNotices
-} from "./chunk-MBSO3K6L.js";
+} from "./chunk-XJIWWZ2T.js";
 import "./chunk-K3NQKI34.js";
 export {
+  assertFunctionsNode,
   deployDirectory,
+  deployFunctions,
   eventsObserver,
   localDependencies,
   parseDotenv,

package/dist/env-services.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Which outside service the env keys a deploy is missing belong to, and where
+ * that service keeps their values.
+ *
+ * The deploy already works out the names it needs by scanning the source
+ * (`scanEnvReferences`), but a list of bare names only helps someone who
+ * already knows where each value comes from. The first thing anyone moving an
+ * existing app here hits is exactly that gap: the app talks to a Supabase
+ * project that is already running, and the deploy asks for
+ * `NEXT_PUBLIC_SUPABASE_URL` without saying it is asking for something they
+ * have in another browser tab.
+ *
+ * This only names the service and the screen its values are on. Nothing here
+ * reaches Supabase's API, stores a token or creates anything there — the
+ * values still arrive the way every other env var does, from `.env.local`
+ * with the user's consent or from `naro env add`.
+ */
+/** The key without that prefix. The longest match wins, so order is free. */
+export declare function bareEnvKey(key: string): string;
+/**
+ * The given keys that name a Supabase project, in the order given.
+ *
+ * Everything Supabase hands a project is `SUPABASE_*`: the project URL, the
+ * publishable and secret keys, the legacy `anon` and `service_role` keys, the
+ * JWT secret, the account's access token, the database password. Matching the
+ * prefix rather than a fixed list keeps a name we have not seen — Supabase
+ * renamed its keys once already — from dropping out. A name that merely
+ * contains the word (`MY_SUPABASE_URL`) is not one of theirs.
+ *
+ * Belonging to Supabase is not the same as being on one of the screens
+ * `envServiceHints` knows; that function decides which of these it can place.
+ */
+export declare function supabaseKeys(keys: readonly string[]): string[];
+/**
+ * Lines naming the service the missing keys belong to, to print under the
+ * "env var(s) needed" line. Empty when nothing is recognised, which is the
+ * common case — this adds to that line, it never replaces it.
+ *
+ * Adding a second service means another `supabaseKeys`-shaped filter and
+ * another branch here. It is deliberately not a table of services yet: the
+ * useful half of each entry is the screen its values are on, and that is
+ * prose we can only write for a dashboard we have actually checked.
+ */
+export declare function envServiceHints(keys: readonly string[]): string[];

package/dist/functions/deploy.d.ts

@@ -0,0 +1,70 @@
+import { bootCheck, bundleFunction } from "@next-deploy/functions-bundler";
+import { type FunctionUploadTarget, type NaroClient } from "@next-deploy/sdk";
+export declare const PER_FUNCTION_CODES: ReadonlySet<string>;
+export interface DeploySteps {
+    bundle: typeof bundleFunction;
+    boot: typeof bootCheck;
+}
+export interface DeployFunctionsOptions {
+    client: NaroClient;
+    projectId: string;
+    /** Where relative --root, --dir and --import-map start. */
+    cwd: string;
+    root?: string | undefined;
+    dir?: string | undefined;
+    /** Empty or absent: every function in the folder. */
+    names?: readonly string[] | undefined;
+    /**
+     * Wins over function.json either way: the CLI's `--no-verify-jwt` passes
+     * false, naro-mcp's `verifyJwt` passes what it was given — true is never
+     * dropped for function.json's false (PR #353 review).
+     */
+    verifyJwt?: boolean | undefined;
+    importMap?: string | undefined;
+    skipCheck?: boolean | undefined;
+    cliVersion?: string | undefined;
+    /**
+     * Tries after FUNCTIONS_RATE_LIMITED (3 by default, up to 300 s each).
+     * naro-mcp passes 0: one tool call must end within two minutes (plan Q6),
+     * so it hands the error and its retryAfter back instead (final review A-M4).
+     */
+    rateLimitRetries?: number | undefined;
+    /** Tries after FUNCTION_BUSY (3 by default, 5 s each); naro-mcp passes 0. */
+    busyRetries?: number | undefined;
+    /**
+     * The whole run's limit — naro-mcp passes 120 s, so one tool call ends
+     * within about two minutes after the bundle (plan Q6, PR #353 review). The
+     * secrets list, the boot check, making the version, the PUT and the deploy
+     * each get only what is left (never more than their own limit), and none
+     * starts once it is reached. Absent: each step's own limit, as for the CLI.
+     */
+    deadlineMs?: number | undefined;
+    /** Tests move the clock; `Date.now` by default. */
+    now?: (() => number) | undefined;
+    log?: ((line: string) => void) | undefined;
+    /** The presigned PUT's fetch; the global one by default. */
+    fetch?: typeof fetch | undefined;
+    sleep?: ((ms: number) => Promise<void>) | undefined;
+    /** Tests stand in for esbuild and workerd. */
+    steps?: DeploySteps | undefined;
+    /** `process.versions.node` by default. */
+    nodeVersion?: string | undefined;
+}
+export interface DeployedFunction {
+    name: string;
+    version: number | null;
+    url: string;
+    verifyJwt: boolean;
+}
+export interface DeployFunctionsResult {
+    deployed: DeployedFunction[];
+}
+export declare function assertFunctionsNode(version?: string): void;
+/**
+ * The presigned PUT's time limit: as long as the URL still works (60 seconds
+ * at least) plus 30 seconds, so a hung connection ends instead of waiting
+ * for the OS; 15 minutes when the answer has no usable `expiresAt`.
+ */
+export declare function uploadTimeoutMs(upload: FunctionUploadTarget, now?: number): number;
+export declare const deadlineReached: (name: string, deadlineMs: number) => string;
+export declare function deployFunctions(options: DeployFunctionsOptions): Promise<DeployFunctionsResult>;

package/dist/functions/retry.d.ts

@@ -0,0 +1,16 @@
+import { type NaroError } from "@next-deploy/sdk";
+export declare const FUNCTION_RETRIES = 3;
+export declare const FUNCTION_BUSY_WAIT_MS = 5000;
+export declare const FUNCTION_RATE_LIMIT_DEFAULT_SECONDS = 60;
+export declare const FUNCTION_RATE_LIMIT_MAX_SECONDS = 300;
+export declare function defaultSleep(ms: number): Promise<void>;
+/** `details.retryAfter` rounded up, at most 300; 60 when it is missing. */
+export declare function retryAfterSeconds(error: NaroError): number;
+export declare function withFunctionRetries<T>(op: () => Promise<T>, name: string, io: {
+    sleep: (ms: number) => Promise<void>;
+    log: (line: string) => void;
+    /** Tries after FUNCTIONS_RATE_LIMITED: 3 by default; naro-mcp passes 0. */
+    rateLimitRetries?: number | undefined;
+    /** Tries after FUNCTION_BUSY: 3 by default; naro-mcp passes 0. */
+    busyRetries?: number | undefined;
+}): Promise<T>;