transom 0.0.0-stage → 0.1.0

package/dist/cli.js

@@ -0,0 +1,631 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import http from "http";
+import fs3 from "fs";
+import path2 from "path";
+import crypto from "crypto";
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+
+// src/postgres.ts
+import pg from "pg";
+import os from "os";
+import fs from "fs";
+for (const oid of [1082, 1083, 1114, 1184, 1266, 20, 1700]) pg.types.setTypeParser(oid, (v) => v);
+var pool = null;
+var current = {};
+var serverVersion = "";
+var q = (id) => pg.escapeIdentifier(id);
+function config(c) {
+  const base = c.url ? { connectionString: c.url } : {
+    host: c.host || void 0,
+    port: c.port || 5432,
+    user: c.user || os.userInfo().username,
+    password: c.password || void 0,
+    database: c.database || "postgres",
+    ssl: c.ssl ? { rejectUnauthorized: false } : void 0
+  };
+  return { ...base, max: 4, connectionTimeoutMillis: 5e3, statement_timeout: 15e3, application_name: "transom" };
+}
+async function connect(c) {
+  const next = new pg.Pool(config(c));
+  try {
+    const { rows: rows2 } = await next.query(
+      `select current_database() as database, current_user as user, current_setting('server_version') as version,
+              inet_server_addr()::text as addr, current_setting('port') as port`
+    );
+    await pool?.end().catch(() => {
+    });
+    pool = next;
+    current = c;
+    serverVersion = String(rows2[0].version ?? "").split(" ")[0];
+    return { ...rows2[0], host: c.url ? new URL(c.url).hostname || "localhost" : c.host || "localhost", databases: await databases() };
+  } catch (e) {
+    await next.end().catch(() => {
+    });
+    throw e;
+  }
+}
+async function switchDatabase(database) {
+  if (current.url) {
+    const u = new URL(current.url);
+    u.pathname = "/" + encodeURIComponent(database);
+    return connect({ ...current, url: u.toString() });
+  }
+  return connect({ ...current, database });
+}
+function connected() {
+  return pool !== null;
+}
+function db() {
+  if (!pool) throw Object.assign(new Error("Not connected"), { status: 409 });
+  return pool;
+}
+async function databases() {
+  const { rows: rows2 } = await db().query(
+    `select datname as name, pg_database_size(datname)::bigint::text as size
+       from pg_database where not datistemplate and datallowconn order by datname`
+  );
+  return rows2;
+}
+async function detectLocal() {
+  const candidates = [];
+  for (const dir of ["/tmp", "/var/run/postgresql"]) {
+    if (fs.existsSync(`${dir}/.s.PGSQL.5432`)) candidates.push({ host: dir, port: 5432 });
+  }
+  candidates.push({ host: "localhost", port: 5432 });
+  for (const c of candidates) {
+    const probe = new pg.Client({ ...config({ ...c, database: "postgres" }), connectionTimeoutMillis: 1500 });
+    try {
+      await probe.connect();
+      const { rows: rows2 } = await probe.query(
+        `select datname as name, pg_database_size(datname)::bigint::text as size
+           from pg_database where not datistemplate and datallowconn order by datname`
+      );
+      const v = await probe.query(`select current_setting('server_version') as version`);
+      return {
+        found: true,
+        host: c.host,
+        port: c.port,
+        user: os.userInfo().username,
+        version: String(v.rows[0].version).split(" ")[0],
+        databases: rows2
+      };
+    } catch {
+    } finally {
+      await probe.end().catch(() => {
+      });
+    }
+  }
+  return { found: false };
+}
+async function tables() {
+  const { rows: rows2 } = await db().query(
+    `select n.nspname as schema, c.relname as name,
+            case c.relkind when 'r' then 'table' when 'p' then 'table' when 'v' then 'view' when 'm' then 'matview' when 'f' then 'foreign' end as kind,
+            -- Small tables (< 8 MB) get an exact count; big ones keep the planner estimate and are marked as such.
+            case when c.relkind in ('r','p','m') and pg_total_relation_size(c.oid) < 8388608
+                 then (xpath('/row/n/text()', query_to_xml(format('select count(*) as n from %I.%I', n.nspname, c.relname), false, true, '')))[1]::text
+                 when c.reltuples >= 0 then c.reltuples::bigint::text else s.n_live_tup::text end as estimate,
+            c.relkind in ('r','p','m') and pg_total_relation_size(c.oid) < 8388608 as exact,
+            pg_total_relation_size(c.oid)::bigint::text as size
+       from pg_class c join pg_namespace n on n.oid = c.relnamespace
+       left join pg_stat_all_tables s on s.relid = c.oid
+      where c.relkind in ('r','p','v','m','f')
+        and n.nspname not in ('pg_catalog','information_schema') and n.nspname not like 'pg_toast%' and n.nspname not like 'pg_temp%'
+        and not c.relispartition
+      order by n.nspname, c.relname`
+  );
+  return rows2;
+}
+async function oidOf(schema, table) {
+  const { rows: rows2 } = await db().query(`select ($1::text || '.' || $2::text)::regclass::oid as oid`, [q(schema), q(table)]);
+  return rows2[0].oid;
+}
+async function describe(schema, table) {
+  const oid = await oidOf(schema, table);
+  const [columns, outgoing, incoming, indexes, meta] = await Promise.all([
+    db().query(
+      `select a.attname as name, format_type(a.atttypid, a.atttypmod) as type, t.typcategory as category,
+              not a.attnotnull as nullable, pg_get_expr(d.adbin, d.adrelid) as default,
+              coalesce(a.attnum = any(pk.conkey), false) as pk, col_description(a.attrelid, a.attnum) as comment
+         from pg_attribute a
+         join pg_type t on t.oid = a.atttypid
+         left join pg_attrdef d on d.adrelid = a.attrelid and d.adnum = a.attnum
+         left join pg_constraint pk on pk.conrelid = a.attrelid and pk.contype = 'p'
+        where a.attrelid = $1 and a.attnum > 0 and not a.attisdropped
+        order by a.attnum`,
+      [oid]
+    ),
+    // Single-column foreign keys are the ones we can make clickable; composite ones are still listed.
+    db().query(
+      `select con.conname as name,
+              array(select attname::text from pg_attribute where attrelid = con.conrelid and attnum = any(con.conkey) order by array_position(con.conkey, attnum)) as columns,
+              fn.nspname as ref_schema, f.relname as ref_table,
+              array(select attname::text from pg_attribute where attrelid = con.confrelid and attnum = any(con.confkey) order by array_position(con.confkey, attnum)) as ref_columns
+         from pg_constraint con
+         join pg_class f on f.oid = con.confrelid join pg_namespace fn on fn.oid = f.relnamespace
+        where con.contype = 'f' and con.conrelid = $1 order by con.conname`,
+      [oid]
+    ),
+    db().query(
+      `select con.conname as name, sn.nspname as schema, s.relname as table,
+              array(select attname::text from pg_attribute where attrelid = con.conrelid and attnum = any(con.conkey) order by array_position(con.conkey, attnum)) as columns,
+              array(select attname::text from pg_attribute where attrelid = con.confrelid and attnum = any(con.confkey) order by array_position(con.confkey, attnum)) as ref_columns
+         from pg_constraint con
+         join pg_class s on s.oid = con.conrelid join pg_namespace sn on sn.oid = s.relnamespace
+        where con.contype = 'f' and con.confrelid = $1 order by s.relname, con.conname`,
+      [oid]
+    ),
+    db().query(
+      `select i.relname as name, pg_get_indexdef(ix.indexrelid) as definition, ix.indisunique as unique, ix.indisprimary as primary,
+              pg_relation_size(ix.indexrelid)::bigint::text as size
+         from pg_index ix join pg_class i on i.oid = ix.indexrelid
+        where ix.indrelid = $1 order by ix.indisprimary desc, i.relname`,
+      [oid]
+    ),
+    db().query(
+      `select c.reltuples::bigint::text as estimate, pg_total_relation_size(c.oid)::bigint::text as size,
+              obj_description(c.oid, 'pg_class') as comment,
+              case c.relkind when 'v' then 'view' when 'm' then 'matview' when 'f' then 'foreign' else 'table' end as kind
+         from pg_class c where c.oid = $1`,
+      [oid]
+    )
+  ]);
+  const m = meta.rows[0];
+  let count = String(Math.max(Number(m.estimate), 0));
+  let exact = false;
+  const estimate = Number(m.estimate);
+  if (estimate >= 0 && estimate < 2e5 || estimate < 0 && Number(m.size) < 64 * 1024 * 1024) {
+    const r = await db().query(`select count(*)::text as n from ${q(schema)}.${q(table)}`);
+    count = r.rows[0].n;
+    exact = true;
+  }
+  return {
+    schema,
+    name: table,
+    kind: m.kind,
+    comment: m.comment,
+    size: m.size,
+    count,
+    exact,
+    columns: columns.rows,
+    outgoing: outgoing.rows,
+    incoming: incoming.rows,
+    indexes: indexes.rows
+  };
+}
+var OPS = {
+  eq: "=",
+  neq: "<>",
+  gt: ">",
+  gte: ">=",
+  lt: "<",
+  lte: "<="
+};
+async function rows(opts) {
+  const { schema, table } = opts;
+  const limit = Math.min(Math.max(Number(opts.limit) || 100, 1), 1e3);
+  const offset = Math.max(Number(opts.offset) || 0, 0);
+  const cols = new Set(
+    (await db().query(
+      `select attname from pg_attribute where attrelid = $1 and attnum > 0 and not attisdropped`,
+      [await oidOf(schema, table)]
+    )).rows.map((r) => r.attname)
+  );
+  const params = [];
+  const where = [];
+  for (const f of opts.filters ?? []) {
+    if (!cols.has(f.column)) throw Object.assign(new Error(`Unknown column ${f.column}`), { status: 400 });
+    const c = q(f.column);
+    if (f.op === "null") where.push(`${c} is null`);
+    else if (f.op === "notnull") where.push(`${c} is not null`);
+    else if (f.op === "contains") {
+      params.push(`%${f.value ?? ""}%`);
+      where.push(`${c}::text ilike $${params.length}`);
+    } else if (OPS[f.op]) {
+      params.push(f.value ?? "");
+      where.push(`${c} ${OPS[f.op]} $${params.length}`);
+    } else throw Object.assign(new Error(`Unknown operator ${f.op}`), { status: 400 });
+  }
+  let order = "";
+  if (opts.sort && cols.has(opts.sort.column)) order = ` order by ${q(opts.sort.column)} ${opts.sort.dir === "desc" ? "desc" : "asc"} nulls last`;
+  const whereSql = where.length ? ` where ${where.join(" and ")}` : "";
+  const from = `${q(schema)}.${q(table)}`;
+  const started = performance.now();
+  const res = await db().query({
+    text: `select * from ${from}${whereSql}${order} limit ${limit + 1} offset ${offset}`,
+    values: params
+  });
+  const filteredCount = where.length ? (await db().query(`select count(*)::text as n from ${from}${whereSql}`, params)).rows[0].n : null;
+  return {
+    fields: res.fields.map((f) => f.name),
+    rows: res.rows.slice(0, limit).map(serializeRow),
+    hasMore: res.rows.length > limit,
+    filteredCount,
+    ms: Math.round(performance.now() - started)
+  };
+}
+async function relations() {
+  const { rows: rows2 } = await db().query(
+    `select con.conname as name, sn.nspname as schema, s.relname as table, fn.nspname as ref_schema, f.relname as ref_table,
+            array(select attname::text from pg_attribute where attrelid = con.conrelid and attnum = any(con.conkey) order by array_position(con.conkey, attnum)) as columns,
+            array(select attname::text from pg_attribute where attrelid = con.confrelid and attnum = any(con.confkey) order by array_position(con.confkey, attnum)) as ref_columns
+       from pg_constraint con
+       join pg_class s on s.oid = con.conrelid join pg_namespace sn on sn.oid = s.relnamespace
+       join pg_class f on f.oid = con.confrelid join pg_namespace fn on fn.oid = f.relnamespace
+      where con.contype = 'f' and con.conparentid = 0 and not s.relispartition
+        and sn.nspname not in ('pg_catalog','information_schema') and sn.nspname not like 'pg_toast%' and sn.nspname not like 'pg_temp%'
+      order by sn.nspname, s.relname, con.conname`
+  );
+  return rows2;
+}
+var NUMBERS = /* @__PURE__ */ new Set(["int2", "int4", "int8", "float4", "float8", "numeric", "money", "oid"]);
+var EXACT_BYTES = 32 * 1024 * 1024;
+var SAMPLE_BYTES = 16 * 1024 * 1024;
+var BUCKETS = 24;
+var CHARTED = 60;
+async function profile(schema, table) {
+  const started = performance.now();
+  const oid = await oidOf(schema, table);
+  const { rows: [meta] } = await db().query(
+    `select c.relkind as kind, c.reltuples::bigint::text as estimate,
+            (case when c.relkind = 'p' then (select coalesce(sum(pg_table_size(relid)), 0) from pg_partition_tree(c.oid))
+                  else pg_table_size(c.oid) end)::bigint::text as bytes
+       from pg_class c where c.oid = $1`,
+    [oid]
+  );
+  const { rows: cols } = await db().query(
+    `select a.attname as name, format_type(a.atttypid, a.atttypmod) as type, t.typcategory as category, t.typname
+       from pg_attribute a join pg_type t on t.oid = a.atttypid
+      where a.attrelid = $1 and a.attnum > 0 and not a.attisdropped order by a.attnum`,
+    [oid]
+  );
+  const { rows: fkRows } = await db().query(
+    `select a.attname as name from pg_constraint con join pg_attribute a on a.attrelid = con.conrelid and a.attnum = con.conkey[1]
+      where con.conrelid = $1 and con.contype = 'f' and array_length(con.conkey, 1) = 1`,
+    [oid]
+  );
+  const fkCols = new Set(fkRows.map((f) => f.name));
+  const { rows: keyRows } = await db().query(
+    `select a.attname as name from pg_index ix join pg_attribute a on a.attrelid = ix.indrelid and a.attnum = ix.indkey[0]
+      where ix.indrelid = $1 and ix.indisunique and ix.indnatts = 1`,
+    [oid]
+  );
+  const keyCols = new Set(keyRows.map((k) => k.name));
+  const rel = `${q(schema)}.${q(table)}`;
+  const bytes = Number(meta.bytes);
+  const estimate = Number(meta.estimate);
+  const sampleable = ["r", "m", "p"].includes(meta.kind);
+  let method = sampleable ? "exact" : "head";
+  let percent = 100;
+  if (sampleable && (bytes > EXACT_BYTES || estimate > 2e5)) {
+    percent = Math.max(0.01, SAMPLE_BYTES / Math.max(bytes, 1) * 100);
+    if (percent < 100) method = "sample";
+    else percent = 100;
+  }
+  const source = () => method === "head" ? `(select * from ${rel} limit 100000) h` : method === "sample" ? `${rel} tablesample system (${percent.toFixed(4)}) repeatable (7)` : rel;
+  const finite = (x) => `${x} > '-Infinity'::float8 and ${x} < 'Infinity'::float8`;
+  const axis = cols.map((c) => {
+    const col = q(c.name);
+    if (c.category === "N" && !NUMBERS.has(c.typname)) return null;
+    if (c.category === "N") return c.typname === "money" ? `${col}::numeric::float8` : `${col}::text::float8`;
+    if (c.category === "D" || c.category === "T") return `extract(epoch from ${col})::float8`;
+    return null;
+  });
+  const select = ["count(*)::bigint::text as n"];
+  cols.forEach((c, i) => {
+    const col = q(c.name);
+    const key = ["S", "A", "U"].includes(c.category) ? `md5(${col}::text)` : `${col}::text`;
+    select.push(`count(${col})::bigint::text as n${i}`, `count(distinct ${key})::bigint::text as d${i}`);
+    const x = axis[i];
+    if (x) select.push(`(min(${col}) filter (where ${finite(x)}))::text as lo${i}`, `(max(${col}) filter (where ${finite(x)}))::text as hi${i}`, `min(${x}) filter (where ${finite(x)}) as xl${i}`, `max(${x}) filter (where ${finite(x)}) as xh${i}`);
+    if (c.category === "S") select.push(`min(length(${col}::text)) as ll${i}`, `max(length(${col}::text)) as lh${i}`);
+  });
+  let r;
+  try {
+    r = (await db().query(`select ${select.join(", ")} from ${source()}`)).rows[0];
+  } catch (e) {
+    if (e.code !== "57014" || method !== "exact" || !sampleable) throw friendlyTimeout(e);
+    method = "sample";
+    percent = 10;
+    r = (await db().query(`select ${select.join(", ")} from ${source()}`).catch((e2) => {
+      throw friendlyTimeout(e2);
+    })).rows[0];
+  }
+  const scanned = Number(r.n);
+  const columns = await Promise.all(cols.map(async (c, i) => {
+    const nonNull = Number(r[`n${i}`]);
+    const distinct = Number(r[`d${i}`]);
+    const x = axis[i];
+    const xl = x ? r[`xl${i}`] : null;
+    const xh = x ? r[`xh${i}`] : null;
+    const out = {
+      name: c.name,
+      type: c.type,
+      category: c.category,
+      nonNull,
+      distinct,
+      min: x ? r[`lo${i}`] : null,
+      max: x ? r[`hi${i}`] : null,
+      minLength: c.category === "S" ? r[`ll${i}`] : null,
+      maxLength: c.category === "S" ? r[`lh${i}`] : null,
+      hist: null,
+      top: null
+    };
+    if (i >= CHARTED || nonNull === 0) return out;
+    const col = q(c.name);
+    try {
+      const unique = distinct === nonNull;
+      const sequence = unique && ["int2", "int4", "int8"].includes(c.typname) && xl !== null && xh !== null && xh - xl + 1 === distinct;
+      const blob = c.category === "S" && (out.maxLength ?? 0) > 200;
+      if (x && !fkCols.has(c.name) && !keyCols.has(c.name) && !sequence && xl !== null && xh !== null && xl < xh && distinct > 12) {
+        const n = ["int2", "int4", "int8"].includes(c.typname) && xh - xl < BUCKETS ? xh - xl + 1 : BUCKETS;
+        const top = n === BUCKETS ? xh : xh + 1;
+        const { rows: rows2 } = await db().query(
+          `select least(width_bucket(${x}, $1, $2, ${n}), ${n}) as b, count(*)::int as n
+             from ${source()} where ${finite(x)} group by 1 order by 1`,
+          [xl, top]
+        );
+        const counts = Array(n).fill(0);
+        for (const row of rows2) counts[row.b - 1] = row.n;
+        out.hist = { lo: xl, hi: top, counts };
+      } else if (!blob && !unique && (fkCols.has(c.name) || distinct <= 12 || distinct < nonNull * 0.9)) {
+        const { rows: rows2 } = await db().query(
+          `select min(left(${col}::text, 120)) as value, count(*)::int as count
+             from ${source()} where ${col} is not null group by md5(${col}::text) order by 2 desc, 1 limit 5`
+        );
+        out.top = rows2;
+      }
+    } catch {
+    }
+    return out;
+  }));
+  return {
+    method,
+    percent: method === "sample" ? percent : 100,
+    scanned,
+    estimate: method === "exact" ? scanned : estimate >= 0 ? estimate : null,
+    charted: Math.min(cols.length, CHARTED),
+    ms: Math.round(performance.now() - started),
+    columns
+  };
+}
+function friendlyTimeout(e) {
+  if (e?.code === "57014") return Object.assign(new Error("Profiling stopped after 15 seconds."), { status: 408, hint: "This view or table is too slow to read in full. Query it in SQL with a LIMIT instead." });
+  return e;
+}
+async function references(schema, table, row) {
+  const { incoming } = await describe(schema, table);
+  return Promise.all(
+    incoming.filter((fk) => fk.columns.length === 1).map(async (fk) => {
+      const value = row[fk.ref_columns[0]];
+      if (value === null || value === void 0) return { ...fk, count: "0" };
+      const r = await db().query(
+        `select count(*)::text as n from ${q(fk.schema)}.${q(fk.table)} where ${q(fk.columns[0])} = $1`,
+        [value]
+      );
+      return { ...fk, count: r.rows[0].n };
+    })
+  );
+}
+var ESCAPES = /\b(set_config|query_to_xml\w*|cursor_to_xml\w*|dblink\w*|ts_stat|ts_rewrite)\s*\(|^\s*do\b|\bu&/i;
+var stripLiterals = (sql) => sql.replace(/--[^\n]*|\/\*[\s\S]*?\*\//g, " ").replace(/\$(\w*)\$[\s\S]*?\$\1\$|'(?:[^']|'')*'/g, "''").replace(/"/g, "");
+function guard(sql) {
+  const m = stripLiterals(sql).match(ESCAPES);
+  if (m) throw Object.assign(new Error(`${m[0].replace(/\s*\($/, "").trim()} isn't allowed in the read-only SQL tab.`), { status: 400 });
+}
+var NUMERIC_TYPES = /* @__PURE__ */ new Set([21, 23, 20, 26, 700, 701, 790, 1700]);
+async function query(sql) {
+  guard(sql);
+  const client = await db().connect();
+  const started = performance.now();
+  try {
+    await client.query(`begin read only; set local statement_timeout = '30s'`);
+    const { rows: [r] } = await client.query(
+      `select rolsuper, exists (select 1 from pg_roles where rolname = 'pg_read_all_data') and pg_has_role('pg_read_all_data', 'member') as can_drop
+         from pg_roles where rolname = current_user`
+    );
+    if (r?.can_drop) await client.query("set local role pg_read_all_data");
+    else if (r?.rolsuper) throw Object.assign(new Error("The SQL tab needs Postgres 14 or later when connected as a superuser, so queries can run without superuser rights."), { status: 400 });
+    const last = await client.query({ text: sql, rowMode: "array", queryMode: "extended" });
+    return {
+      command: last?.command ?? null,
+      fields: last?.fields?.map((f) => f.name) ?? [],
+      numeric: last?.fields?.map((f) => NUMERIC_TYPES.has(f.dataTypeID)) ?? [],
+      rows: (last?.rows ?? []).slice(0, 5e3).map((r2) => r2.map(serialize)),
+      rowCount: last?.rowCount ?? 0,
+      truncated: (last?.rows?.length ?? 0) > 5e3,
+      ms: Math.round(performance.now() - started)
+    };
+  } finally {
+    await client.query("rollback").catch(() => {
+    });
+    client.release();
+  }
+}
+function serialize(v) {
+  if (Buffer.isBuffer(v)) return "\\x" + v.toString("hex").slice(0, 200) + (v.length > 100 ? "\u2026" : "");
+  if (v instanceof Date) return v.toISOString();
+  return v;
+}
+function serializeRow(r) {
+  const out = {};
+  for (const k in r) out[k] = serialize(r[k]);
+  return out;
+}
+function describeConnection() {
+  const c = current;
+  if (c.url) {
+    const u = new URL(c.url);
+    return { host: u.hostname, port: u.port || "5432", user: decodeURIComponent(u.username), database: u.pathname.slice(1), version: serverVersion };
+  }
+  return { host: c.host || "localhost", port: String(c.port || 5432), user: c.user || os.userInfo().username, database: c.database || "postgres", version: serverVersion };
+}
+async function disconnect() {
+  await pool?.end().catch(() => {
+  });
+  pool = null;
+}
+
+// src/settings.ts
+import fs2 from "fs";
+import os2 from "os";
+import path from "path";
+var DEFAULTS = { mode: "system", palette: "paper", sidebar: "solid", radius: "none", density: "comfortable", font: "figtree", rail: "expanded" };
+var ALLOWED = {
+  mode: ["system", "light", "dark"],
+  palette: ["paper", "slate", "moss", "plum"],
+  sidebar: ["solid", "light", "minimal"],
+  radius: ["none", "soft", "round"],
+  density: ["comfortable", "compact"],
+  font: ["figtree", "inter", "system"],
+  rail: ["expanded", "collapsed"]
+};
+var file = path.join(process.env.XDG_CONFIG_HOME || path.join(os2.homedir(), ".config"), "transom", "settings.json");
+function sanitize(raw) {
+  const out = { ...DEFAULTS };
+  if (raw && typeof raw === "object")
+    for (const [k, allowed] of Object.entries(ALLOWED)) {
+      const v = raw[k];
+      if (typeof v === "string" && allowed.includes(v)) out[k] = v;
+    }
+  return out;
+}
+function readSettings() {
+  try {
+    return sanitize(JSON.parse(fs2.readFileSync(file, "utf8")));
+  } catch {
+    return { ...DEFAULTS };
+  }
+}
+function writeSettings(raw) {
+  const s = sanitize(raw);
+  fs2.mkdirSync(path.dirname(file), { recursive: true });
+  fs2.writeFileSync(file, JSON.stringify(s, null, 2) + "\n");
+  return s;
+}
+
+// src/cli.ts
+var args = process.argv.slice(2);
+var flag = (name) => args.includes(`--${name}`);
+var opt = (name) => {
+  const i = args.indexOf(`--${name}`);
+  return i >= 0 ? args[i + 1] : void 0;
+};
+if (flag("help") || flag("h")) {
+  console.log(`
+  transom \u2014 a calm Postgres viewer in your browser
+
+  Usage
+    npx transom                         auto-detect local Postgres and open the browser
+    npx transom postgres://user@host/db connect straight to a database
+
+  Options
+    --port <n>     port to listen on (default: a free one)
+    --no-open      don't open the browser
+    --help         show this help
+`);
+  process.exit(0);
+}
+var dev = flag("dev");
+var token = dev ? "dev" : crypto.randomBytes(18).toString("base64url");
+var uiDir = path2.join(path2.dirname(fileURLToPath(import.meta.url)), "ui");
+var initialUrl = args.find((a) => /^postgres(ql)?:\/\//.test(a));
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript",
+  ".css": "text/css",
+  ".svg": "image/svg+xml",
+  ".woff2": "font/woff2",
+  ".woff": "font/woff",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".json": "application/json"
+};
+var routes = {
+  "GET /api/detect": () => detectLocal(),
+  "GET /api/session": async () => connected() ? { connected: true, connection: describeConnection(), databases: await databases() } : { connected: false },
+  "POST /api/connect": (b) => connect(b),
+  "POST /api/disconnect": () => disconnect(),
+  "POST /api/database": (b) => switchDatabase(String(b.database)),
+  "GET /api/tables": () => tables(),
+  "GET /api/table": (_b, u) => describe(u.searchParams.get("schema"), u.searchParams.get("name")),
+  "POST /api/rows": (b) => rows(b),
+  "POST /api/references": (b) => references(b.schema, b.table, b.row),
+  "GET /api/relations": () => relations(),
+  "POST /api/profile": (b) => profile(String(b.schema), String(b.table)),
+  "POST /api/query": (b) => query(String(b.sql ?? "")),
+  "GET /api/settings": async () => readSettings(),
+  "POST /api/settings": async (b) => writeSettings(b)
+};
+function send(res, status, data) {
+  res.writeHead(status, { "content-type": "application/json", "cache-control": "no-store" });
+  res.end(JSON.stringify(data));
+}
+var server = http.createServer(async (req, res) => {
+  const url = new URL(req.url ?? "/", "http://localhost");
+  const host = (req.headers.host ?? "").replace(/:\d+$/, "");
+  if (!["127.0.0.1", "localhost", "[::1]"].includes(host)) return send(res, 403, { error: "Forbidden host" });
+  if (url.pathname.startsWith("/api/")) {
+    if (req.headers["x-transom-token"] !== token) return send(res, 401, { error: "Missing or wrong session token. Reopen the link printed in your terminal." });
+    const handler = routes[`${req.method} ${url.pathname}`];
+    if (!handler) return send(res, 404, { error: "Not found" });
+    let body = {};
+    if (req.method === "POST") {
+      const chunks = [];
+      for await (const c of req) chunks.push(c);
+      try {
+        body = JSON.parse(Buffer.concat(chunks).toString() || "{}");
+      } catch {
+        return send(res, 400, { error: "Invalid JSON" });
+      }
+    }
+    try {
+      send(res, 200, await handler(body, url) ?? { ok: true });
+    } catch (e) {
+      send(res, e.status ?? 400, { error: e.message, code: e.code, position: e.position, detail: e.detail, hint: e.hint });
+    }
+    return;
+  }
+  let file2 = path2.join(uiDir, path2.normalize(url.pathname).replace(/^(\.\.[/\\])+/, ""));
+  if (!file2.startsWith(uiDir) || !fs3.existsSync(file2) || fs3.statSync(file2).isDirectory()) file2 = path2.join(uiDir, "index.html");
+  if (!fs3.existsSync(file2)) return send(res, 404, { error: "UI not built. Run `pnpm build`." });
+  if (file2.endsWith("index.html")) {
+    const html = fs3.readFileSync(file2, "utf8").replace(
+      "<!--transom:settings-->",
+      `<script>window.__TRANSOM_SETTINGS__=${JSON.stringify(readSettings()).replace(/</g, "\\u003c")}</script>`
+    );
+    res.writeHead(200, { "content-type": MIME[".html"], "cache-control": "no-store", "referrer-policy": "no-referrer" });
+    return res.end(html);
+  }
+  res.writeHead(200, {
+    "content-type": MIME[path2.extname(file2)] ?? "application/octet-stream",
+    "cache-control": file2.includes(`${path2.sep}assets${path2.sep}`) ? "public, max-age=31536000, immutable" : "no-store",
+    "referrer-policy": "no-referrer"
+  });
+  fs3.createReadStream(file2).pipe(res);
+});
+if (initialUrl) await connect({ url: initialUrl }).catch((e) => console.error(`  Could not connect: ${e.message}`));
+var port = Number(opt("port") ?? 0);
+server.listen(port, "127.0.0.1", () => {
+  const addr = server.address();
+  const link = `http://127.0.0.1:${dev ? 5173 : addr.port}/#token=${token}`;
+  console.log(`
+  transom is running
+
+  \u2192 ${link}
+
+  Only this machine can reach it. Press Ctrl+C to stop.
+`);
+  if (!flag("no-open")) {
+    const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+    const cmdArgs = process.platform === "win32" ? ["/c", "start", "", link] : [link];
+    spawn(cmd, cmdArgs, { stdio: "ignore", detached: true }).on("error", () => {
+    }).unref();
+  }
+});
+var stop = () => disconnect().finally(() => process.exit(0));
+process.on("SIGINT", stop);
+process.on("SIGTERM", stop);