neon 2.1.2 → 2.29.0

package/dist/env_file.js

@@ -0,0 +1,159 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * Default dotenv file `env pull` writes to: `.env` when one already exists in the working
+ * directory (update where secrets already live), otherwise `.env.local` — matching the
+ * `vercel env pull` convention. An explicit `--file` always wins over this.
+ */
+export const resolveEnvFilePath = (cwd, file) => {
+    if (file)
+        return join(cwd, file);
+    if (existsSync(join(cwd, ".env")))
+        return join(cwd, ".env");
+    return join(cwd, ".env.local");
+};
+/**
+ * Merge `updates` into the dotenv content at `path`, preserving every other line
+ * (comments, blank lines, unrelated keys) and the file's existing order. Keys present in
+ * both are updated in place; keys only in `updates` are appended. A non-existent file is
+ * treated as empty. When `managedKeys` is given, any owned key on disk that is absent from
+ * `updates` is removed. Returns the keys written and the (managed) keys removed.
+ */
+export const mergeEnvFile = (path, updates, options = {}) => {
+    const original = existsSync(path) ? readFileSync(path, "utf8") : "";
+    const { content, written, removed } = mergeEnvContent(original, updates, options);
+    writeFileSync(path, content);
+    return { written, removed };
+};
+/**
+ * Pure core of {@link mergeEnvFile}: takes the current file content and the updates, and
+ * returns the new content plus which keys were written / removed. Kept side-effect-free so
+ * it can be unit-tested without touching the filesystem.
+ */
+export const mergeEnvContent = (original, updates, options = {}) => {
+    const keys = Object.keys(updates);
+    // Owned keys the current pull did not produce: stale Neon-managed vars to prune. Anything
+    // not in `managedKeys` is always kept, so a user's own lines are never removed.
+    const stale = new Set([...(options.managedKeys ?? [])].filter((key) => !(key in updates)));
+    if (keys.length === 0 && stale.size === 0) {
+        return { content: original, written: [], removed: [] };
+    }
+    const remaining = new Set(keys);
+    const removed = [];
+    const lines = original === "" ? [] : original.split("\n");
+    // Walk the file: drop stale owned lines, update existing keys in place (so their position
+    // and any surrounding comments are preserved), and pass everything else through untouched.
+    const updatedLines = [];
+    for (const line of lines) {
+        const key = parseKey(line);
+        if (key !== null && stale.has(key)) {
+            removed.push(key);
+            continue;
+        }
+        if (key !== null && remaining.has(key)) {
+            remaining.delete(key);
+            updatedLines.push(formatLine(key, updates[key]));
+            continue;
+        }
+        updatedLines.push(line);
+    }
+    // Append keys that weren't already present, in the order they were given.
+    const appended = keys
+        .filter((key) => remaining.has(key))
+        .map((key) => formatLine(key, updates[key]));
+    const body = trimTrailingBlank(updatedLines);
+    const content = [...body, ...appended].join("\n");
+    return {
+        // A dotenv file ends with a trailing newline.
+        content: content === "" ? "" : `${content}\n`,
+        written: keys,
+        removed,
+    };
+};
+/**
+ * Read a dotenv file at `path` into a plain `{ KEY: value }` map. A non-existent file is an
+ * error (callers pass an explicit `--env` path, so a typo should fail loudly rather than
+ * silently load nothing). Quotes are stripped and `\"` / `\\` unescaped, matching the
+ * quoting {@link mergeEnvFile} writes. Comments, blank lines, and non-assignment lines are
+ * ignored.
+ */
+export const readEnvFile = (path) => {
+    if (!existsSync(path)) {
+        throw new Error(`Env file not found: ${path}`);
+    }
+    const out = {};
+    for (const line of readFileSync(path, "utf8").split("\n")) {
+        const parsed = parseAssignment(line);
+        if (parsed)
+            out[parsed.key] = parsed.value;
+    }
+    return out;
+};
+/**
+ * Load a dotenv file into `process.env` so values are available to anything read later
+ * (e.g. a `neon.ts` whose function `env` values come from `process.env.X`). Existing
+ * `process.env` entries are **not** overridden — an already-exported var wins over the
+ * file, matching dotenv's default. Returns the keys that were applied.
+ */
+export const loadEnvFileIntoProcess = (path) => {
+    const parsed = readEnvFile(path);
+    const applied = [];
+    for (const [key, value] of Object.entries(parsed)) {
+        if (process.env[key] === undefined) {
+            process.env[key] = value;
+            applied.push(key);
+        }
+    }
+    return applied;
+};
+/**
+ * Extract the variable name from a dotenv line, or `null` for comments / blank lines / any
+ * line that isn't a `KEY=value` assignment. Tolerates a leading `export ` and surrounding
+ * whitespace, matching common `.env` styles.
+ */
+const parseKey = (line) => {
+    const match = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/.exec(line);
+    return match ? match[1] : null;
+};
+/**
+ * Parse a `KEY=value` dotenv line into its key and unquoted value, or `null` for
+ * comments / blank lines / non-assignments. Mirrors {@link formatLine}'s quoting.
+ */
+const parseAssignment = (line) => {
+    const match = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/.exec(line);
+    const key = match?.[1];
+    const raw = match?.[2];
+    if (key === undefined || raw === undefined)
+        return null;
+    return { key, value: unquote(raw.trim()) };
+};
+/** Strip matching surrounding quotes and unescape `\"` / `\\` inside double quotes. */
+const unquote = (value) => {
+    if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) {
+        return value.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+    }
+    if (value.length >= 2 && value.startsWith("'") && value.endsWith("'")) {
+        return value.slice(1, -1);
+    }
+    return value;
+};
+/**
+ * Render a `KEY=value` line. The value is wrapped in double quotes when it contains
+ * characters that would otherwise break parsing (spaces, `#`, quotes, `=`), with inner
+ * quotes/backslashes escaped — Neon connection strings and URLs are safe either way, but
+ * quoting defensively avoids surprises for tools that re-parse the file.
+ */
+const formatLine = (key, value) => {
+    const needsQuotes = /[\s#"'=]/.test(value);
+    if (!needsQuotes)
+        return `${key}=${value}`;
+    const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    return `${key}="${escaped}"`;
+};
+/** Drop trailing blank lines so we don't accumulate them across repeated merges. */
+const trimTrailingBlank = (lines) => {
+    const out = [...lines];
+    while (out.length > 0 && out[out.length - 1]?.trim() === "")
+        out.pop();
+    return out;
+};

package/dist/errors.js

@@ -0,0 +1,80 @@
+const ERROR_MATCHERS = [
+    [/^Unknown command: (.*)$/, "UNKNOWN_COMMAND"],
+    [/^Missing required argument: (.*)$/, "MISSING_ARGUMENT"],
+    [/^Failed to open web browser. (.*)$/, "AUTH_BROWSER_FAILED"],
+];
+export const matchErrorCode = (message) => {
+    if (!message) {
+        return "UNKNOWN_ERROR";
+    }
+    for (const [matcher, code] of ERROR_MATCHERS) {
+        const match = message.match(matcher);
+        if (match) {
+            return code;
+        }
+    }
+    return "UNKNOWN_ERROR";
+};
+/**
+ * The single, human-readable line shown when the CLI couldn't reach the Neon API because
+ * of a connection-level failure (DNS, refused/reset connection, offline). It replaces the
+ * cryptic `fetch failed` / empty axios message a network blip otherwise surfaces (see
+ * {@link isNetworkError}), pointing at the two things the user can actually check.
+ */
+export const NETWORK_ERROR_MESSAGE = "Could not reach the Neon API. Please check your internet connection and try again. " +
+    "If your connection is fine and this keeps happening, check https://neonstatus.com for ongoing incidents.";
+/**
+ * Node-level socket/DNS error codes that mean the request never reached the server — a
+ * genuine connectivity problem rather than an API response we should surface. Deliberately
+ * excludes `ECONNABORTED` (axios' timeout), which the CLI already reports as a timeout.
+ */
+const NETWORK_ERROR_CODES = new Set([
+    "ECONNREFUSED",
+    "ECONNRESET",
+    "ETIMEDOUT",
+    "ENOTFOUND",
+    "EAI_AGAIN",
+    "EPIPE",
+    "EHOSTUNREACH",
+    "ENETUNREACH",
+    "EHOSTDOWN",
+    "ENETDOWN",
+]);
+/**
+ * Message fragments that mark a connection-level failure across our two transports: the
+ * `@neon/sdk` / global `fetch` path (used by `env pull` / `config` / `deploy`, and `link`'s
+ * bundled env pull) throws a bare `TypeError: fetch failed` / "Failed to fetch", while the
+ * axios `api-client` path throws an `AxiosError` whose message is "Network Error".
+ */
+const NETWORK_ERROR_MESSAGE_PATTERN = /fetch failed|failed to fetch|network error/i;
+const readErrorCode = (value) => {
+    if (value === null || typeof value !== "object")
+        return undefined;
+    const code = value.code;
+    return typeof code === "string" ? code : undefined;
+};
+/**
+ * Whether `err` is a connection-level failure (the network blip the user sees as a cryptic
+ * `fetch failed`, or no message at all on the axios path) rather than an actual API response.
+ *
+ * A Node `fetch` failure is a bare `TypeError: fetch failed` whose underlying `cause` carries
+ * the real socket `code` (e.g. `ECONNREFUSED`, `ENOTFOUND`, `EAI_AGAIN`), so we walk the
+ * `cause` chain checking both the code and the message. This is what lets the CLI swap the
+ * confusing default for {@link NETWORK_ERROR_MESSAGE}. It matches only failures where no
+ * response was ever received, so it never masks a real 4xx/5xx the user needs to see.
+ */
+export const isNetworkError = (err) => {
+    let current = err;
+    for (let depth = 0; depth < 6 && current !== null && current !== undefined; depth++) {
+        const code = readErrorCode(current);
+        if (code !== undefined && NETWORK_ERROR_CODES.has(code)) {
+            return true;
+        }
+        if (current instanceof Error &&
+            NETWORK_ERROR_MESSAGE_PATTERN.test(current.message)) {
+            return true;
+        }
+        current = current.cause;
+    }
+    return false;
+};

package/dist/functions_api.js

@@ -0,0 +1,44 @@
+import { ContentType } from "./api.js";
+const functionsPath = (projectId, branchId) => `/projects/${encodeURIComponent(projectId)}/branches/${encodeURIComponent(branchId)}/functions`;
+export const listFunctions = async (apiClient, projectId, branchId, { cursor, limit } = {}) => {
+    const { data } = await apiClient.request({
+        path: functionsPath(projectId, branchId),
+        method: "GET",
+        query: { cursor, limit },
+        secure: true,
+        format: "json",
+    });
+    return { functions: data.functions ?? [], next: data.pagination?.next };
+};
+export const getFunction = async (apiClient, projectId, branchId, slug) => {
+    const { data } = await apiClient.request({
+        path: `${functionsPath(projectId, branchId)}/${encodeURIComponent(slug)}`,
+        method: "GET",
+        secure: true,
+        format: "json",
+    });
+    return data.function;
+};
+export const deleteFunction = async (apiClient, projectId, branchId, slug) => {
+    await apiClient.request({
+        path: `${functionsPath(projectId, branchId)}/${encodeURIComponent(slug)}`,
+        method: "DELETE",
+        secure: true,
+    });
+};
+export const createDeployment = async (apiClient, projectId, branchId, slug, params) => {
+    const form = new FormData();
+    form.append("zip", new Blob([params.zip]), "bundle.zip");
+    form.append("runtime", params.runtime);
+    if (params.environment)
+        form.append("environment", params.environment);
+    // The deploy POST returns an operation the CLI cannot poll; the body is
+    // ignored. We only need the request to succeed.
+    await apiClient.request({
+        path: `${functionsPath(projectId, branchId)}/${encodeURIComponent(slug)}/deployments`,
+        method: "POST",
+        type: ContentType.FormData,
+        body: form,
+        secure: true,
+    });
+};

package/dist/help.js

@@ -0,0 +1,146 @@
+import chalk from "chalk";
+import cliui from "cliui";
+import { consumeBlockIfMatches, consumeNextMatching, drawPointer, splitColumns, } from "./utils/ui.js";
+// target width for the leftmost column
+const SPACE_WIDTH = 20;
+const formatHelp = (help) => {
+    const lines = help.split("\n");
+    const result = [];
+    // full command, like `neonctl projects list`
+    const topLevelCommand = consumeNextMatching(lines, /^.*/);
+    if (topLevelCommand) {
+        result.push(chalk.bold(topLevelCommand.replace("[options]", chalk.reset.green("[options]"))));
+        result.push("");
+    }
+    // commands description block
+    // example command to see: neonctl projects
+    const commandsBlock = consumeBlockIfMatches(lines, /^Commands:/);
+    if (commandsBlock.length > 0) {
+        const header = commandsBlock.shift();
+        result.push(header);
+        const ui = cliui({
+            width: 0,
+        });
+        commandsBlock.forEach((line) => {
+            if (/^\s{3,}/.exec(line)) {
+                ui.div({
+                    text: "",
+                    width: SPACE_WIDTH,
+                    padding: [0, 0, 0, 0],
+                }, { text: line.trim(), padding: [0, 0, 0, 0] });
+                return;
+            }
+            const [command, description] = splitColumns(line);
+            // patch the previous command if it was multiline
+            if (!description && ui.rows.length > 1) {
+                ui.rows[ui.rows.length - 2][0].text += command;
+                return;
+            }
+            ui.div(chalk.cyan(command));
+            ui.div({
+                text: chalk.gray(drawPointer(SPACE_WIDTH)),
+                width: SPACE_WIDTH,
+                padding: [0, 0, 0, 0],
+            }, { text: description, padding: [0, 0, 0, 2] });
+        });
+        result.push(ui.toString());
+        result.push("");
+    }
+    // positional args block
+    // example command to see: neonctl branches rename
+    const positionalsBlock = consumeBlockIfMatches(lines, /Positionals:/);
+    if (positionalsBlock.length > 0) {
+        const header = positionalsBlock.shift();
+        result.push(header);
+        const ui = cliui({
+            width: 0,
+        });
+        positionalsBlock.forEach((line) => {
+            const [positional, description] = splitColumns(line);
+            ui.div({
+                text: positional,
+                width: SPACE_WIDTH,
+                padding: [0, 2, 0, 0],
+            }, {
+                text: description,
+                padding: [0, 0, 0, 0],
+            });
+        });
+        result.push(ui.toString());
+        result.push("");
+    }
+    // command description
+    // example command to see: neonctl projects list
+    const descriptionBlock = consumeBlockIfMatches(lines, /^(?!.*options:)/i);
+    if (descriptionBlock.length > 0) {
+        result.push(...descriptionBlock);
+        result.push("");
+    }
+    while (true) {
+        // there are two options blocks: global and specific
+        // example to see both: neonctl projects create
+        const optionsBlock = consumeBlockIfMatches(lines, /.*options:/i);
+        if (optionsBlock.length === 0) {
+            break;
+        }
+        result.push(optionsBlock.shift());
+        optionsBlock.forEach((line) => {
+            const [option, description] = splitColumns(line);
+            const ui = cliui({
+                width: 0,
+            });
+            if (option.startsWith("-")) {
+                ui.div({
+                    text: chalk.green(option),
+                    padding: [0, 0, 0, 0],
+                });
+                ui.div({
+                    text: chalk.gray(drawPointer(SPACE_WIDTH)),
+                    width: SPACE_WIDTH,
+                    padding: [0, 2, 0, 0],
+                }, {
+                    text: chalk.rgb(210, 210, 210)(description ?? ""),
+                    padding: [0, 0, 0, 0],
+                });
+            }
+            else {
+                ui.div({
+                    padding: [0, 0, 0, 0],
+                    text: "",
+                    width: SPACE_WIDTH,
+                }, {
+                    text: chalk.rgb(210, 210, 210)(option),
+                    padding: [0, 0, 0, 0],
+                });
+            }
+            result.push(ui.toString());
+        });
+        result.push("");
+    }
+    const exampleBlock = consumeBlockIfMatches(lines, /Examples:/);
+    if (exampleBlock.length > 0) {
+        result.push(exampleBlock.shift());
+        const ui = cliui({
+            width: 0,
+        });
+        for (const line of exampleBlock) {
+            const [command, description] = splitColumns(line);
+            ui.div({
+                text: chalk.bold(command),
+                padding: [0, 0, 0, 0],
+            });
+            ui.div({
+                text: chalk.reset(description),
+                padding: [0, 0, 0, 2],
+            });
+        }
+        result.push(ui.toString());
+    }
+    return [...result, ...lines];
+};
+export const showHelp = async (argv) => {
+    // add wrap to ensure that there are no line breaks
+    const help = await argv.getHelp();
+    process.stderr.write(formatHelp(help).join("\n") + "\n");
+    process.exit(0);
+};

package/dist/index.js

@@ -0,0 +1,234 @@
+import { basename } from "node:path";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { analyticsMiddleware, closeAnalytics, getAnalyticsEventProperties, initAnalyticsClientMiddleware, sendError, trackEvent, } from "./analytics.js";
+import { isNeonApiError, messageFromBody } from "./api.js";
+import { defaultClientID } from "./auth.js";
+import { deleteCredentials, ensureAuth } from "./commands/auth.js";
+import commands from "./commands/index.js";
+import { defaultDir, ensureConfigDir } from "./config.js";
+import { currentContextFile, enrichFromContext } from "./context.js";
+import { isNetworkError, matchErrorCode, NETWORK_ERROR_MESSAGE, } from "./errors.js";
+import { showHelp } from "./help.js";
+import { log } from "./log.js";
+import pkg from "./pkg.js";
+import { fillInArgs } from "./utils/middlewares.js";
+const NO_SUBCOMMANDS_VERBS = [
+    // aliases
+    "auth",
+    "login",
+    "me",
+    // aliases
+    "cs",
+    "connection-string",
+    "psql",
+    "set-context",
+    "checkout",
+    "link",
+    "init",
+    "dev",
+    "deploy",
+    "bootstrap",
+    // alias of `config status`
+    "status",
+];
+let builder = yargs(hideBin(process.argv));
+builder = builder
+    .scriptName(pkg.name)
+    .locale("en")
+    .usage("$0 <command> [options]")
+    .parserConfiguration({
+    "populate--": true,
+})
+    .help()
+    .option("output", {
+    alias: "o",
+    group: "Global options:",
+    describe: "Set output format",
+    type: "string",
+    choices: ["json", "yaml", "table"],
+    default: "table",
+})
+    .option("api-host", {
+    describe: "The API host",
+    hidden: true,
+    default: process.env.NEON_API_HOST ?? "https://console.neon.tech/api/v2",
+})
+    // Setup config directory
+    .option("config-dir", {
+    describe: "Path to config directory",
+    group: "Global options:",
+    type: "string",
+    default: defaultDir,
+})
+    .option("force-auth", {
+    describe: "Force authentication",
+    type: "boolean",
+    hidden: true,
+    default: false,
+})
+    .middleware(ensureConfigDir)
+    .options({
+    "oauth-host": {
+        description: "URL to Neon OAuth host",
+        hidden: true,
+        default: process.env.NEON_OAUTH_HOST ?? "https://oauth2.neon.tech",
+    },
+    "client-id": {
+        description: "OAuth client id",
+        hidden: true,
+        type: "string",
+        default: defaultClientID,
+    },
+    "api-key": {
+        describe: "API key",
+        group: "Global options:",
+        type: "string",
+        default: process.env.NEON_API_KEY ?? "",
+    },
+    apiClient: {
+        hidden: true,
+        coerce: (v) => v,
+        default: null,
+    },
+    "context-file": {
+        describe: "Context file",
+        type: "string",
+        default: currentContextFile,
+    },
+    color: {
+        group: "Global options:",
+        describe: "Colorize the output. Example: --no-color, --color false",
+        type: "boolean",
+        default: true,
+    },
+    analytics: {
+        describe: "Manage analytics. Example: --no-analytics, --analytics false",
+        group: "Global options:",
+        type: "boolean",
+        default: true,
+    },
+})
+    .middleware((args) => {
+    fillInArgs(args);
+}, true)
+    .middleware(initAnalyticsClientMiddleware, true)
+    .help(false)
+    .group("help", "Global options:")
+    .option("help", {
+    describe: "Show help",
+    type: "boolean",
+    default: false,
+})
+    .alias("help", "h")
+    .middleware(async (args) => {
+    if (args.help ||
+        (args._.length === 1 &&
+            !NO_SUBCOMMANDS_VERBS.includes(args._[0]))) {
+        await showHelp(builder);
+    }
+})
+    .middleware(ensureAuth)
+    .middleware(enrichFromContext)
+    .middleware(analyticsMiddleware)
+    .command(commands)
+    .strictCommands()
+    .version(pkg.version)
+    .group("version", "Global options:")
+    .alias("version", "v")
+    .completion()
+    .scriptName(basename(process.argv[1]) === "neon" ? "neon" : "neonctl")
+    .epilog("For more information, visit https://neon.com/docs/reference/neon-cli")
+    .wrap(null)
+    .fail(false);
+async function handleError(msg, err) {
+    if (process.argv.some((arg) => arg === "--help" || arg === "-h")) {
+        await showHelp(builder);
+        process.exit(0);
+    }
+    // Log stack trace if available
+    if (err instanceof Error && err.stack) {
+        log.debug("Stack: %s", err.stack);
+    }
+    // A connection-level failure (no response ever reached us) reads as a cryptic
+    // `fetch failed` from the @neon/sdk / global `fetch` path. Detect it first and
+    // swap in one clear "check your connection" hint. We deliberately do not retry
+    // here: re-running the whole command could re-trigger a non-idempotent step
+    // (e.g. project create), so retries belong at the request layer.
+    if (isNetworkError(err)) {
+        log.error(NETWORK_ERROR_MESSAGE);
+        const error = err instanceof Error ? err : new Error(NETWORK_ERROR_MESSAGE);
+        sendError(error, "NETWORK_ERROR");
+        return false;
+    }
+    if (isNeonApiError(err)) {
+        if (err.code === "ECONNABORTED") {
+            log.error("Request timed out");
+            sendError(err, "REQUEST_TIMEOUT");
+            return false;
+        }
+        else if (err.status === 401) {
+            sendError(err, "AUTH_FAILED");
+            log.info("Authentication failed, deleting credentials...");
+            try {
+                deleteCredentials(defaultDir);
+                return true; // Allow retry for auth failures
+            }
+            catch (deleteErr) {
+                log.debug("Failed to delete credentials: %s", deleteErr instanceof Error
+                    ? deleteErr.message
+                    : "unknown error");
+                return false;
+            }
+        }
+        else {
+            const serverMessage = messageFromBody(err.data);
+            if (serverMessage) {
+                log.error(serverMessage);
+            }
+            log.debug("status: %d %s | path: %s", err.status, err.statusText, err.requestPath);
+            sendError(err, "API_ERROR");
+            return false;
+        }
+    }
+    else {
+        const error = err instanceof Error ? err : new Error(msg || "Unknown error");
+        sendError(error, matchErrorCode(error.message));
+        log.error(error.message);
+        return false;
+    }
+}
+void (async () => {
+    // Main loop with max 2 attempts (initial + 1 retry):
+    let attempts = 0;
+    const MAX_ATTEMPTS = 2;
+    while (attempts < MAX_ATTEMPTS) {
+        try {
+            const args = await builder.argv;
+            // Send analytics for a successful attempt
+            trackEvent("cli_command_success", {
+                ...getAnalyticsEventProperties(args),
+                projectId: args.projectId,
+                branchId: args.branchId,
+                accountId: args.accountId,
+                authMethod: args.authMethod,
+                authData: args.authData,
+            });
+            if (args._.length === 0 || args.help) {
+                await showHelp(builder);
+                process.exit(0);
+            }
+            await closeAnalytics();
+            break;
+        }
+        catch (err) {
+            attempts++;
+            const shouldRetry = await handleError("", err);
+            if (!shouldRetry || attempts >= MAX_ATTEMPTS) {
+                await closeAnalytics();
+                process.exit(1);
+            }
+            // If shouldRetry is true and we haven't hit max attempts, loop continues
+        }
+    }
+})();

package/dist/log.js

@@ -0,0 +1,18 @@
+import { format } from "node:util";
+import { isDebug } from "./env.js";
+export const log = {
+    debug: (...args) => {
+        if (isDebug()) {
+            process.stderr.write(`DEBUG: ${format(...args)}\n`);
+        }
+    },
+    warning: (...args) => {
+        process.stderr.write(`WARNING: ${format(...args)}\n`);
+    },
+    info: (...args) => {
+        process.stderr.write(`INFO: ${format(...args)}\n`);
+    },
+    error: (...args) => {
+        process.stderr.write(`ERROR: ${format(...args)}\n`);
+    },
+};