neonctl 2.28.0 → 2.29.1

package/dist/psql/io/lineEditor/vt100.js

@@ -23,7 +23,7 @@
 const controlEvent = (b) => {
     // ^A == 0x01 maps back to 'a'. Lowercase keeps things consistent.
     const letter = String.fromCharCode(b + 0x60);
-    return { key: 'char', char: letter, ctrl: true };
+    return { key: "char", char: letter, ctrl: true };
 };
 /** Streaming decoder. Owns a small pending-byte buffer. */
 export class Vt100Decoder {
@@ -102,7 +102,7 @@ export class Vt100Decoder {
                 this.utf8Bytes.length = 0;
                 this.utf8Expect = 0;
                 this.pending.shift();
-                return { key: 'unknown', raw: new Uint8Array([b]) };
+                return { key: "unknown", raw: new Uint8Array([b]) };
             }
             this.utf8Bytes.push(b);
             this.pending.shift();
@@ -111,27 +111,27 @@ export class Vt100Decoder {
                 const bytes = Uint8Array.from(this.utf8Bytes);
                 this.utf8Bytes.length = 0;
                 const decoded = utf8Decode(bytes);
-                return { key: 'char', char: decoded };
+                return { key: "char", char: decoded };
             }
             return null;
         }
         // ASCII printable.
         if (b >= 0x20 && b <= 0x7e) {
             this.pending.shift();
-            return { key: 'char', char: String.fromCharCode(b) };
+            return { key: "char", char: String.fromCharCode(b) };
         }
         // Common controls.
         if (b === 0x09) {
             this.pending.shift();
-            return { key: 'tab' };
+            return { key: "tab" };
         }
         if (b === 0x0a || b === 0x0d) {
             this.pending.shift();
-            return { key: 'enter' };
+            return { key: "enter" };
         }
         if (b === 0x7f || b === 0x08) {
             this.pending.shift();
-            return { key: 'backspace' };
+            return { key: "backspace" };
         }
         if (b === 0x1b) {
             // Escape: maybe alone, maybe the lead of a CSI/SS3/Meta sequence.
@@ -162,7 +162,7 @@ export class Vt100Decoder {
         }
         // Stray high byte. Emit unknown.
         this.pending.shift();
-        return { key: 'unknown', raw: new Uint8Array([b]) };
+        return { key: "unknown", raw: new Uint8Array([b]) };
     }
     /**
      * Called when the head byte is 0x1b. Tries to consume an escape
@@ -181,7 +181,7 @@ export class Vt100Decoder {
         if (this.pending.length === 1) {
             if (this.escTimeoutMs === 0) {
                 this.pending.shift();
-                return { key: 'escape' };
+                return { key: "escape" };
             }
             // Already waiting? Don't re-arm the timer.
             if (this.escPending)
@@ -193,7 +193,7 @@ export class Vt100Decoder {
                 if (this.escPending && this.pending[0] === 0x1b) {
                     this.pending.shift();
                     this.escPending = false;
-                    this.onTimeoutEvent?.({ key: 'escape' });
+                    this.onTimeoutEvent?.({ key: "escape" });
                 }
                 else {
                     this.escPending = false;
@@ -224,16 +224,16 @@ export class Vt100Decoder {
         }
         if (b1 === 0x7f) {
             this.pending.splice(0, 2);
-            return { key: 'backspace', meta: true };
+            return { key: "backspace", meta: true };
         }
         if (b1 >= 0x20 && b1 <= 0x7e) {
             this.pending.splice(0, 2);
-            return { key: 'char', char: String.fromCharCode(b1), meta: true };
+            return { key: "char", char: String.fromCharCode(b1), meta: true };
         }
         // Unknown Esc-X sequence; consume both and emit unknown.
         const raw = Uint8Array.from(this.pending.slice(0, 2));
         this.pending.splice(0, 2);
-        return { key: 'unknown', raw };
+        return { key: "unknown", raw };
     }
     consumeCsi() {
         // Format: ESC [ (parameter bytes 0x30..0x3f)* (intermediate bytes 0x20..0x2f)* (final byte 0x40..0x7e)
@@ -259,52 +259,52 @@ export class Vt100Decoder {
             const paramStr = String.fromCharCode(...params);
             consume();
             switch (paramStr) {
-                case '1':
-                case '7':
-                    return { key: 'home' };
-                case '2':
-                    return { key: 'unknown' }; // Insert; we don't handle it.
-                case '3':
-                    return { key: 'delete' };
-                case '4':
-                case '8':
-                    return { key: 'end' };
-                case '5':
-                    return { key: 'pageup' };
-                case '6':
-                    return { key: 'pagedown' };
-                case '200':
-                    return { key: 'paste-start' };
-                case '201':
-                    return { key: 'paste-end' };
+                case "1":
+                case "7":
+                    return { key: "home" };
+                case "2":
+                    return { key: "unknown" }; // Insert; we don't handle it.
+                case "3":
+                    return { key: "delete" };
+                case "4":
+                case "8":
+                    return { key: "end" };
+                case "5":
+                    return { key: "pageup" };
+                case "6":
+                    return { key: "pagedown" };
+                case "200":
+                    return { key: "paste-start" };
+                case "201":
+                    return { key: "paste-end" };
                 default:
-                    return { key: 'unknown' };
+                    return { key: "unknown" };
             }
         }
         // Letter finals (A/B/C/D/H/F).
         // Param string may carry modifiers: e.g. "1;3" → Alt-arrow.
         const paramStr = String.fromCharCode(...params);
         consume();
-        const meta = paramStr.endsWith(';3') || paramStr.endsWith(';7');
+        const meta = paramStr.endsWith(";3") || paramStr.endsWith(";7");
         switch (final) {
             case 0x41 /* 'A' */:
-                return meta ? { key: 'up', meta: true } : { key: 'up' };
+                return meta ? { key: "up", meta: true } : { key: "up" };
             case 0x42 /* 'B' */:
-                return meta ? { key: 'down', meta: true } : { key: 'down' };
+                return meta ? { key: "down", meta: true } : { key: "down" };
             case 0x43 /* 'C' */:
-                return meta ? { key: 'right', meta: true } : { key: 'right' };
+                return meta ? { key: "right", meta: true } : { key: "right" };
             case 0x44 /* 'D' */:
-                return meta ? { key: 'left', meta: true } : { key: 'left' };
+                return meta ? { key: "left", meta: true } : { key: "left" };
             case 0x48 /* 'H' */:
-                return { key: 'home' };
+                return { key: "home" };
             case 0x46 /* 'F' */:
-                return { key: 'end' };
+                return { key: "end" };
             case 0x5a /* 'Z' */:
                 // Shift-Tab; treat as plain Tab for now (no reverse cycling yet).
-                return { key: 'tab', meta: true };
+                return { key: "tab", meta: true };
             default:
                 return {
-                    key: 'unknown',
+                    key: "unknown",
                     raw: Uint8Array.from(this.pending.slice(0, seqLen)),
                 };
         }
@@ -313,51 +313,51 @@ export class Vt100Decoder {
 /** Decode a small UTF-8 byte sequence (1..4 bytes) into a string. */
 const utf8Decode = (bytes) => {
     // Node provides TextDecoder; available on all supported runtimes (Node 18+).
-    return new TextDecoder('utf-8', { fatal: false }).decode(bytes);
+    return new TextDecoder("utf-8", { fatal: false }).decode(bytes);
 };
 /** Translate an SS3 final byte (after `ESC O`) into a key event. */
 const ss3ToEvent = (b) => {
     switch (b) {
         case 0x41:
-            return { key: 'up' };
+            return { key: "up" };
         case 0x42:
-            return { key: 'down' };
+            return { key: "down" };
         case 0x43:
-            return { key: 'right' };
+            return { key: "right" };
         case 0x44:
-            return { key: 'left' };
+            return { key: "left" };
         case 0x48:
-            return { key: 'home' };
+            return { key: "home" };
         case 0x46:
-            return { key: 'end' };
+            return { key: "end" };
         default:
-            return { key: 'unknown', raw: new Uint8Array([0x1b, 0x4f, b]) };
+            return { key: "unknown", raw: new Uint8Array([0x1b, 0x4f, b]) };
     }
 };
 // ---------------------------------------------------------------------------
 // CSI output helpers
 // ---------------------------------------------------------------------------
 /** Move cursor up N rows. */
-export const csiUp = (n) => (n > 0 ? `\x1b[${n}A` : '');
+export const csiUp = (n) => (n > 0 ? `\x1b[${n}A` : "");
 /** Move cursor down N rows. */
-export const csiDown = (n) => (n > 0 ? `\x1b[${n}B` : '');
+export const csiDown = (n) => (n > 0 ? `\x1b[${n}B` : "");
 /** Move cursor right N columns. */
-export const csiRight = (n) => (n > 0 ? `\x1b[${n}C` : '');
+export const csiRight = (n) => (n > 0 ? `\x1b[${n}C` : "");
 /** Move cursor left N columns. */
-export const csiLeft = (n) => (n > 0 ? `\x1b[${n}D` : '');
+export const csiLeft = (n) => (n > 0 ? `\x1b[${n}D` : "");
 /** Move cursor to column N (1-based). */
 export const csiToColumn = (col) => `\x1b[${col}G`;
 /** Erase from cursor to end-of-line. */
-export const csiEraseToEol = () => '\x1b[K';
+export const csiEraseToEol = () => "\x1b[K";
 /** Erase entire screen and move cursor to home. */
-export const csiClearScreen = () => '\x1b[2J\x1b[H';
+export const csiClearScreen = () => "\x1b[2J\x1b[H";
 /** Carriage return: move to column 1 without writing a newline. */
-export const CR = '\r';
+export const CR = "\r";
 /** Newline (LF). */
-export const LF = '\n';
+export const LF = "\n";
 /** Enable bracketed paste mode (DEC private mode 2004). */
-export const enableBracketedPaste = () => '\x1b[?2004h';
+export const enableBracketedPaste = () => "\x1b[?2004h";
 /** Disable bracketed paste mode. */
-export const disableBracketedPaste = () => '\x1b[?2004l';
+export const disableBracketedPaste = () => "\x1b[?2004l";
 /** Audible bell. */
-export const BEL = '\x07';
+export const BEL = "\x07";

package/dist/psql/io/pgpass.js

@@ -25,10 +25,10 @@
  *   skip the file and emit a single warning to stderr. Windows skips the check
  *   entirely (libpq does the same — `geteuid` / `S_IRWXG` aren't portable).
  */
-import { promises as fs } from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-const isWindows = process.platform === 'win32';
+import { promises as fs } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+const isWindows = process.platform === "win32";
 /**
  * Return the default `.pgpass` path:
  *
@@ -46,13 +46,13 @@ export const defaultPgPassPath = (env = process.env) => {
     if (isWindows) {
         const appdata = env.APPDATA;
         if (appdata !== undefined && appdata.length > 0) {
-            return path.join(appdata, 'postgresql', 'pgpass.conf');
+            return path.join(appdata, "postgresql", "pgpass.conf");
         }
         // Fall through to homedir() if APPDATA isn't set — degrade gracefully on
         // a minimally configured Windows session.
     }
     const home = env.HOME ?? os.homedir();
-    return path.join(home, '.pgpass');
+    return path.join(home, ".pgpass");
 };
 /**
  * Split a `.pgpass` line into its five fields, respecting `\:` and `\\`
@@ -67,9 +67,9 @@ export const defaultPgPassPath = (env = process.env) => {
  */
 /** Un-escape `\X` → `X` (a trailing lone backslash is kept). */
 const decodeBackslashes = (s) => {
-    let out = '';
+    let out = "";
     for (let i = 0; i < s.length; i++) {
-        if (s[i] === '\\' && i + 1 < s.length) {
+        if (s[i] === "\\" && i + 1 < s.length) {
             out += s[i + 1];
             i += 1;
             continue;
@@ -87,17 +87,17 @@ const splitLine = (line) => {
     // char-by-char comparison. The password is the returned secret, so it is
     // fully decoded here.
     const fields = [];
-    let current = '';
+    let current = "";
     for (let i = 0; i < line.length; i++) {
         const ch = line[i];
-        if (ch === '\\' && i + 1 < line.length) {
-            current += '\\' + line[i + 1];
+        if (ch === "\\" && i + 1 < line.length) {
+            current += "\\" + line[i + 1];
             i += 1;
             continue;
         }
-        if (ch === ':') {
+        if (ch === ":") {
             fields.push(current);
-            current = '';
+            current = "";
             continue;
         }
         current += ch;
@@ -136,7 +136,7 @@ export const loadPgPass = async (filePath, opts) => {
     }
     catch (err) {
         const code = err.code;
-        if (code === 'ENOENT' || code === 'ENOTDIR')
+        if (code === "ENOENT" || code === "ENOTDIR")
             return [];
         return [];
     }
@@ -148,17 +148,17 @@ export const loadPgPass = async (filePath, opts) => {
     }
     let raw;
     try {
-        raw = await fs.readFile(resolved, 'utf8');
+        raw = await fs.readFile(resolved, "utf8");
     }
     catch {
         return [];
     }
     const entries = [];
     for (const line of raw.split(/\r?\n/)) {
-        const trimmed = line.replace(/^\s+/, '');
+        const trimmed = line.replace(/^\s+/, "");
         if (trimmed.length === 0)
             continue;
-        if (trimmed.startsWith('#'))
+        if (trimmed.startsWith("#"))
             continue;
         const entry = splitLine(trimmed);
         if (entry !== null)
@@ -171,7 +171,7 @@ export const loadPgPass = async (filePath, opts) => {
  */
 const fieldMatches = (pattern, value) => 
 // A bare `*` is the wildcard; `\*` decodes to a LITERAL `*` (review #21).
-pattern === '*' || decodeBackslashes(pattern) === value;
+pattern === "*" || decodeBackslashes(pattern) === value;
 /**
  * Look up a password entry for the given `target`. Returns the first matching
  * entry's password, or `undefined` if nothing matches.

package/dist/psql/io/pgservice.js

@@ -36,10 +36,10 @@
  * silently — libpq would also accept them and feed them to `PQconninfoParse`,
  * which is responsible for the recognised-key gate.
  */
-import { promises as fs } from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-const isWindows = process.platform === 'win32';
+import { promises as fs } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+const isWindows = process.platform === "win32";
 /**
  * Return the ordered list of candidate `pg_service.conf` paths to try. The
  * caller stops at the first one that exists. Pure function — `env` defaults
@@ -56,25 +56,25 @@ export const defaultPgServiceFilePath = (env = process.env) => {
     if (isWindows) {
         const appdata = env.APPDATA;
         if (appdata !== undefined && appdata.length > 0) {
-            out.push(path.join(appdata, 'postgresql', '.pg_service.conf'));
+            out.push(path.join(appdata, "postgresql", ".pg_service.conf"));
         }
     }
     else {
         const home = env.HOME ?? os.homedir();
         if (home.length > 0) {
-            out.push(path.join(home, '.pg_service.conf'));
+            out.push(path.join(home, ".pg_service.conf"));
         }
     }
     // System-level: `$PGSYSCONFDIR/pg_service.conf`.
     const sysDir = env.PGSYSCONFDIR;
     if (sysDir !== undefined && sysDir.length > 0) {
-        out.push(path.join(sysDir, 'pg_service.conf'));
+        out.push(path.join(sysDir, "pg_service.conf"));
     }
     // Platform-default system path. libpq's autoconf picks SYSCONFDIR at build
     // time; for a portable TS implementation we use `/etc/pg_service.conf` on
     // POSIX. Windows has no canonical equivalent.
     if (!isWindows) {
-        out.push('/etc/pg_service.conf');
+        out.push("/etc/pg_service.conf");
     }
     return out;
 };
@@ -101,10 +101,10 @@ export const parsePgServiceContent = (content) => {
         const line = rawLine.trim();
         if (line.length === 0)
             continue;
-        if (line.startsWith('#'))
+        if (line.startsWith("#"))
             continue;
-        if (line.startsWith('[')) {
-            const close = line.indexOf(']');
+        if (line.startsWith("[")) {
+            const close = line.indexOf("]");
             if (close < 0) {
                 // Malformed header — libpq aborts the file; we mirror by ending the
                 // current section so the bogus line doesn't bleed into it.
@@ -126,7 +126,7 @@ export const parsePgServiceContent = (content) => {
             // resolve services that appear after the noise.
             continue;
         }
-        const eq = line.indexOf('=');
+        const eq = line.indexOf("=");
         if (eq < 0)
             continue;
         const key = line.slice(0, eq).trim();
@@ -139,11 +139,11 @@ export const parsePgServiceContent = (content) => {
 };
 const readIfExists = async (filePath) => {
     try {
-        return await fs.readFile(filePath, 'utf8');
+        return await fs.readFile(filePath, "utf8");
     }
     catch (err) {
         const code = err.code;
-        if (code === 'ENOENT' || code === 'ENOTDIR')
+        if (code === "ENOENT" || code === "ENOTDIR")
             return null;
         // Permission / I/O errors silently degrade — libpq treats an unreadable
         // service file the same as a missing one (the connection falls back to