neonctl 2.28.0 → 2.29.1

package/dist/psql/command/cmd_meta.js

@@ -34,21 +34,20 @@
  *     additionally honours a separate "query output" file set via `\o`;
  *     that wiring lives in WP-15 and we leave the hook in place.
  */
-import { spawnSync } from 'node:child_process';
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { readLine } from '../io/input.js';
-import { getHistory } from '../io/history.js';
-import { slashUsage } from '../core/help.js';
-import { helpSQL } from '../core/help.js';
-import { writeOut, writeErr, parseBool } from './shared.js';
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { helpSQL, slashUsage } from "../core/help.js";
+import { getHistory } from "../io/history.js";
+import { readLine } from "../io/input.js";
+import { parseBool, writeErr, writeOut } from "./shared.js";
 /** `\q` / `\quit` — exit the REPL. */
 export const cmdQuit = {
-    name: 'q',
-    aliases: ['quit'],
-    helpKey: 'q',
-    run: () => Promise.resolve({ status: 'exit' }),
+    name: "q",
+    aliases: ["quit"],
+    helpKey: "q",
+    run: () => Promise.resolve({ status: "exit" }),
 };
 /**
  * `\!` — shell escape. Whole-line mode: the entire rest of the line is the
@@ -64,18 +63,18 @@ export const cmdQuit = {
  * resilient against environments where `sh` is unavailable.
  */
 export const cmdShell = {
-    name: '!',
-    argMode: 'whole-line',
-    helpKey: '!',
+    name: "!",
+    argMode: "whole-line",
+    helpKey: "!",
     run: (ctx) => {
         const line = ctx.restOfLine().trim();
         try {
             if (line.length === 0) {
-                const shell = process.env.SHELL ?? '/bin/sh';
-                spawnSync(shell, ['-i'], { stdio: 'inherit' });
+                const shell = process.env.SHELL ?? "/bin/sh";
+                spawnSync(shell, ["-i"], { stdio: "inherit" });
             }
             else {
-                spawnSync('sh', ['-c', line], { stdio: 'inherit' });
+                spawnSync("sh", ["-c", line], { stdio: "inherit" });
             }
         }
         catch {
@@ -83,28 +82,28 @@ export const cmdShell = {
             // keep running even when the child won't start. Status stays `ok` so
             // a failing `\!` is purely informational.
         }
-        return Promise.resolve({ status: 'ok' });
+        return Promise.resolve({ status: "ok" });
     },
 };
 /** `\cd [dir]` — change cwd. No arg falls back to `$HOME`. */
 export const cmdCd = {
-    name: 'cd',
-    helpKey: 'cd',
+    name: "cd",
+    helpKey: "cd",
     run: (ctx) => {
-        const dir = ctx.nextArg('normal');
+        const dir = ctx.nextArg("normal");
         const target = dir && dir.length > 0 ? dir : (process.env.HOME ?? null);
         if (!target) {
             writeErr(`\\${ctx.cmdName}: could not determine home directory\n`);
-            return Promise.resolve({ status: 'error' });
+            return Promise.resolve({ status: "error" });
         }
         try {
             process.chdir(target);
-            return Promise.resolve({ status: 'ok' });
+            return Promise.resolve({ status: "ok" });
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
             writeErr(`\\${ctx.cmdName}: ${msg}\n`);
-            return Promise.resolve({ status: 'error' });
+            return Promise.resolve({ status: "error" });
         }
     },
 };
@@ -130,14 +129,14 @@ const runEcho = (ctx, write) => {
         let i = 0;
         while (i < ctx.rawArgs.length && /\s/.test(ctx.rawArgs[i]))
             i++;
-        return (ctx.rawArgs.slice(i, i + 2) === '-n' &&
+        return (ctx.rawArgs.slice(i, i + 2) === "-n" &&
             (i + 2 === ctx.rawArgs.length || /\s/.test(ctx.rawArgs[i + 2])));
     })();
     for (;;) {
-        const arg = ctx.nextArg('normal');
+        const arg = ctx.nextArg("normal");
         if (arg === null)
             break;
-        if (first && firstArgIsUnquotedDashN && arg === '-n') {
+        if (first && firstArgIsUnquotedDashN && arg === "-n") {
             noNewline = true;
             first = false;
             continue;
@@ -145,20 +144,20 @@ const runEcho = (ctx, write) => {
         first = false;
         parts.push(arg);
     }
-    const out = parts.join(' ') + (noNewline ? '' : '\n');
+    const out = parts.join(" ") + (noNewline ? "" : "\n");
     write(out);
-    return { status: 'ok' };
+    return { status: "ok" };
 };
 /** `\echo` — write args to stdout. */
 export const cmdEcho = {
-    name: 'echo',
-    helpKey: 'echo',
+    name: "echo",
+    helpKey: "echo",
     run: (ctx) => Promise.resolve(runEcho(ctx, writeOut)),
 };
 /** `\qecho` — write args to the query output (logfile if set, else stdout). */
 export const cmdQecho = {
-    name: 'qecho',
-    helpKey: 'qecho',
+    name: "qecho",
+    helpKey: "qecho",
     run: (ctx) => {
         const { logfile } = ctx.settings;
         const write = (s) => {
@@ -174,8 +173,8 @@ export const cmdQecho = {
 };
 /** `\warn` — write args to stderr. */
 export const cmdWarn = {
-    name: 'warn',
-    helpKey: 'warn',
+    name: "warn",
+    helpKey: "warn",
     run: (ctx) => Promise.resolve(runEcho(ctx, writeErr)),
 };
 /**
@@ -193,27 +192,27 @@ export const cmdWarn = {
  * the first is the prompt and the second the variable.
  */
 export const cmdPrompt = {
-    name: 'prompt',
-    helpKey: 'prompt',
+    name: "prompt",
+    helpKey: "prompt",
     run: async (ctx) => {
         const args = [];
         for (;;) {
-            const a = ctx.nextArg('normal');
+            const a = ctx.nextArg("normal");
             if (a === null)
                 break;
             args.push(a);
         }
         // A leading `-` selects the no-echo (password) read path.
         let echo = true;
-        if (args.length > 0 && args[0] === '-') {
+        if (args.length > 0 && args[0] === "-") {
             echo = false;
             args.shift();
         }
         if (args.length === 0) {
             writeErr(`\\${ctx.cmdName}: missing required argument\n`);
-            return { status: 'error' };
+            return { status: "error" };
         }
-        let promptText = '';
+        let promptText = "";
         let varname;
         if (args.length === 1) {
             varname = args[0];
@@ -225,9 +224,9 @@ export const cmdPrompt = {
         const line = await readLine(promptText, { echo });
         if (!ctx.settings.vars.set(varname, line)) {
             writeErr(`\\${ctx.cmdName}: invalid variable name "${varname}"\n`);
-            return { status: 'error' };
+            return { status: "error" };
         }
-        return { status: 'ok' };
+        return { status: "ok" };
     },
 };
 /**
@@ -250,30 +249,30 @@ export const cmdPrompt = {
  *     accepts or returns a wording string.
  */
 export const cmdSet = {
-    name: 'set',
-    helpKey: 'set',
+    name: "set",
+    helpKey: "set",
     run: (ctx) => {
-        const name = ctx.nextArg('normal');
+        const name = ctx.nextArg("normal");
         if (name === null) {
             // List all vars sorted by name.
             const entries = [...ctx.settings.vars.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
             for (const [k, v] of entries) {
                 writeOut(`${k} = '${v}'\n`);
             }
-            return Promise.resolve({ status: 'ok' });
+            return Promise.resolve({ status: "ok" });
         }
         const values = [];
         for (;;) {
-            const a = ctx.nextArg('normal');
+            const a = ctx.nextArg("normal");
             if (a === null)
                 break;
             values.push(a);
         }
-        const value = values.join('');
+        const value = values.join("");
         const result = ctx.settings.vars.trySet(name, value);
         if (!result.ok) {
             const prefix = psqlErrorPrefix(ctx.settings);
-            if (result.reason === 'invalid-name') {
+            if (result.reason === "invalid-name") {
                 writeErr(`${prefix}invalid variable name: "${name}"\n`);
             }
             else if (result.error !== undefined) {
@@ -289,9 +288,9 @@ export const cmdSet = {
                 // built-in hooks take this path, but third-party callers might.
                 writeErr(`${prefix}error while setting variable "${name}"\n`);
             }
-            return Promise.resolve({ status: 'error' });
+            return Promise.resolve({ status: "error" });
         }
-        return Promise.resolve({ status: 'ok' });
+        return Promise.resolve({ status: "ok" });
     },
 };
 /**
@@ -310,49 +309,49 @@ export const cmdSet = {
  * the regress harness, which passes `--quiet`) produces no output.
  */
 export const cmdReset = {
-    name: 'r',
-    aliases: ['reset'],
-    helpKey: 'r',
+    name: "r",
+    aliases: ["reset"],
+    helpKey: "r",
     run: (ctx) => {
         if (!ctx.settings.quiet) {
-            writeOut('Query buffer reset (cleared).\n');
+            writeOut("Query buffer reset (cleared).\n");
         }
-        return Promise.resolve({ status: 'reset-buf', newBuf: '' });
+        return Promise.resolve({ status: "reset-buf", newBuf: "" });
     },
 };
 /** `\unset varname` — unset a psql variable. */
 export const cmdUnset = {
-    name: 'unset',
-    helpKey: 'unset',
+    name: "unset",
+    helpKey: "unset",
     run: (ctx) => {
-        const name = ctx.nextArg('normal');
+        const name = ctx.nextArg("normal");
         if (name === null) {
             writeErr(`\\${ctx.cmdName}: missing required argument\n`);
-            return Promise.resolve({ status: 'error' });
+            return Promise.resolve({ status: "error" });
         }
         ctx.settings.vars.unset(name);
-        return Promise.resolve({ status: 'ok' });
+        return Promise.resolve({ status: "ok" });
     },
 };
 export const cmdGetenv = {
-    name: 'getenv',
-    helpKey: 'getenv',
+    name: "getenv",
+    helpKey: "getenv",
     run: (ctx) => {
-        const varname = ctx.nextArg('normal');
-        const envname = ctx.nextArg('normal');
+        const varname = ctx.nextArg("normal");
+        const envname = ctx.nextArg("normal");
         if (varname === null || envname === null) {
             writeErr(`\\${ctx.cmdName}: missing required argument\n`);
-            return Promise.resolve({ status: 'error' });
+            return Promise.resolve({ status: "error" });
         }
         const value = process.env[envname];
         if (value === undefined) {
-            return Promise.resolve({ status: 'ok' });
+            return Promise.resolve({ status: "ok" });
         }
         if (!ctx.settings.vars.set(varname, value)) {
             writeErr(`\\${ctx.cmdName}: invalid variable name "${varname}"\n`);
-            return Promise.resolve({ status: 'error' });
+            return Promise.resolve({ status: "error" });
         }
-        return Promise.resolve({ status: 'ok' });
+        return Promise.resolve({ status: "ok" });
     },
 };
 /**
@@ -362,17 +361,17 @@ export const cmdGetenv = {
  * rejects names containing `=`.
  */
 export const cmdSetenv = {
-    name: 'setenv',
-    helpKey: 'setenv',
+    name: "setenv",
+    helpKey: "setenv",
     run: (ctx) => {
-        const envname = ctx.nextArg('normal');
+        const envname = ctx.nextArg("normal");
         if (envname === null) {
             writeErr(`\\${ctx.cmdName}: missing required argument\n`);
-            return Promise.resolve({ status: 'error' });
+            return Promise.resolve({ status: "error" });
         }
-        if (envname.includes('=')) {
+        if (envname.includes("=")) {
             writeErr(`\\${ctx.cmdName}: environment variable name must not contain "="\n`);
-            return Promise.resolve({ status: 'error' });
+            return Promise.resolve({ status: "error" });
         }
         // Upstream `exec_command_setenv` reads BOTH the name AND the value with
         // OT_NORMAL — `:VAR` substitution applies to the value so
@@ -381,7 +380,7 @@ export const cmdSetenv = {
         // value.) The mainloop context maintains a per-mode cursor, so using
         // a single mode for both calls also keeps positional reads in sync —
         // each cursor advances exactly once per call.
-        const value = ctx.nextArg('normal');
+        const value = ctx.nextArg("normal");
         if (value === null) {
             // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
             delete process.env[envname];
@@ -389,7 +388,7 @@ export const cmdSetenv = {
         else {
             process.env[envname] = value;
         }
-        return Promise.resolve({ status: 'ok' });
+        return Promise.resolve({ status: "ok" });
     },
 };
 /**
@@ -409,11 +408,11 @@ export const cmdSetenv = {
  * concatenate the severity directly (`prefix + 'ERROR:  msg'`).
  */
 export const psqlErrorPrefix = (settings, lineNumber) => {
-    if (settings.curCmdSource === 'file' && settings.inputfile) {
-        const lineSuffix = lineNumber !== undefined ? String(lineNumber) : '';
+    if (settings.curCmdSource === "file" && settings.inputfile) {
+        const lineSuffix = lineNumber !== undefined ? String(lineNumber) : "";
         return `psql:${settings.inputfile}:${lineSuffix}: `;
     }
-    return '';
+    return "";
 };
 /**
  * Walk past leading whitespace + `--` line comments + slash-star block
@@ -535,9 +534,9 @@ export const renderLineAndCaret = (sqlText, position) => {
     // The server's offset is 1-based and points at the failing character.
     const idx = Math.min(rebasedPos - 1, trimmed.length);
     // Find the line containing `idx`.
-    let lineStart = trimmed.lastIndexOf('\n', idx - 1);
+    let lineStart = trimmed.lastIndexOf("\n", idx - 1);
     lineStart = lineStart === -1 ? 0 : lineStart + 1;
-    let lineEnd = trimmed.indexOf('\n', lineStart);
+    let lineEnd = trimmed.indexOf("\n", lineStart);
     if (lineEnd === -1)
         lineEnd = trimmed.length;
     const lineText = trimmed.slice(lineStart, lineEnd);
@@ -550,15 +549,15 @@ export const renderLineAndCaret = (sqlText, position) => {
     let col = idx - lineStart;
     // Snap past trailing whitespace when the position lands inside it —
     // see the function header for the rationale (trim-on-send delta).
-    const lineTrimEndLen = lineText.replace(/[ \t\f\v]+$/u, '').length;
+    const lineTrimEndLen = lineText.replace(/[ \t\f\v]+$/u, "").length;
     if (col >= lineTrimEndLen && col < lineText.length) {
         col = lineText.length;
     }
-    const caretIndent = ' '.repeat(Math.max(0, col));
+    const caretIndent = " ".repeat(Math.max(0, col));
     const prefix = `LINE ${String(lineNumber)}: `;
     return {
         line: `${prefix}${lineText}`,
-        caret: `${' '.repeat(prefix.length)}${caretIndent}^`,
+        caret: `${" ".repeat(prefix.length)}${caretIndent}^`,
     };
 };
 /**
@@ -588,10 +587,10 @@ export const renderLineAndCaret = (sqlText, position) => {
  * appears when we have both originating SQL text and a 1-based position
  * pointing inside it.
  */
-export const formatErrorReport = (e, verbosity = 'default', showContext = 'errors') => {
-    const severity = e.severity ?? 'ERROR';
-    const sqlstate = e.code ?? e.sqlstate ?? 'XX000';
-    const message = e.message ?? '';
+export const formatErrorReport = (e, verbosity = "default", showContext = "errors") => {
+    const severity = e.severity ?? "ERROR";
+    const sqlstate = e.code ?? e.sqlstate ?? "XX000";
+    const message = e.message ?? "";
     const out = [];
     // `sqlstate` mode is the upstream "just give me the code" flavour:
     // emit `<severity>:  <sqlstate>` with NO message body. `verbose` mode
@@ -601,14 +600,14 @@ export const formatErrorReport = (e, verbosity = 'default', showContext = 'error
     // Reference: upstream `pg_log_pre_callback` / `PQresultErrorMessage`
     // with `verbosity = PQERRORS_SQLSTATE`, which formats just
     // `severity: sqlstate\n` and stops.
-    if (verbosity === 'sqlstate') {
+    if (verbosity === "sqlstate") {
         out.push(`${severity}:  ${sqlstate}`);
         return out;
     }
-    if (verbosity === 'verbose') {
+    if (verbosity === "verbose") {
         out.push(`${severity}:  ${sqlstate}: ${message}`);
     }
-    else if (verbosity === 'terse') {
+    else if (verbosity === "terse") {
         // Terse suppresses LINE/caret/DETAIL/HINT/CONTEXT, but it merges the
         // server's `position` into the severity line as `at character N` —
         // matches libpq's `pqGetErrorNotice3` with `PQERRORS_TERSE` (and
@@ -641,12 +640,12 @@ export const formatErrorReport = (e, verbosity = 'default', showContext = 'error
     // formatter as an error report, so 'errors' and 'always' both include
     // CONTEXT, while 'never' suppresses it. Verbose verbosity unconditionally
     // includes CONTEXT.
-    const includeContext = verbosity === 'verbose' || showContext !== 'never';
+    const includeContext = verbosity === "verbose" || showContext !== "never";
     if (includeContext && e.where) {
         out.push(`CONTEXT:  ${e.where}`);
     }
-    if (verbosity === 'verbose' && (e.routine || e.file || e.line)) {
-        const location = (e.routine ?? '') + (e.file ? `, ${e.file}:${e.line ?? ''}` : '');
+    if (verbosity === "verbose" && (e.routine || e.file || e.line)) {
+        const location = (e.routine ?? "") + (e.file ? `, ${e.file}:${e.line ?? ""}` : "");
         out.push(`LOCATION:  ${location}`);
     }
     return out;
@@ -671,27 +670,27 @@ export const formatErrorReport = (e, verbosity = 'default', showContext = 'error
  * we have both the originating SQL text and a server-provided position.
  */
 export const cmdErrverbose = {
-    name: 'errverbose',
-    helpKey: 'errverbose',
+    name: "errverbose",
+    helpKey: "errverbose",
     run: (ctx) => {
         const e = ctx.settings.lastErrorResult;
         if (!e || (!e.message && !e.sqlstate && !e.code)) {
             // Upstream `exec_command_errverbose` writes the "no previous error"
             // notice to stdout (via `printf`); only the verbose re-render goes to
             // stderr (via `pg_log_error`).
-            writeOut('There is no previous error.\n');
-            return Promise.resolve({ status: 'ok' });
+            writeOut("There is no previous error.\n");
+            return Promise.resolve({ status: "ok" });
         }
         // `\errverbose` always emits the full verbose form regardless of the
         // currently active VERBOSITY setting. Output is prefixed with the same
         // `psql:[<file>:<n>]:` tag upstream's `pg_log_pre_callback` adds — only
         // on the leading severity line; subsequent layers (LINE / caret / DETAIL
         // / HINT / LOCATION) stay unprefixed to match libpq's `PQresultErrorMessage`.
-        const lines = formatErrorReport(e, 'verbose', 'always');
+        const lines = formatErrorReport(e, "verbose", "always");
         const prefix = psqlErrorPrefix(ctx.settings);
         const prefixed = [prefix + lines[0], ...lines.slice(1)];
-        writeErr(prefixed.join('\n') + '\n');
-        return Promise.resolve({ status: 'ok' });
+        writeErr(prefixed.join("\n") + "\n");
+        return Promise.resolve({ status: "ok" });
     },
 };
 /**
@@ -700,10 +699,10 @@ export const cmdErrverbose = {
  * upstream errors "Boolean expected" (review: minor divergences).
  */
 export const cmdTiming = {
-    name: 'timing',
-    helpKey: 'timing',
+    name: "timing",
+    helpKey: "timing",
     run: (ctx) => {
-        const arg = ctx.nextArg('normal');
+        const arg = ctx.nextArg("normal");
         let next;
         if (arg === null) {
             next = !ctx.settings.timing;
@@ -712,13 +711,13 @@ export const cmdTiming = {
             const parsed = parseBool(arg);
             if (parsed === null) {
                 writeErr(`\\${ctx.cmdName}: unrecognized value "${arg}" for "\\timing": Boolean expected\n`);
-                return Promise.resolve({ status: 'error' });
+                return Promise.resolve({ status: "error" });
             }
             next = parsed;
         }
         ctx.settings.timing = next;
-        writeOut(`Timing is ${next ? 'on' : 'off'}.\n`);
-        return Promise.resolve({ status: 'ok' });
+        writeOut(`Timing is ${next ? "on" : "off"}.\n`);
+        return Promise.resolve({ status: "ok" });
     },
 };
 /**
@@ -772,11 +771,11 @@ LICENSE file for distribution terms.
  * Neon notice is appended after it.
  */
 export const cmdCopyright = {
-    name: 'copyright',
-    helpKey: 'copyright',
+    name: "copyright",
+    helpKey: "copyright",
     run: () => {
         writeOut(COPYRIGHT_TEXT + NEON_NOTICE);
-        return Promise.resolve({ status: 'ok' });
+        return Promise.resolve({ status: "ok" });
     },
 };
 /**
@@ -787,7 +786,7 @@ export const cmdCopyright = {
  */
 const screenWidth = () => {
     const cols = process.stdout.columns;
-    return typeof cols === 'number' && cols > 0 ? cols : 80;
+    return typeof cols === "number" && cols > 0 ? cols : 80;
 };
 /**
  * `\h [TOPIC]` (alias `\help`) — show SQL command help.
@@ -798,15 +797,15 @@ const screenWidth = () => {
  * matches. Mirrors upstream `exec_command_help` in `command.c`.
  */
 export const cmdHelpSQL = {
-    name: 'h',
-    aliases: ['help'],
-    helpKey: 'h',
+    name: "h",
+    aliases: ["help"],
+    helpKey: "h",
     run: (ctx) => {
         // Upstream consumes the rest of the line in `OT_WHOLE_LINE` mode so
         // multi-word topics like "CREATE TABLE" come through intact.
         const topic = ctx.restOfLine();
         helpSQL(process.stdout, topic.length === 0 ? null : topic, screenWidth());
-        return Promise.resolve({ status: 'ok' });
+        return Promise.resolve({ status: "ok" });
     },
 };
 /**
@@ -824,9 +823,9 @@ export const cmdHelpSQL = {
  * so a stray topic doesn't leak into the next command.
  */
 export const cmdSlashHelp = {
-    name: '?',
-    argMode: 'whole-line',
-    helpKey: '?',
+    name: "?",
+    argMode: "whole-line",
+    helpKey: "?",
     run: (ctx) => {
         // Consume the rest of the line (`\? options`, `\? variables`) so the
         // cursor doesn't strand trailing text; we only render the command help.
@@ -834,7 +833,7 @@ export const cmdSlashHelp = {
         const out = process.stdout;
         const pager = Boolean(out.isTTY);
         slashUsage(out, pager);
-        return Promise.resolve({ status: 'ok' });
+        return Promise.resolve({ status: "ok" });
     },
 };
 /**
@@ -850,7 +849,7 @@ export const resolveEditor = (env = process.env) => {
     const explicit = env.PSQL_EDITOR ?? env.EDITOR ?? env.VISUAL;
     if (explicit !== undefined && explicit.length > 0)
         return explicit;
-    return process.platform === 'win32' ? 'notepad.exe' : 'vi';
+    return process.platform === "win32" ? "notepad.exe" : "vi";
 };
 /**
  * `\e` / `\edit [FILE] [LINE]` — edit the current query buffer (or a file)
@@ -875,43 +874,44 @@ export const resolveEditor = (env = process.env) => {
  * (`\e file`) and `\ef`/`\ev` on top.
  */
 export const cmdEdit = {
-    name: 'e',
-    aliases: ['edit'],
-    argMode: 'whole-line',
-    helpKey: 'e',
+    name: "e",
+    aliases: ["edit"],
+    argMode: "whole-line",
+    helpKey: "e",
     run: (ctx) => {
         // We don't yet support `\e FILE`; consume the args so they don't strand.
         ctx.restOfLine();
         const editor = resolveEditor();
         // psql seeds the temp file with the current query buffer. A trailing
         // newline keeps editors that expect newline-terminated files happy.
-        const seed = ctx.queryBuf.length > 0 && !ctx.queryBuf.endsWith('\n')
-            ? ctx.queryBuf + '\n'
+        const seed = ctx.queryBuf.length > 0 && !ctx.queryBuf.endsWith("\n")
+            ? ctx.queryBuf + "\n"
             : ctx.queryBuf;
         let dir = null;
         try {
-            dir = mkdtempSync(join(tmpdir(), 'psql.edit.'));
-            const file = join(dir, 'edit.sql');
-            writeFileSync(file, seed, 'utf8');
-            const result = spawnSync(editor, [file], { stdio: 'inherit' });
-            if (result.error || (result.status !== null && result.status !== 0)) {
+            dir = mkdtempSync(join(tmpdir(), "psql.edit."));
+            const file = join(dir, "edit.sql");
+            writeFileSync(file, seed, "utf8");
+            const result = spawnSync(editor, [file], { stdio: "inherit" });
+            if (result.error ||
+                (result.status !== null && result.status !== 0)) {
                 const why = result.error
                     ? result.error.message
                     : `editor exited with status ${String(result.status)}`;
                 writeErr(`\\${ctx.cmdName}: ${why}\n`);
-                return Promise.resolve({ status: 'error' });
+                return Promise.resolve({ status: "error" });
             }
-            let edited = readFileSync(file, 'utf8');
+            let edited = readFileSync(file, "utf8");
             // Upstream drops a single trailing newline the editor may have added
             // so an unchanged round-trip restores the original buffer exactly.
-            if (edited.endsWith('\n'))
+            if (edited.endsWith("\n"))
                 edited = edited.slice(0, -1);
-            return Promise.resolve({ status: 'reset-buf', newBuf: edited });
+            return Promise.resolve({ status: "reset-buf", newBuf: edited });
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
             writeErr(`\\${ctx.cmdName}: ${msg}\n`);
-            return Promise.resolve({ status: 'error' });
+            return Promise.resolve({ status: "error" });
         }
         finally {
             if (dir) {
@@ -942,29 +942,29 @@ export const cmdEdit = {
  * populated as each line is submitted (see `io/history.ts`).
  */
 export const cmdS = {
-    name: 's',
-    helpKey: 's',
+    name: "s",
+    helpKey: "s",
     run: (ctx) => {
-        const fname = ctx.nextArg('normal');
+        const fname = ctx.nextArg("normal");
         const entries = getHistory();
         // Each entry is one logical command; readline's `\s` prints them one
         // per line, so a trailing newline per entry reproduces that layout.
-        const body = entries.map((e) => e + '\n').join('');
+        const body = entries.map((e) => e + "\n").join("");
         if (fname === null || fname.length === 0) {
             writeOut(body);
-            return Promise.resolve({ status: 'ok' });
+            return Promise.resolve({ status: "ok" });
         }
         try {
-            writeFileSync(fname, body, 'utf8');
+            writeFileSync(fname, body, "utf8");
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
             writeErr(`\\${ctx.cmdName}: ${msg}\n`);
-            return Promise.resolve({ status: 'error' });
+            return Promise.resolve({ status: "error" });
         }
         if (!ctx.settings.quiet) {
             writeOut(`Wrote history to file "${fname}".\n`);
         }
-        return Promise.resolve({ status: 'ok' });
+        return Promise.resolve({ status: "ok" });
     },
 };