ardent-cli 0.0.34 → 0.0.36

package/dist/index.js

@@ -1510,11 +1510,24 @@ async function createAction2(type, url, options) {
     console.error(`  Supported: ${supportedTypes.join(", ")}`);
     process.exit(1);
   }
-  const legacyByocNeonProvider = typeof options.byoc === "string" ? options.byoc : void 0;
+  let selectedEnvironmentId = options.environmentId;
+  let legacyByocNeonProvider;
+  let useByocEnvironment = options.byoc === true;
+  if (typeof options.byoc === "string") {
+    if (options.byoc === "neon") {
+      legacyByocNeonProvider = options.byoc;
+    } else {
+      useByocEnvironment = true;
+      if (selectedEnvironmentId && selectedEnvironmentId !== options.byoc) {
+        console.error("\u2717 Conflicting BYOC environment IDs provided");
+        process.exit(1);
+      }
+      selectedEnvironmentId = options.byoc;
+    }
+  }
   const byocNeonProvider = options.byocNeon ?? legacyByocNeonProvider;
-  const useByocEnvironment = options.byoc === true;
   const isByocNeon = Boolean(byocNeonProvider);
-  if (options.environmentId && !useByocEnvironment) {
+  if (selectedEnvironmentId && !useByocEnvironment) {
     console.error("\u2717 --environment-id requires --byoc");
     process.exit(1);
   }
@@ -1584,8 +1597,8 @@ async function createAction2(type, url, options) {
     }
     if (useByocEnvironment) {
       createPayload.use_environment = true;
-      if (options.environmentId) {
-        createPayload.environment_id = options.environmentId;
+      if (selectedEnvironmentId) {
+        createPayload.environment_id = selectedEnvironmentId;
       }
       if (options.privateLinkId) {
         createPayload.private_link_id = options.privateLinkId;
@@ -2849,6 +2862,964 @@ async function removeAction2(key) {
   }
 }
 
+// src/lib/supabase_link.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync2, rmSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname, join as join2 } from "path";
+var CONFIG_DIR2 = join2(homedir2(), ".ardent");
+var STATE_DIR = join2(CONFIG_DIR2, "supabase-links");
+var ORIGINAL_SUFFIX = "-ardent-original";
+var SERVICE_SUFFIXES = ["rest", "auth", "storage", "realtime", "pg_meta"];
+var DOCKER_HOST_GATEWAY = "host.docker.internal";
+var REALTIME_LIST_CHANGES_MIGRATION_VERSION = "20230328144023";
+var SENSITIVE_DOCKER_ENV_KEYS = /* @__PURE__ */ new Set([
+  "DATABASE_URL",
+  "DB_PASSWORD",
+  "GOTRUE_DB_DATABASE_URL",
+  "PG_META_DB_PASSWORD",
+  "PGRST_DB_URI",
+  "PGPASSWORD"
+]);
+function redactDockerArgs(args2) {
+  return args2.map((arg) => {
+    const separatorIndex = arg.indexOf("=");
+    if (separatorIndex === -1) {
+      return arg;
+    }
+    const key = arg.slice(0, separatorIndex);
+    if (SENSITIVE_DOCKER_ENV_KEYS.has(key)) {
+      return `${key}=***`;
+    }
+    return arg;
+  });
+}
+function redactDockerErrorMessage(message) {
+  let redactedMessage = message.replace(
+    /(postgres(?:ql)?:\/\/[^:\s/]+:)[^@\s]+@/g,
+    "$1***@"
+  );
+  for (const key of SENSITIVE_DOCKER_ENV_KEYS) {
+    redactedMessage = redactedMessage.replace(
+      new RegExp(`${key}=[^\\s]+`, "g"),
+      `${key}=***`
+    );
+  }
+  return redactedMessage;
+}
+function runDocker(args2, options = {}) {
+  try {
+    return execFileSync("docker", args2, {
+      encoding: "utf-8",
+      stdio: options.stdio ?? "pipe"
+    }).trim();
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(
+        `Docker command failed: docker ${redactDockerArgs(args2).join(" ")}
+${redactDockerErrorMessage(error.message)}`
+      );
+    }
+    throw error;
+  }
+}
+function runDockerWithInput(args2, input, options = {}) {
+  try {
+    return execFileSync("docker", args2, {
+      encoding: "utf-8",
+      input,
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: options.timeoutMs
+    }).trim();
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(
+        `Docker command failed: docker ${redactDockerArgs(args2).join(" ")}
+${redactDockerErrorMessage(error.message)}`
+      );
+    }
+    throw error;
+  }
+}
+function dockerExists(name) {
+  const output = runDocker(["ps", "-a", "--format", "{{.Names}}"]);
+  return output.split("\n").includes(name);
+}
+function inspectContainer(name) {
+  const output = runDocker(["inspect", name]);
+  const parsed = JSON.parse(output);
+  if (parsed.length !== 1) {
+    throw new Error(`Expected one Docker container named ${name}`);
+  }
+  return parsed[0];
+}
+function containerIpAddress(name, network) {
+  const container = inspectContainer(name);
+  const networkState = container.NetworkSettings.Networks[network];
+  const ipAddress = networkState?.IPAddress;
+  if (!ipAddress) {
+    throw new Error(`Container ${name} is not attached to network ${network}`);
+  }
+  return ipAddress;
+}
+function statePath(projectId) {
+  return join2(STATE_DIR, `${projectId.replace(/[^A-Za-z0-9_.-]/g, "_")}.json`);
+}
+function readState(projectId) {
+  const path = statePath(projectId);
+  if (!existsSync2(path)) {
+    return void 0;
+  }
+  return JSON.parse(readFileSync5(path, "utf-8"));
+}
+function writeState(state) {
+  mkdirSync2(dirname(statePath(state.projectId)), { recursive: true });
+  writeFileSync2(statePath(state.projectId), JSON.stringify(state, null, 2));
+}
+function deleteState(projectId) {
+  const path = statePath(projectId);
+  if (existsSync2(path)) {
+    rmSync(path);
+  }
+}
+function detectSupabaseProject(explicitProject) {
+  if (explicitProject) {
+    return explicitProject;
+  }
+  const output = runDocker([
+    "ps",
+    "-a",
+    "--format",
+    '{{.Names}}	{{.Label "com.supabase.cli.project"}}'
+  ]);
+  const projects = /* @__PURE__ */ new Set();
+  for (const line of output.split("\n")) {
+    const parts = line.split("	");
+    if (parts.length !== 2) {
+      continue;
+    }
+    const projectId2 = parts[1]?.trim();
+    if (projectId2) {
+      projects.add(projectId2);
+    }
+  }
+  if (projects.size === 0) {
+    throw new Error("No local Supabase CLI containers found. Run `supabase start` first.");
+  }
+  if (projects.size > 1) {
+    throw new Error(
+      `Multiple Supabase projects found: ${Array.from(projects).join(", ")}. Pass --project <id>.`
+    );
+  }
+  const projectId = Array.from(projects)[0];
+  if (!projectId) {
+    throw new Error("Could not detect local Supabase project id.");
+  }
+  return projectId;
+}
+function containerName(prefix, projectId) {
+  return `supabase_${prefix}_${projectId}`;
+}
+function networkName(projectId) {
+  return `supabase_network_${projectId}`;
+}
+async function resolveBranch(branchName) {
+  const requestedBranchName = branchName || getCurrentBranch();
+  if (!requestedBranchName) {
+    throw new Error("No branch specified and no current branch is selected.");
+  }
+  const currentConnectorId = getConfig("currentConnectorId");
+  if (!currentConnectorId) {
+    throw new Error("No connector selected. Run `ardent connector switch` first.");
+  }
+  const result = await api.get(
+    `/v1/cli/branches?connector_id=${encodeURIComponent(currentConnectorId)}`
+  );
+  if (!Array.isArray(result.branches)) {
+    throw new Error("API returned invalid response: missing branches array");
+  }
+  setCacheEntry("branches", result.branches);
+  const branch = result.branches.find((candidate) => candidate.name === requestedBranchName);
+  if (!branch) {
+    const cached = getCacheEntry("branches");
+    const cachedBranch = cached?.data.find((candidate) => candidate.name === requestedBranchName);
+    if (cachedBranch) {
+      return cachedBranch;
+    }
+    throw new Error(`Branch "${requestedBranchName}" not found.`);
+  }
+  if (!branch.branch_url) {
+    throw new Error(`Branch "${branch.name}" does not have a connection URL.`);
+  }
+  return branch;
+}
+function parseBranchUrl(branchUrl) {
+  const parsed = new URL(branchUrl);
+  if (!parsed.hostname || !parsed.username || !parsed.password) {
+    throw new Error("Branch URL is missing host, username, or password.");
+  }
+  return parsed;
+}
+function branchTargetConnectHost(hostname) {
+  if (hostname === "routing.localhost" || hostname.endsWith(".routing.localhost")) {
+    return DOCKER_HOST_GATEWAY;
+  }
+  return hostname;
+}
+function shouldVerifyBranchTargetCertificate(hostname) {
+  return !(hostname === "routing.localhost" || hostname.endsWith(".routing.localhost"));
+}
+function proxyScript() {
+  return String.raw`
+const net = require("net");
+const tls = require("tls");
+
+const listenPort = Number(process.env.LISTEN_PORT || "5432");
+const targetHost = process.env.TARGET_HOST;
+const targetConnectHost = process.env.TARGET_CONNECT_HOST || targetHost;
+const targetPort = Number(process.env.TARGET_PORT || "5432");
+const targetDatabase = process.env.TARGET_DATABASE;
+const rejectUnauthorized = process.env.TARGET_REJECT_UNAUTHORIZED !== "false";
+
+if (!targetHost || !targetDatabase) {
+  throw new Error("TARGET_HOST and TARGET_DATABASE are required");
+}
+
+const SSL_REQUEST = 80877103;
+const AUTH_SASL = 10;
+
+function readCString(buffer, offset) {
+  const end = buffer.indexOf(0, offset);
+  if (end === -1) {
+    throw new Error("Invalid startup packet: unterminated string");
+  }
+  return [buffer.toString("utf8", offset, end), end + 1];
+}
+
+function rewriteStartupPacket(packet) {
+  const length = packet.readInt32BE(0);
+  const protocol = packet.readInt32BE(4);
+  const params = [];
+  let offset = 8;
+
+  while (offset < length - 1) {
+    let key;
+    [key, offset] = readCString(packet, offset);
+    if (!key) {
+      break;
+    }
+    let value;
+    [value, offset] = readCString(packet, offset);
+    if (key === "database" && (value === "postgres" || value === "_supabase")) {
+      value = targetDatabase;
+    }
+    params.push([key, value]);
+  }
+
+  const chunks = [];
+  const header = Buffer.alloc(4);
+  header.writeInt32BE(protocol, 0);
+  chunks.push(header);
+  for (const [key, value] of params) {
+    chunks.push(Buffer.from(key + "\0" + value + "\0", "utf8"));
+  }
+  chunks.push(Buffer.from([0]));
+  const body = Buffer.concat(chunks);
+  const output = Buffer.alloc(4 + body.length);
+  output.writeInt32BE(output.length, 0);
+  body.copy(output, 4);
+  return output;
+}
+
+function filterServerPacket(packet) {
+  if (packet.length < 9 || packet[0] !== 82) {
+    return packet;
+  }
+  const authCode = packet.readInt32BE(5);
+  if (authCode !== AUTH_SASL) {
+    return packet;
+  }
+  const length = packet.readInt32BE(1);
+  const body = packet.subarray(9, 1 + length);
+  const trailing = packet.subarray(1 + length);
+  const mechanisms = body.toString("utf8").split("\0").filter(Boolean);
+  const filtered = mechanisms.filter((mechanism) => mechanism !== "SCRAM-SHA-256-PLUS");
+  if (filtered.length === mechanisms.length) {
+    return packet;
+  }
+  filtered.push("");
+  const newBody = Buffer.from(filtered.join("\0") + "\0", "utf8");
+  const output = Buffer.alloc(1 + 4 + 4 + newBody.length);
+  output[0] = 82;
+  output.writeInt32BE(4 + 4 + newBody.length, 1);
+  output.writeInt32BE(AUTH_SASL, 5);
+  newBody.copy(output, 9);
+  return Buffer.concat([output, trailing]);
+}
+
+function connectUpstream(startupPacket, client) {
+  const socket = net.connect(targetPort, targetConnectHost, () => {
+    const sslRequest = Buffer.alloc(8);
+    sslRequest.writeInt32BE(8, 0);
+    sslRequest.writeInt32BE(SSL_REQUEST, 4);
+    socket.write(sslRequest);
+  });
+
+  socket.once("data", (response) => {
+    if (response[0] !== 83) {
+      client.destroy(new Error("Upstream PostgreSQL server did not accept SSL"));
+      socket.destroy();
+      return;
+    }
+
+    const secureSocket = tls.connect({
+      socket,
+      servername: targetHost,
+      rejectUnauthorized,
+    }, () => {
+      let rewrittenStartupPacket;
+      try {
+        rewrittenStartupPacket = rewriteStartupPacket(startupPacket);
+      } catch {
+        client.destroy();
+        secureSocket.destroy();
+        return;
+      }
+      secureSocket.write(rewrittenStartupPacket);
+    });
+
+    secureSocket.on("data", (chunk) => {
+      client.write(filterServerPacket(chunk));
+    });
+    client.on("data", (chunk) => secureSocket.write(chunk));
+    secureSocket.on("error", () => client.destroy());
+    client.on("error", () => secureSocket.destroy());
+    secureSocket.on("close", () => client.destroy());
+    client.on("close", () => secureSocket.destroy());
+  });
+
+  socket.on("error", () => client.destroy());
+}
+
+const server = net.createServer((client) => {
+  let buffered = Buffer.alloc(0);
+  let sawSslRequest = false;
+
+  client.on("data", function onFirstData(chunk) {
+    buffered = Buffer.concat([buffered, chunk]);
+    if (buffered.length < 8) {
+      return;
+    }
+
+    const length = buffered.readInt32BE(0);
+    const code = buffered.readInt32BE(4);
+    if (!sawSslRequest && length === 8 && code === SSL_REQUEST) {
+      client.write("N");
+      buffered = buffered.subarray(8);
+      sawSslRequest = true;
+      if (buffered.length < 8) {
+        return;
+      }
+    }
+
+    const startupLength = buffered.readInt32BE(0);
+    if (buffered.length < startupLength) {
+      return;
+    }
+
+    client.off("data", onFirstData);
+    try {
+      const startupPacket = buffered.subarray(0, startupLength);
+      const remainder = buffered.subarray(startupLength);
+      connectUpstream(startupPacket, client);
+      if (remainder.length > 0) {
+        client.unshift(remainder);
+      }
+    } catch {
+      client.destroy();
+    }
+  });
+});
+
+server.listen(listenPort, "0.0.0.0", () => {
+  console.log(JSON.stringify({ event: "listening", listenPort, targetHost, targetConnectHost, targetDatabase }));
+});
+`;
+}
+function writeProxyScript(projectId) {
+  const scriptPath = join2(STATE_DIR, projectId, "proxy.js");
+  mkdirSync2(dirname(scriptPath), { recursive: true });
+  writeFileSync2(scriptPath, proxyScript());
+  return scriptPath;
+}
+function serviceEnvForBranch(servicePrefix, env, dbContainer, branchUser, branchPassword) {
+  const localDbUri = (role) => `postgresql://${encodeURIComponent(role)}:${encodeURIComponent(branchPassword)}@${dbContainer}:5432/postgres?sslmode=disable`;
+  return env.map((entry) => {
+    if (servicePrefix === "rest" && entry.startsWith("PGRST_DB_URI=")) {
+      return `PGRST_DB_URI=${localDbUri("authenticator")}`;
+    }
+    if (servicePrefix === "auth" && entry.startsWith("GOTRUE_DB_DATABASE_URL=")) {
+      return `GOTRUE_DB_DATABASE_URL=${localDbUri("supabase_auth_admin")}`;
+    }
+    if (servicePrefix === "storage" && entry.startsWith("DATABASE_URL=")) {
+      return `DATABASE_URL=${localDbUri("supabase_storage_admin")}`;
+    }
+    if (servicePrefix === "realtime") {
+      if (entry.startsWith("DB_HOST=")) {
+        return `DB_HOST=${dbContainer}`;
+      }
+      if (entry.startsWith("DB_NAME=")) {
+        return "DB_NAME=postgres";
+      }
+      if (entry.startsWith("DB_USER=")) {
+        return "DB_USER=supabase_admin";
+      }
+      if (entry.startsWith("DB_PASSWORD=")) {
+        return `DB_PASSWORD=${branchPassword}`;
+      }
+      if (entry.startsWith("DB_PORT=")) {
+        return "DB_PORT=5432";
+      }
+    }
+    if (servicePrefix === "pg_meta") {
+      if (entry.startsWith("PG_META_DB_HOST=")) {
+        return `PG_META_DB_HOST=${dbContainer}`;
+      }
+      if (entry.startsWith("PG_META_DB_NAME=")) {
+        return "PG_META_DB_NAME=postgres";
+      }
+      if (entry.startsWith("PG_META_DB_USER=")) {
+        return `PG_META_DB_USER=${branchUser}`;
+      }
+      if (entry.startsWith("PG_META_DB_PASSWORD=")) {
+        return `PG_META_DB_PASSWORD=${branchPassword}`;
+      }
+      if (entry.startsWith("PG_META_DB_PORT=")) {
+        return "PG_META_DB_PORT=5432";
+      }
+    }
+    return entry;
+  });
+}
+function mountArgs(mounts) {
+  const args2 = [];
+  for (const mount of mounts) {
+    if (!mount.Source || !mount.Target) {
+      continue;
+    }
+    const readonly = mount.ReadOnly ? ",readonly" : "";
+    args2.push(
+      "--mount",
+      `type=${mount.Type},source=${mount.Source},target=${mount.Target}${readonly}`
+    );
+  }
+  return args2;
+}
+function portPublishArgs(container) {
+  const args2 = [];
+  const ports = container.NetworkSettings.Ports ?? {};
+  for (const [containerPort, bindings] of Object.entries(ports)) {
+    if (!bindings) {
+      continue;
+    }
+    for (const binding of bindings) {
+      if (!binding.HostPort) {
+        continue;
+      }
+      const hostPrefix = binding.HostIp ? `${binding.HostIp}:` : "";
+      args2.push("-p", `${hostPrefix}${binding.HostPort}:${containerPort}`);
+    }
+  }
+  return args2;
+}
+function containerAliases(container, network, fallback) {
+  const aliases = container.NetworkSettings.Networks[network]?.Aliases ?? [];
+  const cleanAliases = aliases.filter((alias) => alias && alias !== container.Name.replace(/^\//, ""));
+  return cleanAliases.length > 0 ? cleanAliases : [fallback];
+}
+function imageCommandArgs(image, entrypoint, command) {
+  const args2 = [];
+  if (entrypoint && entrypoint.length > 0) {
+    args2.push("--entrypoint", entrypoint[0]);
+  }
+  args2.push(image);
+  if (entrypoint && entrypoint.length > 1) {
+    args2.push(...entrypoint.slice(1));
+  }
+  if (command) {
+    args2.push(...command);
+  }
+  return args2;
+}
+function recreateServiceForBranch(servicePrefix, projectId, network, dbContainer, branchUser, branchPassword) {
+  const name = containerName(servicePrefix, projectId);
+  if (!dockerExists(name)) {
+    return void 0;
+  }
+  const originalName = `${name}${ORIGINAL_SUFFIX}`;
+  if (dockerExists(originalName)) {
+    throw new Error(`Refusing to overwrite existing backup container ${originalName}. Run unlink first.`);
+  }
+  const container = inspectContainer(name);
+  const aliases = containerAliases(container, network, servicePrefix.replace("pg_meta", "meta"));
+  const env = serviceEnvForBranch(
+    servicePrefix,
+    container.Config.Env ?? [],
+    dbContainer,
+    branchUser,
+    branchPassword
+  );
+  runDocker(["stop", name]);
+  runDocker(["rename", name, originalName]);
+  const args2 = ["run", "-d", "--name", name, "--network", network];
+  for (const alias of aliases) {
+    args2.push("--network-alias", alias);
+  }
+  for (const envValue of env) {
+    args2.push("-e", envValue);
+  }
+  if (container.Config.User) {
+    args2.push("--user", container.Config.User);
+  }
+  if (container.Config.WorkingDir) {
+    args2.push("--workdir", container.Config.WorkingDir);
+  }
+  args2.push(...mountArgs(container.Mounts));
+  args2.push(
+    ...imageCommandArgs(container.Config.Image, container.Config.Entrypoint, container.Config.Cmd)
+  );
+  runDocker(args2);
+  return { name, originalName };
+}
+function startProxyContainer(projectId, network, dbContainer, parsedBranchUrl, portBindings) {
+  const scriptPath = writeProxyScript(projectId);
+  const targetDatabase = parsedBranchUrl.pathname.replace(/^\//, "") || "postgres";
+  const targetPort = parsedBranchUrl.port || "5432";
+  const targetConnectHost = branchTargetConnectHost(parsedBranchUrl.hostname);
+  const rejectUnauthorized = shouldVerifyBranchTargetCertificate(parsedBranchUrl.hostname);
+  const args2 = [
+    "run",
+    "-d",
+    "--name",
+    dbContainer,
+    "--network",
+    network,
+    "--network-alias",
+    "db",
+    "--network-alias",
+    "db.supabase.internal"
+  ];
+  if (targetConnectHost === DOCKER_HOST_GATEWAY) {
+    args2.push("--add-host", `${DOCKER_HOST_GATEWAY}:host-gateway`);
+  }
+  args2.push(...portBindings);
+  args2.push(
+    "-v",
+    `${scriptPath}:/proxy.js:ro`,
+    "-e",
+    `TARGET_HOST=${parsedBranchUrl.hostname}`,
+    "-e",
+    `TARGET_CONNECT_HOST=${targetConnectHost}`,
+    "-e",
+    `TARGET_PORT=${targetPort}`,
+    "-e",
+    `TARGET_DATABASE=${targetDatabase}`,
+    "-e",
+    `TARGET_REJECT_UNAUTHORIZED=${String(rejectUnauthorized)}`,
+    "-e",
+    "LISTEN_PORT=5432",
+    "node:22-alpine",
+    "node",
+    "/proxy.js"
+  );
+  runDocker(args2);
+}
+function dumpLocalStorageMigrations(dbContainer) {
+  return runDocker([
+    "exec",
+    dbContainer,
+    "pg_dump",
+    "-U",
+    "postgres",
+    "-d",
+    "postgres",
+    "--data-only",
+    "--table=storage.migrations",
+    "--column-inserts",
+    "--no-owner",
+    "--no-privileges"
+  ]);
+}
+function storageMigrationsImportSql(dumpSql) {
+  const tempTable = "pg_temp.ardent_storage_migrations_import";
+  const tempDumpSql = dumpSql.replaceAll("INSERT INTO storage.migrations", `INSERT INTO ${tempTable}`);
+  return `
+BEGIN;
+CREATE TEMP TABLE ardent_storage_migrations_import (LIKE storage.migrations INCLUDING DEFAULTS);
+${tempDumpSql}
+INSERT INTO storage.migrations
+SELECT * FROM ${tempTable}
+ON CONFLICT DO NOTHING;
+COMMIT;
+`;
+}
+function waitForOriginalDb(containerName2) {
+  const deadline = Date.now() + 3e4;
+  while (Date.now() < deadline) {
+    try {
+      runDocker(["exec", containerName2, "pg_isready", "-U", "postgres", "-d", "postgres"]);
+      return;
+    } catch {
+      execFileSync("sleep", ["1"]);
+    }
+  }
+  throw new Error(`Timed out waiting for ${containerName2} to accept local PostgreSQL connections.`);
+}
+function copyLocalStorageMigrationsToBranch(dumpSql, originalDbContainer, dbContainer, network, branchUser, branchPassword) {
+  runDocker(["start", originalDbContainer]);
+  try {
+    waitForOriginalDb(originalDbContainer);
+    const dbContainerIpAddress = containerIpAddress(dbContainer, network);
+    runDockerWithInput(
+      [
+        "exec",
+        "-i",
+        "-e",
+        `PGPASSWORD=${branchPassword}`,
+        originalDbContainer,
+        "psql",
+        "-h",
+        dbContainerIpAddress,
+        "-p",
+        "5432",
+        "-U",
+        branchUser,
+        "-d",
+        "postgres",
+        "-v",
+        "ON_ERROR_STOP=1"
+      ],
+      storageMigrationsImportSql(dumpSql)
+    );
+  } finally {
+    runDocker(["stop", originalDbContainer]);
+  }
+}
+function supabaseRealtimeCompatibilitySql() {
+  return String.raw`
+SET lock_timeout = '2s';
+SET statement_timeout = '5s';
+
+ALTER SCHEMA realtime OWNER TO supabase_admin;
+GRANT ALL PRIVILEGES ON SCHEMA realtime TO supabase_realtime_admin;
+
+CREATE OR REPLACE FUNCTION realtime.list_changes(
+  publication name,
+  slot_name name,
+  max_changes int,
+  max_record_bytes int
+)
+RETURNS SETOF realtime.wal_rls
+LANGUAGE sql
+AS $$
+  WITH pub AS (
+    SELECT
+      concat_ws(
+        ',',
+        CASE WHEN bool_or(pubinsert) THEN 'insert' ELSE NULL END,
+        CASE WHEN bool_or(pubupdate) THEN 'update' ELSE NULL END,
+        CASE WHEN bool_or(pubdelete) THEN 'delete' ELSE NULL END
+      ) AS w2j_actions,
+      coalesce(
+        string_agg(
+          realtime.quote_wal2json(format('%I.%I', schemaname, tablename)::regclass),
+          ','
+        ) FILTER (WHERE ppt.tablename IS NOT NULL AND ppt.tablename NOT LIKE '% %'),
+        ''
+      ) AS w2j_add_tables
+    FROM pg_publication pp
+    LEFT JOIN pg_publication_tables ppt
+      ON pp.pubname = ppt.pubname
+    WHERE pp.pubname = publication
+    GROUP BY pp.pubname
+    LIMIT 1
+  ),
+  w2j AS (
+    SELECT
+      x.*,
+      pub.w2j_add_tables
+    FROM pub,
+    pg_logical_slot_get_changes(
+      slot_name,
+      NULL,
+      max_changes,
+      'include-pk', 'true',
+      'include-transaction', 'false',
+      'include-timestamp', 'true',
+      'include-type-oids', 'true',
+      'format-version', '2',
+      'actions', pub.w2j_actions,
+      'add-tables', pub.w2j_add_tables
+    ) x
+  )
+  SELECT
+    xyz.wal,
+    xyz.is_rls_enabled,
+    xyz.subscription_ids,
+    xyz.errors
+  FROM w2j,
+  realtime.apply_rls(
+    wal := w2j.data::jsonb,
+    max_record_bytes := max_record_bytes
+  ) xyz(wal, is_rls_enabled, subscription_ids, errors)
+  WHERE w2j.w2j_add_tables <> ''
+    AND xyz.subscription_ids[1] IS NOT NULL
+$$;
+
+ALTER FUNCTION realtime.list_changes(name, name, int, int) OWNER TO supabase_realtime_admin;
+GRANT EXECUTE ON FUNCTION realtime.list_changes(name, name, int, int)
+  TO supabase_admin, supabase_realtime_admin;
+
+INSERT INTO realtime.schema_migrations (version, inserted_at)
+VALUES (${REALTIME_LIST_CHANGES_MIGRATION_VERSION}, now())
+ON CONFLICT (version) DO NOTHING;
+`;
+}
+function applySupabaseRealtimeCompatibility(projectId, originalDbContainer, dbContainer, network, branchPassword) {
+  const realtimeContainer = containerName("realtime", projectId);
+  if (!dockerExists(realtimeContainer)) {
+    return;
+  }
+  runDocker(["start", originalDbContainer]);
+  try {
+    waitForOriginalDb(originalDbContainer);
+    const dbContainerIpAddress = containerIpAddress(dbContainer, network);
+    const deadline = Date.now() + 6e4;
+    let lastError = "";
+    while (Date.now() < deadline) {
+      try {
+        runDockerWithInput(
+          [
+            "exec",
+            "-i",
+            "-e",
+            `PGPASSWORD=${branchPassword}`,
+            originalDbContainer,
+            "psql",
+            "-h",
+            dbContainerIpAddress,
+            "-p",
+            "5432",
+            "-U",
+            "supabase_admin",
+            "-d",
+            "postgres",
+            "-v",
+            "ON_ERROR_STOP=1"
+          ],
+          supabaseRealtimeCompatibilitySql(),
+          { timeoutMs: 7e3 }
+        );
+        runDocker(["restart", realtimeContainer]);
+        return;
+      } catch (error) {
+        lastError = error instanceof Error ? error.message : String(error);
+        execFileSync("sleep", ["1"]);
+      }
+    }
+    throw new Error(`Timed out applying Supabase Realtime compatibility: ${lastError}`);
+  } finally {
+    runDocker(["stop", originalDbContainer]);
+  }
+}
+function kongApiUrl(projectId) {
+  const kong = containerName("kong", projectId);
+  if (!dockerExists(kong)) {
+    return void 0;
+  }
+  const output = runDocker(["port", kong, "8000/tcp"]);
+  const first = output.split("\n")[0];
+  const port = first?.split(":").pop();
+  return port ? `http://127.0.0.1:${port}` : void 0;
+}
+async function waitForHealth(projectId) {
+  const apiUrl = kongApiUrl(projectId);
+  if (!apiUrl) {
+    return;
+  }
+  const deadline = Date.now() + 6e4;
+  let lastError = "";
+  while (Date.now() < deadline) {
+    try {
+      const authResponse = await fetch(`${apiUrl}/auth/v1/health`);
+      const restResponse = await fetch(`${apiUrl}/rest/v1/`);
+      if (authResponse.ok && restResponse.ok) {
+        return;
+      }
+      lastError = `auth=${authResponse.status}, rest=${restResponse.status}`;
+    } catch (error) {
+      lastError = error instanceof Error ? error.message : String(error);
+    }
+    await new Promise((resolve) => setTimeout(resolve, 2e3));
+  }
+  throw new Error(`Supabase health checks did not pass: ${lastError}`);
+}
+function restoreOriginalContainer(name, originalName) {
+  if (dockerExists(name)) {
+    runDocker(["rm", "-f", name]);
+  }
+  if (dockerExists(originalName)) {
+    runDocker(["rename", originalName, name]);
+    runDocker(["start", name]);
+  }
+}
+function rollbackPartialLink(projectId, dbContainer, originalDbContainer, services) {
+  for (const service of services.reverse()) {
+    restoreOriginalContainer(service.name, service.originalName);
+  }
+  restoreOriginalContainer(dbContainer, originalDbContainer);
+  deleteState(projectId);
+}
+async function statusSupabaseAction(options = {}) {
+  try {
+    const projectId = detectSupabaseProject(options.project);
+    const state = readState(projectId);
+    console.log(`Supabase project: ${projectId}`);
+    if (!state) {
+      console.log("Status: not linked");
+      return;
+    }
+    console.log("Status: linked");
+    console.log(`Branch: ${state.branchName}`);
+    console.log(`Linked at: ${new Date(state.linkedAt).toLocaleString()}`);
+    console.log(`DB container: ${state.dbContainer}`);
+  } catch (error) {
+    console.error("\u2717 Failed:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+async function linkSupabaseAction(branchName, options = {}) {
+  let projectId = "";
+  let dbContainer = "";
+  let originalDbContainer = "";
+  const createdServices = [];
+  try {
+    projectId = detectSupabaseProject(options.project);
+    if (readState(projectId)) {
+      throw new Error(`Supabase project ${projectId} is already linked. Run unlink first.`);
+    }
+    const branch = await resolveBranch(branchName);
+    const parsedBranchUrl = parseBranchUrl(branch.branch_url);
+    const branchUser = decodeURIComponent(parsedBranchUrl.username);
+    const branchPassword = decodeURIComponent(parsedBranchUrl.password);
+    dbContainer = containerName("db", projectId);
+    originalDbContainer = `${dbContainer}${ORIGINAL_SUFFIX}`;
+    const network = networkName(projectId);
+    if (!dockerExists(dbContainer)) {
+      throw new Error(`Local Supabase DB container not found: ${dbContainer}`);
+    }
+    if (dockerExists(originalDbContainer)) {
+      throw new Error(`Backup DB container already exists: ${originalDbContainer}. Run unlink first.`);
+    }
+    console.log(`Linking Supabase project ${projectId} to branch ${branch.name}...`);
+    const storageMigrationsDump = dumpLocalStorageMigrations(dbContainer);
+    const originalDbContainerState = inspectContainer(dbContainer);
+    const dbPortBindings = portPublishArgs(originalDbContainerState);
+    runDocker(["stop", dbContainer]);
+    runDocker(["rename", dbContainer, originalDbContainer]);
+    startProxyContainer(projectId, network, dbContainer, parsedBranchUrl, []);
+    copyLocalStorageMigrationsToBranch(
+      storageMigrationsDump,
+      originalDbContainer,
+      dbContainer,
+      network,
+      branchUser,
+      branchPassword
+    );
+    for (const servicePrefix of SERVICE_SUFFIXES) {
+      const service = recreateServiceForBranch(
+        servicePrefix,
+        projectId,
+        network,
+        dbContainer,
+        branchUser,
+        branchPassword
+      );
+      if (service) {
+        createdServices.push(service);
+      }
+    }
+    applySupabaseRealtimeCompatibility(
+      projectId,
+      originalDbContainer,
+      dbContainer,
+      network,
+      branchPassword
+    );
+    runDocker(["rm", "-f", dbContainer]);
+    startProxyContainer(projectId, network, dbContainer, parsedBranchUrl, dbPortBindings);
+    const kong = containerName("kong", projectId);
+    if (dockerExists(kong)) {
+      runDocker(["restart", kong]);
+    }
+    const state = {
+      version: 1,
+      projectId,
+      network,
+      branchName: branch.name,
+      linkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      dbContainer,
+      originalDbContainer,
+      services: createdServices
+    };
+    if (!options.skipHealthCheck) {
+      await waitForHealth(projectId);
+    }
+    writeState(state);
+    console.log("\u2713 Local Supabase is linked to the branch");
+    trackEvent("CLI: settings supabase link succeeded");
+  } catch (error) {
+    if (projectId) {
+      const state = readState(projectId);
+      if (!state && dbContainer && originalDbContainer) {
+        rollbackPartialLink(projectId, dbContainer, originalDbContainer, createdServices);
+      }
+    }
+    trackEvent("CLI: settings supabase link failed");
+    console.error("\u2717 Failed:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+async function unlinkSupabaseAction(options = {}) {
+  try {
+    const projectId = detectSupabaseProject(options.project);
+    const state = readState(projectId);
+    if (!state) {
+      console.log(`Supabase project ${projectId} is not linked`);
+      return;
+    }
+    console.log(`Unlinking Supabase project ${projectId}...`);
+    restoreOriginalContainer(state.dbContainer, state.originalDbContainer);
+    for (const service of state.services) {
+      restoreOriginalContainer(service.name, service.originalName);
+    }
+    const kong = containerName("kong", projectId);
+    if (dockerExists(kong)) {
+      runDocker(["restart", kong]);
+    }
+    deleteState(projectId);
+    if (!options.skipHealthCheck) {
+      await waitForHealth(projectId);
+    }
+    console.log("\u2713 Local Supabase restored to its local database");
+    trackEvent("CLI: settings supabase unlink succeeded");
+  } catch (error) {
+    trackEvent("CLI: settings supabase unlink failed");
+    console.error("\u2717 Failed:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+
 // src/commands/settings/index.ts
 var settingsCommand = new Command6("settings").description("Manage settings for the current connector").showHelpAfterError("(run 'ardent settings --help' for valid keys)");
 settingsCommand.command("list").description("List current settings for the connector").action(listAction5);
@@ -2856,6 +3827,11 @@ settingsCommand.command("set <key> <value>").description(
   "Set a setting. Keys: default_db, branch_sql. For branch_sql, prefix value with @ to read from file."
 ).action(setAction);
 settingsCommand.command("remove <key>").description("Remove a setting. Keys: default_db, branch_sql.").action(removeAction2);
+var supabaseSettingsCommand = new Command6("supabase").description("Link local Supabase to an Ardent branch");
+supabaseSettingsCommand.command("status").description("Show local Supabase link status").option("--project <project>", "Supabase CLI project id").action(statusSupabaseAction);
+supabaseSettingsCommand.command("link [branch]").description("Point local Supabase at an Ardent branch").option("--project <project>", "Supabase CLI project id").option("--skip-health-check", "Skip Supabase API health checks after linking").action(linkSupabaseAction);
+supabaseSettingsCommand.command("unlink").description("Restore local Supabase to its local database").option("--project <project>", "Supabase CLI project id").option("--skip-health-check", "Skip Supabase API health checks after unlinking").action(unlinkSupabaseAction);
+settingsCommand.addCommand(supabaseSettingsCommand);
 
 // src/commands/auth/index.ts
 import { Command as Command7 } from "commander";
@@ -3047,16 +4023,16 @@ var logoutCommand = new Command7("logout").description("Logout from Ardent").act
 var statusCommand = new Command7("status").description("Show status").action(statusAction);
 
 // src/lib/update-check.ts
-import { existsSync as existsSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
-import { join as join2 } from "path";
-import { homedir as homedir2 } from "os";
-var UPDATE_CHECK_FILE = join2(homedir2(), ".ardent", "update-check.json");
+import { existsSync as existsSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+var UPDATE_CHECK_FILE = join3(homedir3(), ".ardent", "update-check.json");
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var PACKAGE_NAME = "ardent-cli";
 function loadCache() {
   try {
-    if (existsSync2(UPDATE_CHECK_FILE)) {
-      return JSON.parse(readFileSync5(UPDATE_CHECK_FILE, "utf-8"));
+    if (existsSync3(UPDATE_CHECK_FILE)) {
+      return JSON.parse(readFileSync6(UPDATE_CHECK_FILE, "utf-8"));
     }
   } catch {
   }
@@ -3068,7 +4044,7 @@ function saveCache(latestVersion) {
       latest_version: latestVersion,
       checked_at: (/* @__PURE__ */ new Date()).toISOString()
     };
-    writeFileSync2(UPDATE_CHECK_FILE, JSON.stringify(data));
+    writeFileSync3(UPDATE_CHECK_FILE, JSON.stringify(data));
   } catch {
   }
 }
@@ -3155,6 +4131,7 @@ SETTINGS
   settings list          List current settings for the connector
   settings set           Set a setting (e.g. default_db testdb)
   settings remove        Remove a setting
+  settings supabase      Link local Supabase to the current branch
 
 TEAM
   invite <email>         Invite a user to your organization

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ardent-cli",
-  "version": "0.0.34",
+  "version": "0.0.36",
   "description": "Git for Data infrastructure",
   "type": "module",
   "bin": {