pgsqlio 0.1.0

package/dist/app-74TNCHFZ.js

@@ -0,0 +1,1208 @@
+// src/app.ts
+import { createCliRenderer } from "@opentui/core";
+
+// src/commands/dump.ts
+import { createWriteStream, unlinkSync } from "fs";
+import { spawn } from "child_process";
+import { finished, pipeline } from "stream/promises";
+import {
+  BoxRenderable as BoxRenderable3,
+  TextRenderable as TextRenderable3
+} from "@opentui/core";
+import { SpinnerRenderable as SpinnerRenderable2 } from "opentui-spinner";
+
+// src/utils.ts
+import { spawnSync } from "child_process";
+function requireBin(name) {
+  const result = spawnSync(name, ["--version"], { encoding: "utf8" });
+  if (result.error || result.status !== 0) {
+    console.error(`\u274C Missing required binary: ${name} (install PostgreSQL client tools)`);
+    process.exit(1);
+  }
+}
+function run(cmd, args, options) {
+  const result = spawnSync(cmd, args, {
+    encoding: "utf8",
+    input: options?.input,
+    stdio: options?.input !== void 0 ? ["pipe", "pipe", "pipe"] : ["ignore", "pipe", "pipe"]
+  });
+  const output = [result.stdout, result.stderr].filter(Boolean).join("\n").trim();
+  return { ok: result.status === 0, output };
+}
+function quoteIdent(name) {
+  return `"${name.replace(/"/g, '""')}"`;
+}
+function ensureDatabase(adminUrl, name) {
+  const lit = name.replace(/'/g, "''");
+  const { ok: checkOk, stdout } = runCapture("psql", [
+    adminUrl,
+    "-Atc",
+    `SELECT 1 FROM pg_database WHERE datname = '${lit}'`
+  ]);
+  if (checkOk && stdout.trim() === "1") {
+    return { ok: true, output: "" };
+  }
+  return run("psql", [adminUrl, "-v", "ON_ERROR_STOP=1", "-c", `CREATE DATABASE ${quoteIdent(name)}`]);
+}
+function wipePublicSchema(dbUrl) {
+  return run("psql", [
+    dbUrl,
+    "-v",
+    "ON_ERROR_STOP=1",
+    "-c",
+    "DROP SCHEMA IF EXISTS public CASCADE; CREATE SCHEMA public; GRANT ALL ON SCHEMA public TO public; GRANT ALL ON SCHEMA public TO CURRENT_USER;"
+  ]);
+}
+function extractConnectTargets(sql) {
+  const found = /* @__PURE__ */ new Set();
+  for (const m of sql.matchAll(/\\connect\s+"((?:\\.|[^"\\])*)"/gi)) {
+    found.add(m[1].replace(/""/g, '"'));
+  }
+  for (const m of sql.matchAll(/\\connect\s+([^\s"]+)/gi)) {
+    const name = m[1].replace(/;$/, "");
+    if (name.toLowerCase() !== "postgres") found.add(name);
+  }
+  found.delete("postgres");
+  return [...found];
+}
+function runCapture(cmd, args) {
+  const result = spawnSync(cmd, args, { encoding: "utf8" });
+  return {
+    ok: result.status === 0,
+    stdout: (result.stdout ?? "").trim(),
+    stderr: (result.stderr ?? "").trim()
+  };
+}
+function normalizeConnUrl(url) {
+  const [base, query] = url.split("?");
+  let next = base ?? url;
+  if (/^postgres(?:ql)?:\/\/[^/]+$/i.test(next)) {
+    next = `${next}/postgres`;
+  } else if (/^postgres(?:ql)?:\/\/[^/]+\/$/i.test(next)) {
+    next = `${next}postgres`;
+  }
+  return query !== void 0 ? `${next}?${query}` : next;
+}
+function replaceDbInUrl(url, newDb) {
+  const normalized = normalizeConnUrl(url);
+  const [base, query] = normalized.split("?");
+  const match = (base ?? normalized).match(/^(postgres(?:ql)?:\/\/[^/]+)/i);
+  const authority = match?.[1] ?? (base ?? normalized).replace(/\/[^/]*$/, "");
+  const replaced = `${authority}/${newDb}`;
+  return query !== void 0 ? `${replaced}?${query}` : replaced;
+}
+function timestamp() {
+  const d = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}_${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
+}
+function listDatabases(dbUrl) {
+  const url = normalizeConnUrl(dbUrl);
+  const { ok, stdout, stderr } = runCapture("psql", [
+    url,
+    "-Atc",
+    "SELECT datname FROM pg_database WHERE datistemplate = false ORDER BY datname;"
+  ]);
+  if (!ok) {
+    return { ok: false, databases: [], error: stderr || stdout || "Connection failed" };
+  }
+  return { ok: true, databases: stdout.split("\n").filter(Boolean) };
+}
+function dropDatabases(connUrl, names) {
+  const adminUrl = replaceDbInUrl(normalizeConnUrl(connUrl), "postgres");
+  const logs = [];
+  for (const name of names) {
+    if (name === "postgres" || name.startsWith("template")) {
+      return {
+        ok: false,
+        output: `Refusing to drop protected database: ${name}`
+      };
+    }
+    const lit = name.replace(/'/g, "''");
+    const terminate = run("psql", [
+      adminUrl,
+      "-c",
+      `SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = '${lit}' AND pid <> pg_backend_pid();`
+    ]);
+    if (terminate.output) logs.push(terminate.output);
+    const dropped = run("psql", [
+      adminUrl,
+      "-v",
+      "ON_ERROR_STOP=1",
+      "-c",
+      `DROP DATABASE IF EXISTS ${quoteIdent(name)};`
+    ]);
+    if (dropped.output) logs.push(dropped.output);
+    if (!dropped.ok) {
+      return {
+        ok: false,
+        output: [`Failed dropping "${name}"`, ...logs].filter(Boolean).join("\n")
+      };
+    }
+  }
+  return { ok: true, output: logs.join("\n").trim() };
+}
+
+// src/tui/shared.ts
+import {
+  BoxRenderable as BoxRenderable2,
+  InputRenderable,
+  InputRenderableEvents,
+  SelectRenderable,
+  SelectRenderableEvents,
+  TextRenderable as TextRenderable2
+} from "@opentui/core";
+import { SpinnerRenderable } from "opentui-spinner";
+
+// src/tui/branding.ts
+import {
+  ASCIIFontRenderable,
+  BoxRenderable,
+  TextRenderable
+} from "@opentui/core";
+var SHELL_ID = "app-shell";
+var CONTENT_ID = "app-content";
+var VERSION = "0.1.0";
+function createHeader(renderer) {
+  const header = new BoxRenderable(renderer, {
+    id: "app-header",
+    width: "100%",
+    flexDirection: "column",
+    flexShrink: 0
+  });
+  const logo = new BoxRenderable(renderer, {
+    id: "branding-logo",
+    position: "relative",
+    marginBottom: 0
+  });
+  logo.add(
+    new ASCIIFontRenderable(renderer, {
+      id: "branding-shadow",
+      text: "pgsqlio",
+      font: "block",
+      color: "#1A2228",
+      position: "absolute",
+      left: 1,
+      top: 1,
+      zIndex: 0
+    })
+  );
+  logo.add(
+    new ASCIIFontRenderable(renderer, {
+      id: "branding-wordmark",
+      text: "pgsqlio",
+      font: "block",
+      color: ["#2DD4BF", "#67E8F9", "#E0F2FE"],
+      zIndex: 1
+    })
+  );
+  header.add(logo);
+  header.add(
+    new TextRenderable(renderer, {
+      id: "branding-tagline",
+      content: `PostgreSQL dump \xB7 restore \xB7 cleanup  \xB7  v${VERSION}`,
+      fg: "#3F3F46",
+      marginTop: 1
+    })
+  );
+  return header;
+}
+function mountShell(renderer) {
+  for (const child of renderer.root.getChildren()) {
+    renderer.root.remove(child.id);
+  }
+  const shell = new BoxRenderable(renderer, {
+    id: SHELL_ID,
+    width: "100%",
+    height: "100%",
+    flexDirection: "column",
+    backgroundColor: "#0C0C0C",
+    padding: 1
+  });
+  shell.add(createHeader(renderer));
+  const content = new BoxRenderable(renderer, {
+    id: CONTENT_ID,
+    width: "100%",
+    flexGrow: 1,
+    flexShrink: 1,
+    flexDirection: "column",
+    marginTop: 1
+  });
+  shell.add(content);
+  renderer.root.add(shell);
+  return content;
+}
+function getContent(renderer) {
+  const shell = renderer.root.getChildren().find((c) => c.id === SHELL_ID);
+  if (!shell) {
+    return mountShell(renderer);
+  }
+  const content = shell.getChildren().find((c) => c.id === CONTENT_ID);
+  if (!content) {
+    return mountShell(renderer);
+  }
+  return content;
+}
+
+// src/tui/shared.ts
+var BACK = "__back__";
+function clearContent(renderer) {
+  const content = getContent(renderer);
+  for (const child of content.getChildren()) {
+    content.remove(child.id);
+  }
+  return content;
+}
+function looksLikePgUrl(value) {
+  return /^(postgres(ql)?:\/\/)/i.test(value.trim());
+}
+function promptMultiSelect(renderer, options) {
+  return new Promise((resolve) => {
+    const { items } = options;
+    if (items.length === 0) {
+      resolve([]);
+      return;
+    }
+    const content = clearContent(renderer);
+    const choices = [BACK, ...items];
+    const checked = /* @__PURE__ */ new Set();
+    let cursor = 1;
+    const panel = new BoxRenderable2(renderer, {
+      id: "pick-panel",
+      border: true,
+      borderColor: "#555555",
+      title: ` ${options.title} `,
+      flexDirection: "column",
+      padding: 1,
+      width: "100%",
+      flexGrow: 1
+    });
+    panel.add(
+      new TextRenderable2(renderer, {
+        id: "pick-hint",
+        content: "Space toggle \xB7 a all \xB7 Enter confirm \xB7 Esc back",
+        fg: "#888888",
+        marginBottom: 1
+      })
+    );
+    const list = new BoxRenderable2(renderer, {
+      id: "pick-list",
+      flexDirection: "column",
+      flexGrow: 1,
+      width: "100%"
+    });
+    const lines = choices.map((_, i) => {
+      const line = new TextRenderable2(renderer, {
+        id: `pick-line-${i}`,
+        content: "",
+        fg: "#CCCCCC"
+      });
+      list.add(line);
+      return line;
+    });
+    panel.add(list);
+    content.add(panel);
+    const redraw = () => {
+      for (let i = 0; i < choices.length; i++) {
+        const id = choices[i];
+        const isBack = id === BACK;
+        const marker = isBack ? "   " : checked.has(id) ? "[x]" : "[ ]";
+        const pointer = i === cursor ? "\u25B6" : " ";
+        const label = isBack ? "\u2190 Back" : id;
+        lines[i].content = `${pointer} ${marker} ${label}`;
+        lines[i].fg = i === cursor ? "#FFFF66" : isBack ? "#88AADD" : "#CCCCCC";
+      }
+    };
+    redraw();
+    const onKey = (key) => {
+      if (key.name === "up" || key.name === "k") {
+        cursor = Math.max(0, cursor - 1);
+        redraw();
+        return;
+      }
+      if (key.name === "down" || key.name === "j") {
+        cursor = Math.min(choices.length - 1, cursor + 1);
+        redraw();
+        return;
+      }
+      if (key.name === "space") {
+        const id = choices[cursor];
+        if (id === BACK) {
+          cleanup();
+          resolve(BACK);
+          return;
+        }
+        if (checked.has(id)) checked.delete(id);
+        else checked.add(id);
+        redraw();
+        return;
+      }
+      if (key.name === "a") {
+        if (checked.size === items.length) checked.clear();
+        else items.forEach((item) => checked.add(item));
+        redraw();
+        return;
+      }
+      if (key.name === "escape") {
+        cleanup();
+        resolve(BACK);
+        return;
+      }
+      if (key.name === "return" || key.name === "enter") {
+        const id = choices[cursor];
+        if (id === BACK) {
+          cleanup();
+          resolve(BACK);
+          return;
+        }
+        if (checked.size === 0) return;
+        cleanup();
+        resolve([...checked]);
+      }
+    };
+    const cleanup = () => {
+      renderer.keyInput.off("keypress", onKey);
+    };
+    renderer.keyInput.on("keypress", onKey);
+  });
+}
+function promptSelect(renderer, options) {
+  return new Promise((resolve, reject) => {
+    const content = clearContent(renderer);
+    const panel = new BoxRenderable2(renderer, {
+      id: "select-panel",
+      border: true,
+      borderColor: "#555555",
+      title: ` ${options.title} `,
+      flexDirection: "column",
+      padding: 1,
+      width: "100%",
+      flexGrow: 1
+    });
+    panel.add(
+      new TextRenderable2(renderer, {
+        id: "select-message",
+        content: options.message,
+        fg: "#FFFFFF",
+        marginBottom: 1
+      })
+    );
+    const menu = new SelectRenderable(renderer, {
+      id: "select-menu",
+      width: "100%",
+      height: Math.max(4, options.choices.length * 2 + 1),
+      showDescription: true,
+      showScrollIndicator: false,
+      options: options.choices.map(
+        (c) => ({
+          name: c.name,
+          description: c.description,
+          value: c.value
+        })
+      )
+    });
+    panel.add(menu);
+    panel.add(
+      new TextRenderable2(renderer, {
+        id: "select-hint",
+        content: options.hint ?? (options.allowBack ? "\u2191/\u2193 move \xB7 Enter confirm \xB7 Esc back" : "\u2191/\u2193 move \xB7 Enter confirm \xB7 Ctrl+C quit"),
+        fg: "#888888",
+        marginTop: 1
+      })
+    );
+    content.add(panel);
+    menu.focus();
+    const onSelect = (_index, option) => {
+      cleanup();
+      resolve(option.value);
+    };
+    const onKey = (key) => {
+      if (key.name === "escape") {
+        cleanup();
+        if (options.allowBack) resolve(BACK);
+        else reject(new Error("cancelled"));
+      }
+    };
+    const cleanup = () => {
+      menu.off(SelectRenderableEvents.ITEM_SELECTED, onSelect);
+      renderer.keyInput.off("keypress", onKey);
+    };
+    menu.on(SelectRenderableEvents.ITEM_SELECTED, onSelect);
+    renderer.keyInput.on("keypress", onKey);
+  });
+}
+function promptText(renderer, options) {
+  return new Promise((resolve, reject) => {
+    const content = clearContent(renderer);
+    const panel = new BoxRenderable2(renderer, {
+      id: "text-panel",
+      border: true,
+      borderColor: "#555555",
+      title: ` ${options.title} `,
+      flexDirection: "column",
+      padding: 1,
+      width: "100%",
+      flexGrow: 1,
+      gap: 1
+    });
+    panel.add(
+      new TextRenderable2(renderer, {
+        id: "text-label",
+        content: options.label,
+        fg: "#FFFFFF"
+      })
+    );
+    const error = new TextRenderable2(renderer, {
+      id: "text-error",
+      content: "",
+      fg: "#FF6666",
+      height: 1
+    });
+    const input = new InputRenderable(renderer, {
+      id: "text-input",
+      width: "100%",
+      height: 1,
+      placeholder: options.placeholder ?? "",
+      value: options.initial?.trim() ?? "",
+      maxLength: options.maxLength ?? 2e3,
+      backgroundColor: "#1A1A1A",
+      focusedBackgroundColor: "#2A2A2A",
+      textColor: "#FFFFFF",
+      cursorColor: "#88CCFF"
+    });
+    panel.add(input);
+    panel.add(error);
+    panel.add(
+      new TextRenderable2(renderer, {
+        id: "text-hint",
+        content: options.hint ?? "Enter confirm \xB7 Esc back",
+        fg: "#888888"
+      })
+    );
+    content.add(panel);
+    input.focus();
+    const submit = (value) => {
+      const trimmed = value.trim();
+      if (!trimmed) {
+        error.content = "Value is required";
+        return;
+      }
+      if (options.validate) {
+        const msg = options.validate(trimmed);
+        if (msg) {
+          error.content = msg;
+          return;
+        }
+      }
+      cleanup();
+      resolve(trimmed);
+    };
+    const onEnter = (value) => submit(value);
+    const onKey = (key) => {
+      if (key.name === "escape") {
+        cleanup();
+        reject(new Error("cancelled"));
+      }
+    };
+    const cleanup = () => {
+      input.off(InputRenderableEvents.ENTER, onEnter);
+      renderer.keyInput.off("keypress", onKey);
+    };
+    input.on(InputRenderableEvents.ENTER, onEnter);
+    renderer.keyInput.on("keypress", onKey);
+  });
+}
+function promptDbUrl(renderer, title, initial) {
+  return promptText(renderer, {
+    title,
+    label: "PostgreSQL connection URL",
+    placeholder: "postgresql://user:password@host:5432",
+    initial,
+    hint: "Enter confirm \xB7 Esc back \xB7 database name optional (you can pick next)",
+    validate: (value) => looksLikePgUrl(value) ? null : "URL must start with postgresql:// or postgres://"
+  }).then(normalizeConnUrl);
+}
+async function waitForEnter(renderer, message = "Press Enter to continue") {
+  const content = getContent(renderer);
+  const hint = new TextRenderable2(renderer, {
+    id: `wait-enter-${Date.now()}`,
+    content: message,
+    fg: "#888888",
+    marginTop: 1
+  });
+  const children = content.getChildren();
+  const last = children[children.length - 1];
+  if (last) {
+    try {
+      last.add(hint);
+    } catch {
+      content.add(hint);
+    }
+  } else {
+    content.add(hint);
+  }
+  await new Promise((resolve) => {
+    const onKey = (key) => {
+      if (key.name === "return" || key.name === "enter" || key.name === "q") {
+        renderer.keyInput.off("keypress", onKey);
+        resolve();
+      }
+    };
+    renderer.keyInput.on("keypress", onKey);
+  });
+}
+async function showStatus(renderer, options) {
+  const content = clearContent(renderer);
+  const panel = new BoxRenderable2(renderer, {
+    id: "status-panel",
+    border: true,
+    borderColor: "#555555",
+    title: ` ${options.title} `,
+    flexDirection: "column",
+    padding: 1,
+    width: "100%",
+    flexGrow: 1
+  });
+  panel.add(
+    new TextRenderable2(renderer, {
+      content: options.message,
+      fg: options.ok ? "#66DD88" : "#FF6666",
+      marginBottom: options.detail ? 1 : 0
+    })
+  );
+  if (options.detail) {
+    const lines = options.detail.split("\n").filter(Boolean).slice(-8);
+    for (const [i, line] of lines.entries()) {
+      panel.add(
+        new TextRenderable2(renderer, {
+          id: `status-detail-${i}`,
+          content: line.length > 100 ? `${line.slice(0, 97)}\u2026` : line,
+          fg: "#A1A1AA"
+        })
+      );
+    }
+  }
+  content.add(panel);
+  await waitForEnter(renderer);
+}
+async function withSpinner(renderer, title, label, work) {
+  const content = clearContent(renderer);
+  const panel = new BoxRenderable2(renderer, {
+    id: "spinner-panel",
+    border: true,
+    borderColor: "#555555",
+    title: ` ${title} `,
+    flexDirection: "row",
+    alignItems: "center",
+    padding: 1,
+    width: "100%",
+    flexGrow: 1
+  });
+  const spin = new SpinnerRenderable(renderer, {
+    id: "work-spin",
+    name: "dots",
+    color: "#88CCFF"
+  });
+  panel.add(spin);
+  panel.add(
+    new TextRenderable2(renderer, {
+      content: ` ${label}`,
+      fg: "#CCCCCC",
+      marginLeft: 1
+    })
+  );
+  content.add(panel);
+  try {
+    return await work();
+  } finally {
+    spin.stop();
+  }
+}
+
+// src/commands/dump.ts
+var PG_DUMP_ARGS = ["--clean", "--if-exists"];
+function quoteIdent2(name) {
+  return `"${name.replace(/"/g, '""')}"`;
+}
+function sqlString(name) {
+  return `'${name.replace(/'/g, "''")}'`;
+}
+async function waitExit(child) {
+  if (child.exitCode !== null) return child.exitCode;
+  return new Promise((resolve) => child.once("close", resolve));
+}
+async function dumpOne(url, outFile) {
+  const child = spawn("pg_dump", [...PG_DUMP_ARGS, url], {
+    stdio: ["ignore", "pipe", "inherit"]
+  });
+  const out = createWriteStream(outFile);
+  try {
+    await pipeline(child.stdout, out);
+  } catch {
+    return false;
+  }
+  return await waitExit(child) === 0;
+}
+async function dumpAppend(url, out, dbName) {
+  const header = `
+--
+-- Database: ${dbName}
+--
+\\connect postgres
+SELECT format('CREATE DATABASE %I', ${sqlString(dbName)})
+WHERE NOT EXISTS (SELECT FROM pg_database WHERE datname = ${sqlString(dbName)})\\gexec
+\\connect ${quoteIdent2(dbName)}
+
+`;
+  await new Promise((resolve, reject) => {
+    out.write(header, (err) => err ? reject(err) : resolve());
+  });
+  const child = spawn("pg_dump", [...PG_DUMP_ARGS, url], {
+    stdio: ["ignore", "pipe", "inherit"]
+  });
+  child.stdout.pipe(out, { end: false });
+  try {
+    await finished(child.stdout);
+  } catch {
+    return false;
+  }
+  return await waitExit(child) === 0;
+}
+async function runProgress(renderer, dbUrl, selected, outputMode) {
+  const content = clearContent(renderer);
+  const ts = timestamp();
+  let failed = 0;
+  const combinedFile = outputMode === "single" ? `backup_combined_${ts}.sql` : null;
+  const panel = new BoxRenderable3(renderer, {
+    id: "progress-panel",
+    border: true,
+    borderColor: "#555555",
+    title: outputMode === "single" ? ` dumping ${selected.length} database(s) \u2192 one file ` : ` dumping ${selected.length} database(s) `,
+    flexDirection: "column",
+    padding: 1,
+    width: "100%",
+    flexGrow: 1
+  });
+  const status = new TextRenderable3(renderer, {
+    id: "progress-status",
+    content: combinedFile ? `Writing ${combinedFile}\u2026` : "Starting\u2026",
+    fg: "#AAAAAA",
+    marginBottom: 1
+  });
+  panel.add(status);
+  const rows = /* @__PURE__ */ new Map();
+  for (const db of selected) {
+    const box = new BoxRenderable3(renderer, {
+      id: `row-${db}`,
+      flexDirection: "row",
+      alignItems: "center",
+      height: 1,
+      width: "100%"
+    });
+    const spinner = new SpinnerRenderable2(renderer, {
+      id: `spin-${db}`,
+      name: "dots",
+      color: "#88CCFF",
+      autoplay: false
+    });
+    const label = new TextRenderable3(renderer, {
+      id: `label-${db}`,
+      content: ` ${db}  pending`,
+      fg: "#888888",
+      marginLeft: 1
+    });
+    box.add(spinner);
+    box.add(label);
+    panel.add(box);
+    rows.set(db, { spinner, label });
+  }
+  content.add(panel);
+  const combined = combinedFile ? createWriteStream(combinedFile) : null;
+  if (combined) {
+    combined.write(
+      `-- pgsqlio combined dump
+-- databases: ${selected.join(", ")}
+-- created: ${ts}
+`
+    );
+  }
+  for (let i = 0; i < selected.length; i++) {
+    const db = selected[i];
+    const url = replaceDbInUrl(dbUrl, db);
+    const row = rows.get(db);
+    const outLabel = combinedFile ?? `backup_${db}_${ts}.sql`;
+    status.content = `Dumping ${i + 1}/${selected.length}: ${db}`;
+    row.label.content = ` ${db}  \u2192  ${outLabel}`;
+    row.label.fg = "#FFFFFF";
+    row.spinner.start();
+    const ok = combined ? await dumpAppend(url, combined, db) : await dumpOne(url, outLabel);
+    row.spinner.stop();
+    row.spinner.visible = false;
+    if (ok) {
+      row.label.content = `\u2713 ${db}  \u2192  ${outLabel}`;
+      row.label.fg = "#66DD88";
+    } else {
+      row.label.content = `\u2717 ${db}  failed`;
+      row.label.fg = "#FF6666";
+      failed += 1;
+      if (!combined) {
+        try {
+          unlinkSync(outLabel);
+        } catch {
+        }
+      }
+    }
+  }
+  if (combined) {
+    await new Promise((resolve, reject) => {
+      combined.end(() => resolve());
+      combined.on("error", reject);
+    });
+    if (failed > 0) {
+      try {
+        unlinkSync(combinedFile);
+      } catch {
+      }
+    }
+  }
+  status.content = failed === 0 ? combinedFile ? `Done \u2014 ${selected.length} database(s) \u2192 ${combinedFile}` : `Done \u2014 ${selected.length} database(s) dumped` : `Finished with ${failed} failure(s)`;
+  status.fg = failed === 0 ? "#66DD88" : "#FFAA66";
+  panel.add(
+    new TextRenderable3(renderer, {
+      id: "progress-done",
+      content: "Press Enter to continue",
+      fg: "#888888",
+      marginTop: 1
+    })
+  );
+  await new Promise((resolve) => {
+    const onKey = (key) => {
+      if (key.name === "return" || key.name === "enter" || key.name === "q") {
+        renderer.keyInput.off("keypress", onKey);
+        resolve();
+      }
+    };
+    renderer.keyInput.on("keypress", onKey);
+  });
+  return failed;
+}
+async function runDumpFlow(renderer) {
+  requireBin("psql");
+  requireBin("pg_dump");
+  let dbUrl;
+  try {
+    dbUrl = await promptDbUrl(renderer, "pgsqlio \xB7 dump");
+  } catch {
+    return "back";
+  }
+  const content = clearContent(renderer);
+  const loading = new BoxRenderable3(renderer, {
+    id: "loading",
+    flexDirection: "row",
+    alignItems: "center",
+    padding: 1,
+    flexGrow: 1
+  });
+  const spin = new SpinnerRenderable2(renderer, {
+    id: "loading-spin",
+    name: "dots",
+    color: "#88CCFF"
+  });
+  loading.add(spin);
+  loading.add(
+    new TextRenderable3(renderer, {
+      id: "loading-text",
+      content: " Fetching database list\u2026",
+      fg: "#CCCCCC",
+      marginLeft: 1
+    })
+  );
+  content.add(loading);
+  const listed = listDatabases(dbUrl);
+  spin.stop();
+  const databases = listed.databases;
+  if (!listed.ok || databases.length === 0) {
+    const failContent = clearContent(renderer);
+    failContent.add(
+      new TextRenderable3(renderer, {
+        content: listed.ok ? "\u274C No databases found" : `\u274C Connection failed: ${listed.error ?? "unknown error"}`,
+        fg: "#FF6666",
+        padding: 1
+      })
+    );
+    await new Promise((r) => setTimeout(r, 2e3));
+    return "fail";
+  }
+  let selected;
+  let outputMode = "separate";
+  while (!selected) {
+    const mode = await promptSelect(renderer, {
+      title: "pgsqlio \xB7 dump",
+      message: "What do you want to dump?",
+      allowBack: true,
+      choices: [
+        {
+          name: `All databases (${databases.length})`,
+          description: "Dump every non-template database",
+          value: "all"
+        },
+        {
+          name: "Select databases",
+          description: "Pick databases with checkboxes",
+          value: "select"
+        }
+      ]
+    });
+    if (mode === BACK) return "back";
+    if (mode === "all") {
+      selected = [...databases];
+    } else {
+      const picks = await promptMultiSelect(renderer, {
+        title: "select databases",
+        items: databases
+      });
+      if (picks === BACK) continue;
+      if (picks.length === 0) continue;
+      selected = picks;
+    }
+    if (selected.length > 1) {
+      const fileMode = await promptSelect(renderer, {
+        title: "pgsqlio \xB7 dump",
+        message: `How should ${selected.length} databases be written?`,
+        allowBack: true,
+        choices: [
+          {
+            name: "Separate files",
+            description: "One backup_<db>_\u2026.sql file per database",
+            value: "separate"
+          },
+          {
+            name: "Single file",
+            description: "One backup_combined_\u2026.sql with \\connect between DBs",
+            value: "single"
+          }
+        ]
+      });
+      if (fileMode === BACK) {
+        selected = void 0;
+        continue;
+      }
+      outputMode = fileMode;
+    } else {
+      outputMode = "separate";
+    }
+  }
+  const failed = await runProgress(renderer, dbUrl, selected, outputMode);
+  return failed === 0 ? "ok" : "fail";
+}
+
+// src/commands/restore.ts
+import { existsSync, readFileSync } from "fs";
+async function runRestoreFlow(renderer) {
+  requireBin("psql");
+  let dbUrl;
+  try {
+    dbUrl = await promptDbUrl(renderer, "pgsqlio \xB7 restore");
+  } catch {
+    return "back";
+  }
+  let file;
+  try {
+    file = await promptText(renderer, {
+      title: "pgsqlio \xB7 restore",
+      label: "SQL backup file path",
+      placeholder: "backup_mydb_20250924_121530.sql",
+      validate: (value) => existsSync(value) ? null : "File not found \u2014 check the path"
+    });
+  } catch {
+    return "back";
+  }
+  let sql = "";
+  try {
+    sql = readFileSync(file, "utf8");
+  } catch {
+    await showStatus(renderer, {
+      title: "pgsqlio \xB7 restore",
+      message: "\u274C Could not read backup file",
+      ok: false
+    });
+    return "fail";
+  }
+  const targets = extractConnectTargets(sql);
+  const isCombined = targets.length > 0;
+  const adminUrl = replaceDbInUrl(dbUrl, "postgres");
+  const confirm = await promptSelect(renderer, {
+    title: "pgsqlio \xB7 restore",
+    message: isCombined ? `Restore ${targets.length} database(s) from ${file}?` : `Restore into this database from ${file}?`,
+    allowBack: true,
+    choices: [
+      {
+        name: "Wipe schemas, then restore",
+        description: "DROP SCHEMA public CASCADE on target DB(s) first (fixes \u201Calready exists\u201D)",
+        value: "wipe"
+      },
+      {
+        name: "Restore as-is",
+        description: "Do not wipe \u2014 fails if objects already exist",
+        value: "asis"
+      },
+      { name: "Cancel", description: "Return to main menu", value: "no" }
+    ]
+  });
+  if (confirm === BACK || confirm === "no") return "back";
+  const wipeFirst = confirm === "wipe";
+  const result = await withSpinner(
+    renderer,
+    "pgsqlio \xB7 restore",
+    wipeFirst ? "Wiping + restoring\u2026" : "Restoring\u2026",
+    () => {
+      const logs = [];
+      if (isCombined) {
+        for (const db of targets) {
+          const created = ensureDatabase(adminUrl, db);
+          if (!created.ok) {
+            return {
+              ok: false,
+              output: [`Failed creating database "${db}"`, created.output].filter(Boolean).join("\n")
+            };
+          }
+          if (created.output) logs.push(created.output);
+          if (wipeFirst) {
+            const wiped = wipePublicSchema(replaceDbInUrl(adminUrl, db));
+            if (!wiped.ok) {
+              return {
+                ok: false,
+                output: [`Failed wiping database "${db}"`, wiped.output].filter(Boolean).join("\n")
+              };
+            }
+            if (wiped.output) logs.push(wiped.output);
+          }
+        }
+      } else if (wipeFirst) {
+        const wiped = wipePublicSchema(dbUrl);
+        if (!wiped.ok) {
+          return {
+            ok: false,
+            output: ["Failed wiping target database", wiped.output].filter(Boolean).join("\n")
+          };
+        }
+        if (wiped.output) logs.push(wiped.output);
+      }
+      const restoreUrl = isCombined ? adminUrl : dbUrl;
+      const restored = run("psql", [
+        restoreUrl,
+        "-v",
+        "ON_ERROR_STOP=1",
+        "-f",
+        file
+      ]);
+      if (restored.output) logs.push(restored.output);
+      return {
+        ok: restored.ok,
+        output: logs.join("\n").trim()
+      };
+    }
+  );
+  await showStatus(renderer, {
+    title: "pgsqlio \xB7 restore",
+    message: result.ok ? "\u2705 Restore successful" : "\u274C Restore failed",
+    ok: result.ok,
+    detail: result.ok ? void 0 : result.output || void 0
+  });
+  return result.ok ? "ok" : "fail";
+}
+
+// src/commands/cleanup.ts
+async function runCleanupFlow(renderer) {
+  requireBin("psql");
+  let dbUrl;
+  try {
+    dbUrl = await promptDbUrl(renderer, "pgsqlio \xB7 cleanup");
+  } catch {
+    return "back";
+  }
+  const confirm = await promptSelect(renderer, {
+    title: "pgsqlio \xB7 cleanup",
+    message: "Drop and recreate the public schema? This is destructive.",
+    allowBack: true,
+    choices: [
+      {
+        name: "Yes, clean database",
+        description: "DROP SCHEMA public CASCADE; CREATE SCHEMA public;",
+        value: "yes"
+      },
+      { name: "Cancel", description: "Return to main menu", value: "no" }
+    ]
+  });
+  if (confirm === BACK || confirm === "no") return "back";
+  const result = await withSpinner(
+    renderer,
+    "pgsqlio \xB7 cleanup",
+    "Cleaning\u2026",
+    () => run("psql", [
+      dbUrl,
+      "-v",
+      "ON_ERROR_STOP=1",
+      "-c",
+      "DROP SCHEMA public CASCADE; CREATE SCHEMA public;"
+    ])
+  );
+  await showStatus(renderer, {
+    title: "pgsqlio \xB7 cleanup",
+    message: result.ok ? "\u2705 Cleanup successful (database is empty)" : "\u274C Cleanup failed",
+    ok: result.ok,
+    detail: result.ok ? void 0 : result.output || void 0
+  });
+  return result.ok ? "ok" : "fail";
+}
+
+// src/commands/drop-databases.ts
+import {
+  BoxRenderable as BoxRenderable4,
+  TextRenderable as TextRenderable4
+} from "@opentui/core";
+import { SpinnerRenderable as SpinnerRenderable3 } from "opentui-spinner";
+async function runDropDatabasesFlow(renderer) {
+  requireBin("psql");
+  let connUrl;
+  try {
+    connUrl = await promptDbUrl(renderer, "pgsqlio \xB7 drop databases");
+  } catch {
+    return "back";
+  }
+  connUrl = normalizeConnUrl(connUrl);
+  const loadingWrap = clearContent(renderer);
+  const spin = new SpinnerRenderable3(renderer, {
+    id: "db-spin",
+    name: "dots",
+    color: "#88CCFF"
+  });
+  const loading = new BoxRenderable4(renderer, {
+    id: "db-loading",
+    flexDirection: "row",
+    alignItems: "center",
+    padding: 1,
+    flexGrow: 1
+  });
+  loading.add(spin);
+  loading.add(
+    new TextRenderable4(renderer, {
+      content: " Fetching databases\u2026",
+      fg: "#CCCCCC",
+      marginLeft: 1
+    })
+  );
+  loadingWrap.add(loading);
+  const listed = listDatabases(connUrl);
+  spin.stop();
+  if (!listed.ok) {
+    await showStatus(renderer, {
+      title: "pgsqlio \xB7 drop databases",
+      message: "\u274C Could not list databases",
+      ok: false,
+      detail: listed.error
+    });
+    return "fail";
+  }
+  const droppable = listed.databases.filter(
+    (name) => name !== "postgres" && !name.startsWith("template")
+  );
+  if (droppable.length === 0) {
+    await showStatus(renderer, {
+      title: "pgsqlio \xB7 drop databases",
+      message: "No droppable databases found",
+      ok: false,
+      detail: "postgres / template* are protected"
+    });
+    return "fail";
+  }
+  const selected = await promptMultiSelect(renderer, {
+    title: "select databases to drop",
+    items: droppable
+  });
+  if (selected === BACK) return "back";
+  if (selected.length === 0) return "back";
+  const confirm = await promptSelect(renderer, {
+    title: "pgsqlio \xB7 drop databases",
+    message: `Permanently drop ${selected.length} database(s)? This cannot be undone.`,
+    allowBack: true,
+    choices: [
+      {
+        name: "Yes, drop selected databases",
+        description: selected.slice(0, 5).join(", ") + (selected.length > 5 ? "\u2026" : ""),
+        value: "yes"
+      },
+      { name: "Cancel", description: "Return to main menu", value: "no" }
+    ]
+  });
+  if (confirm === BACK || confirm === "no") return "back";
+  const result = await withSpinner(
+    renderer,
+    "pgsqlio \xB7 drop databases",
+    `Dropping ${selected.length} database(s)\u2026`,
+    () => dropDatabases(connUrl, selected)
+  );
+  await showStatus(renderer, {
+    title: "pgsqlio \xB7 drop databases",
+    message: result.ok ? `\u2705 Dropped ${selected.length} database(s)` : "\u274C Drop databases failed",
+    ok: result.ok,
+    detail: result.ok ? selected.join(", ") : result.output || void 0
+  });
+  return result.ok ? "ok" : "fail";
+}
+
+// src/app.ts
+async function runApp() {
+  const renderer = await createCliRenderer({
+    exitOnCtrlC: true,
+    backgroundColor: "#0C0C0C"
+  });
+  renderer.start();
+  mountShell(renderer);
+  try {
+    while (true) {
+      const action = await promptSelect(renderer, {
+        title: "pgsqlio",
+        message: "What do you want to do?",
+        choices: [
+          {
+            name: "Dump",
+            description: "Backup one or more databases",
+            value: "dump"
+          },
+          {
+            name: "Restore",
+            description: "Import a .sql backup into a database",
+            value: "restore"
+          },
+          {
+            name: "Cleanup",
+            description: "Drop and recreate the public schema",
+            value: "cleanup"
+          },
+          {
+            name: "Drop databases",
+            description: "Select and permanently drop databases",
+            value: "drop-databases"
+          },
+          {
+            name: "Quit",
+            description: "Exit pgsqlio",
+            value: "quit"
+          }
+        ]
+      });
+      if (action === BACK || action === "quit") break;
+      if (action === "dump") await runDumpFlow(renderer);
+      else if (action === "restore") await runRestoreFlow(renderer);
+      else if (action === "cleanup") await runCleanupFlow(renderer);
+      else if (action === "drop-databases") await runDropDatabasesFlow(renderer);
+    }
+  } finally {
+    renderer.destroy();
+  }
+}
+export {
+  runApp
+};
+//# sourceMappingURL=app-74TNCHFZ.js.map