supabase-selfhosted-cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,1329 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/lib/config.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+var CONFIG_DIR = path.join(os.homedir(), ".supabase-selfhosted-cli");
+var DEFAULT_PROFILE = "default";
+function profilePath(profile) {
+  return path.join(CONFIG_DIR, "profiles", `${profile}.json`);
+}
+function projectLinkPath(cwd) {
+  return path.join(cwd, ".supabase-selfhosted-cli.json");
+}
+function ensureConfigDir() {
+  fs.mkdirSync(path.join(CONFIG_DIR, "profiles"), { recursive: true, mode: 448 });
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  const filePath = profilePath(config.profile);
+  fs.writeFileSync(filePath, `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+}
+function normalizeConfig(raw) {
+  return {
+    ...raw,
+    target: raw.target ?? "ssh"
+  };
+}
+function loadConfig(profile = DEFAULT_PROFILE) {
+  const filePath = profilePath(profile);
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  const raw = JSON.parse(fs.readFileSync(filePath, "utf8"));
+  return normalizeConfig(raw);
+}
+function deleteConfig(profile = DEFAULT_PROFILE) {
+  const filePath = profilePath(profile);
+  if (!fs.existsSync(filePath)) {
+    return false;
+  }
+  fs.unlinkSync(filePath);
+  return true;
+}
+function listProfiles() {
+  const profilesDir = path.join(CONFIG_DIR, "profiles");
+  if (!fs.existsSync(profilesDir)) {
+    return [];
+  }
+  return fs.readdirSync(profilesDir).filter((name) => name.endsWith(".json")).map((name) => name.replace(/\.json$/, ""));
+}
+function resolveProfile(cwd, explicitProfile) {
+  if (explicitProfile) {
+    return explicitProfile;
+  }
+  const linkPath = projectLinkPath(cwd);
+  if (fs.existsSync(linkPath)) {
+    const link = JSON.parse(fs.readFileSync(linkPath, "utf8"));
+    return link.profile;
+  }
+  return DEFAULT_PROFILE;
+}
+function saveProjectLink(cwd, profile) {
+  const linkPath = projectLinkPath(cwd);
+  const link = { profile };
+  fs.writeFileSync(linkPath, `${JSON.stringify(link, null, 2)}
+`);
+}
+function buildDbUrl(config, kind) {
+  const { tenantId, password: password2, host, pushPort, typesPort, database } = config.database;
+  const port = kind === "push" ? pushPort : typesPort;
+  const encodedPassword = encodeURIComponent(password2);
+  return `postgresql://postgres.${tenantId}:${encodedPassword}@${host}:${port}/${database}`;
+}
+function maskSecret(value) {
+  if (value.length <= 4) {
+    return "****";
+  }
+  return `${value.slice(0, 2)}${"*".repeat(Math.min(value.length - 4, 12))}${value.slice(-2)}`;
+}
+function formatConfigSummary(config) {
+  const targetLabel = config.target === "local" ? "Local (Docker / filesystem)" : "Remote (SSH)";
+  const lines = [
+    `Profile: ${config.profile}`,
+    `Target: ${targetLabel}`
+  ];
+  if (config.target === "ssh") {
+    lines.push(
+      `SSH: ${config.ssh.user}@${config.ssh.host}`,
+      `SSH password: ${maskSecret(config.ssh.password)}`
+    );
+  }
+  lines.push(
+    `Local functions: ${config.functions.localPath}`,
+    `Functions destination: ${config.functions.remotePath}`,
+    `DB tenant: postgres.${config.database.tenantId}`,
+    `DB password: ${maskSecret(config.database.password)}`,
+    `DB push port: ${config.database.pushPort}`,
+    `DB types port: ${config.database.typesPort}`,
+    `Restart after deploy: ${config.deploy.restartAfterDeploy ? "yes" : "no"}`,
+    `Restart command: ${config.deploy.restartCommand || "(not set)"}`
+  );
+  return lines.join("\n");
+}
+
+// src/lib/ui.ts
+import os2 from "os";
+import process2 from "process";
+var VERSION = "0.1.1";
+var BRAND_NAME = "Velocilabs";
+var BRAND_URL = "https://velocilabs.com";
+var SPYKE_URL = "https://spyke.social";
+var TAGLINE = "Deploy, migrate, and sync self-hosted Supabase.";
+var REPO_URL = "https://github.com/spykesocial/supabase-selfhosted-cli";
+var ESC = "\x1B";
+var colors = {
+  green: `${ESC}[0;32m`,
+  blue: `${ESC}[1;34m`,
+  cyan: `${ESC}[0;36m`,
+  yellow: `${ESC}[0;33m`,
+  purple: `${ESC}[0;35m`,
+  red: `${ESC}[0;31m`,
+  gray: `${ESC}[0;90m`,
+  nc: `${ESC}[0m`
+};
+var VELOCILABS_PURPLE_RGB = "219;156;253";
+var icons = {
+  success: "\u2713",
+  error: "\u263B",
+  warning: "\u25CE",
+  arrow: "\u27A4",
+  list: "\u2022",
+  dryRun: "\u2192",
+  review: "\u261E",
+  info: "\u2139"
+};
+function isColorEnabled() {
+  if (process2.env.NO_COLOR) {
+    return false;
+  }
+  return Boolean(process2.stdout.isTTY);
+}
+function hideCursor() {
+  if (process2.stderr.isTTY) {
+    process2.stderr.write("\x1B[?25l");
+  }
+}
+function showCursor() {
+  if (process2.stderr.isTTY) {
+    process2.stderr.write("\x1B[?25h");
+  }
+}
+function paint(text, color) {
+  if (!isColorEnabled()) {
+    return text;
+  }
+  return `${colors[color]}${text}${colors.nc}`;
+}
+function paintBrand(text) {
+  if (!isColorEnabled()) {
+    return text;
+  }
+  const depth = process2.stdout.getColorDepth?.() ?? 4;
+  if (depth >= 8) {
+    return `${ESC}[38;2;${VELOCILABS_PURPLE_RGB}m${text}${colors.nc}`;
+  }
+  return paint(text, "purple");
+}
+var LIGHTNING_MARK = [
+  "  \u2588\u2588\u2588\u2588\u2588\u2588\u2580",
+  "  \u2588\u2588\u2588\u2588\u2588",
+  " \u2588\u2588\u2588\u2588\u2580",
+  "\u2584\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2580",
+  "\u2580\u2580\u2580\u2588\u2588\u2588\u2580",
+  "  \u2584\u2588\u2588\u2580",
+  "  \u2588\u2580",
+  " \u2580"
+];
+var WORDMARK = [
+  "__     __   _            _ _       _         ",
+  "\\ \\   / /__| | ___   ___(_) | __ _| |__  ___ ",
+  " \\ \\ / / _ \\ |/ _ \\ / __| | |/ _` | '_ \\/ __|",
+  "  \\ V /  __/ | (_) | (__| | | (_| | |_) \\__ \\",
+  "   \\_/ \\___|_|\\___/ \\___|_|_|\\__,_|_.__/|___/"
+];
+function combineLockupLines(markLines, textLines, gap = 2, textOffset = 0) {
+  const markWidth = Math.max(...markLines.map((line) => line.length));
+  const rows = Math.max(markLines.length, textLines.length + textOffset);
+  const combined = [];
+  for (let index = 0; index < rows; index += 1) {
+    const mark = markLines[index] ?? "";
+    const textIndex = index - textOffset;
+    const text = textIndex >= 0 && textIndex < textLines.length ? textLines[textIndex] : "";
+    combined.push(`${mark.padEnd(markWidth + gap)}${text}`.trimEnd());
+  }
+  return combined;
+}
+function showBrandBanner() {
+  const useColor = isColorEnabled();
+  const brand = (text) => useColor ? paintBrand(text) : text;
+  const link = (text) => useColor ? paint(text, "blue") : text;
+  const meta = (text) => useColor ? paint(text, "gray") : text;
+  const textOffset = Math.floor((LIGHTNING_MARK.length - WORDMARK.length) / 2);
+  const lockup = combineLockupLines(LIGHTNING_MARK, WORDMARK, 2, textOffset);
+  return [
+    ...lockup.map((line) => brand(line)),
+    link(REPO_URL),
+    `${link(BRAND_URL)}  ${meta("\xB7")}  ${link(SPYKE_URL)}  ${meta(`\xB7  ${TAGLINE}`)}`,
+    ""
+  ].join("\n");
+}
+function showMenuOption(number2, label, description, selected) {
+  const text = `${label.padEnd(12)} ${description}`;
+  if (selected) {
+    return `${paintBrand(`${icons.arrow} ${number2}. ${text}`)}`;
+  }
+  return `  ${number2}. ${text}`;
+}
+function logInfo(message) {
+  console.log(paint(message, "blue"));
+}
+function logSuccess(message) {
+  console.log(`  ${paintBrand(icons.success)} ${message}`);
+}
+function logWarning(message) {
+  console.log(paint(message, "yellow"));
+}
+function logError(message) {
+  console.error(`${paint(icons.error, "yellow")} ${message}`);
+}
+function logReview(message) {
+  console.log(`${icons.review} ${message}`);
+}
+function printSummaryBlock(heading, ...details) {
+  const width = Math.min(process2.stdout.columns ?? 70, 70);
+  const divider = "=".repeat(width);
+  console.log("");
+  console.log(divider);
+  console.log(paint(heading, "blue"));
+  for (const detail of details) {
+    if (detail) {
+      console.log(formatStyledConfigSummary([detail]));
+    }
+  }
+  console.log(divider);
+  console.log("");
+}
+function formatVersion() {
+  const profiles = listProfiles();
+  return [
+    "",
+    `${paintBrand(BRAND_NAME)} ${paint("supabase-selfhosted-cli", "gray")} ${VERSION}`,
+    paint(BRAND_URL, "blue"),
+    `Node: ${process2.version}`,
+    `Platform: ${process2.platform} ${os2.arch()}`,
+    `Config: ${CONFIG_DIR}`,
+    `Profiles: ${profiles.length > 0 ? profiles.join(", ") : "(none)"}`,
+    `Shell: ${process2.env.SHELL ?? "unknown"}`,
+    ""
+  ].join("\n");
+}
+function showVersion() {
+  console.log(formatVersion());
+}
+var COMMAND_ENTRIES = [
+  { command: "supabase-selfhosted-cli", description: "Main menu" },
+  { command: "setup", description: "Interactive setup wizard" },
+  { command: "settings", description: "View, update, or delete stored credentials" },
+  { command: "functions deploy", description: "Deploy local supabase/functions" },
+  { command: "db push", description: "Push local migrations with supabase db push" },
+  { command: "gen types", description: "Generate TypeScript types from remote DB" }
+];
+var EXAMPLE_ENTRIES = [
+  { command: "setup -p staging", description: "Create a named profile" },
+  { command: "functions deploy --prune", description: "Deploy and remove remote-only files" },
+  { command: "functions deploy --no-restart", description: "Deploy without restarting runtime" },
+  { command: "db push --debug", description: "Push migrations with supabase debug logs" },
+  { command: "gen types -o src/types/database.ts", description: "Write types to a custom path" }
+];
+function formatHelpSection(title, entries) {
+  const lines = [paint(title, "blue")];
+  for (const entry of entries) {
+    const command = entry.command.padEnd(28);
+    lines.push(`  ${paintBrand(command)} ${entry.description}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function formatHelp() {
+  return [
+    showBrandBanner(),
+    formatHelpSection("COMMANDS", COMMAND_ENTRIES),
+    formatHelpSection("EXAMPLES", EXAMPLE_ENTRIES),
+    paint("OPTIONS", "blue"),
+    `  ${paintBrand("-p, --profile <name>".padEnd(28))} Use a stored profile`,
+    `  ${paintBrand("-h, --help".padEnd(28))} Show this help message`,
+    `  ${paintBrand("-V, --version".padEnd(28))} Show version information`,
+    ""
+  ].join("\n");
+}
+function showHelp() {
+  console.log(formatHelp());
+}
+var InlineSpinner = class {
+  constructor(message) {
+    this.message = message;
+  }
+  message;
+  timer = null;
+  frame = 0;
+  frames = "|/-\\";
+  start() {
+    if (!process2.stderr.isTTY) {
+      console.error(this.message);
+      return;
+    }
+    this.stop();
+    this.frame = 0;
+    this.timer = setInterval(() => {
+      const char = this.frames[this.frame % this.frames.length];
+      this.frame += 1;
+      process2.stderr.write(
+        `\r${paintBrand(char)} ${truncateMessage(this.message)}`
+      );
+    }, 80);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (process2.stderr.isTTY) {
+      process2.stderr.write("\r\x1B[2K");
+    }
+  }
+};
+async function withSpinner(message, task) {
+  const spinner = new InlineSpinner(message);
+  spinner.start();
+  try {
+    return await task();
+  } finally {
+    spinner.stop();
+  }
+}
+function truncateMessage(message, reserve = 8) {
+  const cols = process2.stderr.columns ?? 80;
+  const available = Math.max(cols - reserve, 20);
+  const normalized = message.replace(/[\r\n]+/g, " ");
+  if (normalized.length <= available) {
+    return normalized;
+  }
+  return `${normalized.slice(0, available - 3)}...`;
+}
+function formatStyledConfigSummary(lines) {
+  return lines.map((line) => {
+    const separator = line.indexOf(":");
+    if (separator === -1) {
+      return line;
+    }
+    const label = line.slice(0, separator + 1);
+    const value = line.slice(separator + 1);
+    return `${paint(label, "gray")}${value}`;
+  }).join("\n");
+}
+
+// src/lib/require-config.ts
+async function requireConfig(profile) {
+  const cwd = process.cwd();
+  const resolvedProfile = resolveProfile(cwd, profile);
+  const config = loadConfig(resolvedProfile);
+  if (!config) {
+    logError(
+      `No profile "${resolvedProfile}" found. Run \`supabase-selfhosted-cli setup\` first.`
+    );
+    process.exitCode = 1;
+    return null;
+  }
+  return config;
+}
+
+// src/lib/supabase-runner.ts
+import { spawnSync } from "child_process";
+import fs2 from "fs";
+import path2 from "path";
+function runSupabase(args, options) {
+  const localBin = path2.join(process.cwd(), "node_modules", ".bin", "supabase");
+  const useNpx = !fs2.existsSync(localBin);
+  const command = useNpx ? "npx" : localBin;
+  const finalArgs = useNpx ? ["supabase", ...args] : args;
+  if (options?.outputFile) {
+    const result2 = spawnSync(command, finalArgs, {
+      cwd: options.cwd ?? process.cwd(),
+      encoding: "utf8",
+      shell: false
+    });
+    if (result2.error) {
+      throw result2.error;
+    }
+    if ((result2.status ?? 1) !== 0) {
+      throw new Error(result2.stderr || result2.stdout || "supabase command failed");
+    }
+    fs2.writeFileSync(options.outputFile, result2.stdout);
+    return;
+  }
+  const result = spawnSync(command, finalArgs, {
+    cwd: options?.cwd ?? process.cwd(),
+    stdio: "inherit",
+    shell: false
+  });
+  if (result.error) {
+    throw result.error;
+  }
+  if ((result.status ?? 1) !== 0) {
+    throw new Error("supabase command failed");
+  }
+}
+async function pushDatabaseMigrations(dbUrl, options) {
+  const args = ["db", "push", "--db-url", dbUrl, "--yes"];
+  if (options?.debug) {
+    args.push("--debug");
+  }
+  await withSpinner("Running supabase db push...", async () => {
+    runSupabase(args, { cwd: options?.cwd });
+  });
+}
+async function generateTypeScriptTypes(dbUrl, outputFile, options) {
+  const args = [
+    "gen",
+    "types",
+    "typescript",
+    "--db-url",
+    dbUrl,
+    "--schema",
+    options?.schema ?? "public"
+  ];
+  if (options?.debug) {
+    args.push("--debug");
+  }
+  await withSpinner(`Generating TypeScript types -> ${outputFile}`, async () => {
+    runSupabase(args, { cwd: options?.cwd, outputFile });
+  });
+  logSuccess(`Wrote ${outputFile}`);
+}
+
+// src/commands/db-push.ts
+async function runDbPush(options) {
+  const config = await requireConfig(options?.profile);
+  if (!config) {
+    return;
+  }
+  const dbUrl = buildDbUrl(config, "push");
+  await pushDatabaseMigrations(dbUrl, { debug: options?.debug, cwd: process.cwd() });
+}
+
+// src/commands/functions-deploy.ts
+import { confirm } from "@inquirer/prompts";
+
+// src/lib/deploy-options.ts
+function resolveShouldRestart(config, options) {
+  if (options?.restart === true) {
+    return true;
+  }
+  if (options?.restart === false) {
+    return false;
+  }
+  return config.deploy.restartAfterDeploy ? "prompt-default-yes" : "prompt-default-no";
+}
+
+// src/lib/local-deploy.ts
+import fs4 from "fs";
+import path4 from "path";
+import { execSync } from "child_process";
+
+// src/lib/function-sync.ts
+import fs3 from "fs";
+import path3 from "path";
+function listLocalEntries(localDir) {
+  return fs3.readdirSync(localDir, { withFileTypes: true }).map((entry) => ({
+    name: entry.name,
+    isDirectory: entry.isDirectory()
+  }));
+}
+function joinRemotePath(remoteDir, name) {
+  return `${remoteDir}/${name}`.replace(/\\/g, "/");
+}
+
+// src/lib/local-deploy.ts
+function copyDirectory(localDir, targetDir, onFile, baseDir = localDir) {
+  fs4.mkdirSync(targetDir, { recursive: true });
+  for (const entry of fs4.readdirSync(localDir, { withFileTypes: true })) {
+    const localPath = path4.join(localDir, entry.name);
+    const destPath = path4.join(targetDir, entry.name);
+    if (entry.isDirectory()) {
+      copyDirectory(localPath, destPath, onFile, baseDir);
+      continue;
+    }
+    if (entry.isFile()) {
+      onFile?.(path4.relative(baseDir, localPath).replace(/\\/g, "/"));
+      fs4.copyFileSync(localPath, destPath);
+    }
+  }
+}
+function pruneLocalDirectory(localDir, targetDir, targetRoot, onPrune) {
+  if (!fs4.existsSync(targetDir)) {
+    return 0;
+  }
+  const localEntries = listLocalEntries(localDir);
+  const targetEntries = fs4.readdirSync(targetDir, { withFileTypes: true });
+  const localByName = new Map(localEntries.map((entry) => [entry.name, entry]));
+  let pruned = 0;
+  for (const targetEntry of targetEntries) {
+    const localEntry = localByName.get(targetEntry.name);
+    const localPath = path4.join(localDir, targetEntry.name);
+    const entryPath = joinRemotePath(targetDir, targetEntry.name);
+    if (!localEntry) {
+      fs4.rmSync(entryPath, { recursive: true, force: true });
+      onPrune?.(entryPath.slice(targetRoot.length + 1));
+      pruned += 1;
+      continue;
+    }
+    if (targetEntry.isDirectory() && localEntry.isDirectory) {
+      pruned += pruneLocalDirectory(localPath, entryPath, targetRoot, onPrune);
+    }
+  }
+  return pruned;
+}
+async function deployFunctionsLocal(config, localFunctionsPath, options) {
+  const targetPath = path4.resolve(config.functions.remotePath);
+  logInfo(`Copying ${localFunctionsPath} -> ${targetPath}`);
+  if (options?.prune) {
+    const removed = pruneLocalDirectory(
+      localFunctionsPath,
+      targetPath,
+      targetPath,
+      (relativePath) => {
+        logInfo(`Pruned destination-only path: ${relativePath}`);
+      }
+    );
+    if (removed > 0) {
+      logSuccess(`Pruned ${removed} destination-only path(s).`);
+    }
+  }
+  let uploaded = 0;
+  await withSpinner("Copying function files...", async () => {
+    copyDirectory(localFunctionsPath, targetPath, () => {
+      uploaded += 1;
+    });
+  });
+  logSuccess(`Functions copied successfully (${uploaded} file(s)).`);
+}
+async function restartLocal(config) {
+  const command = config.deploy.restartCommand.trim();
+  if (!command) {
+    throw new Error(
+      "Restart command is not configured. Run `supabase-selfhosted-cli setup` to set it."
+    );
+  }
+  logInfo(`Running restart command: ${command}`);
+  try {
+    await withSpinner("Restarting Supabase runtime...", async () => {
+      execSync(command, { stdio: "inherit", shell: "/bin/sh" });
+    });
+  } catch {
+    throw new Error("Restart command failed");
+  }
+  logSuccess("Restart completed.");
+}
+
+// src/lib/paths.ts
+import fs5 from "fs";
+import path5 from "path";
+function resolveLocalFunctionsPath(cwd, configuredPath) {
+  const resolved = path5.isAbsolute(configuredPath) ? configuredPath : path5.resolve(cwd, configuredPath);
+  if (!fs5.existsSync(resolved)) {
+    throw new Error(`Local functions path does not exist: ${resolved}`);
+  }
+  return resolved;
+}
+function findSupabaseProjectRoot(startDir) {
+  let current = startDir;
+  while (true) {
+    const candidate = path5.join(current, "supabase", "functions");
+    if (fs5.existsSync(candidate)) {
+      return current;
+    }
+    const parent = path5.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+
+// src/lib/ssh.ts
+import fs6 from "fs";
+import path6 from "path";
+import { Client } from "ssh2";
+import SftpClient from "ssh2-sftp-client";
+function withSshClient(credentials, run) {
+  return new Promise((resolve, reject) => {
+    const client = new Client();
+    client.on("ready", () => {
+      run(client).then(resolve).catch(reject).finally(() => client.end());
+    }).on("error", reject).connect({
+      host: credentials.host,
+      port: 22,
+      username: credentials.user,
+      password: credentials.password,
+      readyTimeout: 2e4
+    });
+  });
+}
+async function runRemoteCommand(credentials, command) {
+  return withSshClient(
+    credentials,
+    (client) => new Promise((resolve, reject) => {
+      client.exec(command, (error, stream) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        let stdout = "";
+        let stderr = "";
+        stream.on("close", (code) => {
+          resolve({ stdout, stderr, code: code ?? 1 });
+        }).on("data", (data) => {
+          stdout += data.toString();
+          process.stdout.write(data);
+        });
+        stream.stderr.on("data", (data) => {
+          stderr += data.toString();
+          process.stderr.write(data);
+        });
+      });
+    })
+  );
+}
+async function uploadDirectory(sftp, localDir, remoteDir, onFile, baseDir = localDir) {
+  await sftp.mkdir(remoteDir, true);
+  for (const entry of fs6.readdirSync(localDir, { withFileTypes: true })) {
+    const localPath = path6.join(localDir, entry.name);
+    const remotePath = `${remoteDir}/${entry.name}`.replace(/\\/g, "/");
+    if (entry.isDirectory()) {
+      await uploadDirectory(sftp, localPath, remotePath, onFile, baseDir);
+      continue;
+    }
+    if (entry.isFile()) {
+      onFile?.(path6.relative(baseDir, localPath).replace(/\\/g, "/"));
+      await sftp.fastPut(localPath, remotePath);
+    }
+  }
+}
+async function pruneDirectory(sftp, localDir, remoteDir, remoteRoot, onPrune) {
+  const localEntries = listLocalEntries(localDir);
+  let remoteEntries;
+  try {
+    remoteEntries = await sftp.list(remoteDir);
+  } catch {
+    return 0;
+  }
+  const localByName = new Map(localEntries.map((entry) => [entry.name, entry]));
+  let pruned = 0;
+  for (const remoteEntry of remoteEntries) {
+    const localEntry = localByName.get(remoteEntry.name);
+    const localPath = path6.join(localDir, remoteEntry.name);
+    const remotePath = joinRemotePath(remoteDir, remoteEntry.name);
+    if (!localEntry) {
+      if (remoteEntry.type === "d") {
+        await sftp.rmdir(remotePath, true);
+      } else {
+        await sftp.delete(remotePath);
+      }
+      onPrune?.(remotePath.slice(remoteRoot.length + 1));
+      pruned += 1;
+      continue;
+    }
+    if (remoteEntry.type === "d" && localEntry.isDirectory) {
+      pruned += await pruneDirectory(sftp, localPath, remotePath, remoteRoot, onPrune);
+    }
+  }
+  return pruned;
+}
+async function deployFunctionsDirectory(config, localFunctionsPath, options) {
+  const sftp = new SftpClient();
+  try {
+    await sftp.connect({
+      host: config.ssh.host,
+      port: 22,
+      username: config.ssh.user,
+      password: config.ssh.password,
+      readyTimeout: 2e4
+    });
+    logInfo(
+      `Uploading ${localFunctionsPath} -> ${config.ssh.user}@${config.ssh.host}:${config.functions.remotePath}`
+    );
+    if (options?.prune) {
+      const removed = await pruneDirectory(
+        sftp,
+        localFunctionsPath,
+        config.functions.remotePath,
+        config.functions.remotePath,
+        (relativePath) => {
+          logInfo(`Pruned remote-only path: ${relativePath}`);
+        }
+      );
+      if (removed > 0) {
+        logSuccess(`Pruned ${removed} remote-only path(s).`);
+      }
+    }
+    let uploaded = 0;
+    await withSpinner("Uploading function files...", async () => {
+      await uploadDirectory(sftp, localFunctionsPath, config.functions.remotePath, () => {
+        uploaded += 1;
+      });
+    });
+    logSuccess(`Functions uploaded successfully (${uploaded} file(s)).`);
+  } finally {
+    await sftp.end();
+  }
+}
+async function restartSupabaseInstance(config) {
+  const command = config.deploy.restartCommand.trim();
+  if (!command) {
+    throw new Error(
+      "Restart command is not configured. Run `supabase-selfhosted-cli setup` to set it."
+    );
+  }
+  logInfo(`Running restart command: ${command}`);
+  const result = await withSpinner(
+    "Restarting Supabase runtime...",
+    async () => runRemoteCommand(config.ssh, command)
+  );
+  if (result.code !== 0) {
+    throw new Error(`Restart command failed with exit code ${result.code}`);
+  }
+  logSuccess("Restart completed.");
+}
+
+// src/commands/functions-deploy.ts
+async function runFunctionsDeploy(options) {
+  const config = await requireConfig(options?.profile);
+  if (!config) {
+    return;
+  }
+  const localPath = resolveLocalFunctionsPath(process.cwd(), config.functions.localPath);
+  if (config.target === "local") {
+    await deployFunctionsLocal(config, localPath, { prune: options?.prune });
+  } else {
+    await deployFunctionsDirectory(config, localPath, { prune: options?.prune });
+  }
+  const restartDecision = resolveShouldRestart(config, options);
+  let shouldRestart = false;
+  if (restartDecision === true) {
+    shouldRestart = true;
+  } else if (restartDecision === false) {
+    shouldRestart = false;
+  } else {
+    shouldRestart = await confirm({
+      message: "Restart Supabase instance now?",
+      default: restartDecision === "prompt-default-yes"
+    });
+  }
+  if (shouldRestart) {
+    if (config.target === "local") {
+      await restartLocal(config);
+    } else {
+      await restartSupabaseInstance(config);
+    }
+  } else {
+    logWarning("Skipped restart.");
+  }
+}
+
+// src/commands/gen-types.ts
+import path7 from "path";
+async function runGenTypes(options) {
+  const config = await requireConfig(options?.profile);
+  if (!config) {
+    return;
+  }
+  const outputFile = path7.resolve(
+    process.cwd(),
+    options?.output ?? "database.types.ts"
+  );
+  const dbUrl = buildDbUrl(config, "types");
+  await generateTypeScriptTypes(dbUrl, outputFile, {
+    debug: options?.debug,
+    cwd: process.cwd(),
+    schema: options?.schema
+  });
+}
+
+// src/commands/settings.ts
+import { confirm as confirm3, select as select2 } from "@inquirer/prompts";
+
+// src/commands/setup.ts
+import path8 from "path";
+import {
+  confirm as confirm2,
+  input,
+  number,
+  password,
+  select
+} from "@inquirer/prompts";
+async function promptSecretWithRetention(options) {
+  if (options.existing) {
+    const keepExisting = await confirm2({
+      message: `Keep existing ${options.label}?`,
+      default: true
+    });
+    if (keepExisting) {
+      return options.existing;
+    }
+  }
+  return password({
+    message: options.label,
+    mask: "*",
+    validate: (value) => value ? true : "Password is required"
+  });
+}
+var LOCAL_RESTART_DEFAULT = "docker ps --format '{{.Names}}' | grep -i edge | head -n 1 | xargs -I{} docker restart {}";
+var REMOTE_RESTART_DEFAULT = "docker ps --format '{{.Names}}' | grep -i edge | head -n 1 | xargs -I{} docker restart {}";
+async function runSetup(options) {
+  const cwd = process.cwd();
+  const profile = options?.profile ?? DEFAULT_PROFILE;
+  const existing = loadConfig(profile);
+  if (existing && !options?.forceUpdate) {
+    const overwrite = await confirm2({
+      message: `Profile "${profile}" already exists. Overwrite it?`,
+      default: false
+    });
+    if (!overwrite) {
+      logWarning("Setup cancelled.");
+      return existing;
+    }
+  }
+  console.log(showBrandBanner());
+  logInfo("These settings are stored locally in ~/.supabase-selfhosted-cli/");
+  console.log("");
+  const target = await select({
+    message: "Where is your Supabase instance running?",
+    choices: [
+      {
+        name: "Local machine (Docker / Docker Compose on this computer)",
+        value: "local"
+      },
+      {
+        name: "Remote server (VPS, cloud VM, etc. over SSH)",
+        value: "ssh"
+      }
+    ],
+    default: existing?.target ?? "ssh"
+  });
+  let sshUser = existing?.ssh.user ?? "root";
+  let sshHost = existing?.ssh.host ?? "";
+  let sshPassword = existing?.ssh.password ?? "";
+  if (target === "ssh") {
+    sshUser = await input({
+      message: "SSH user",
+      default: sshUser
+    });
+    sshHost = await input({
+      message: "Server IP address or hostname",
+      default: sshHost,
+      validate: (value) => value.trim() ? true : "Host is required"
+    });
+    sshPassword = await promptSecretWithRetention({
+      label: "SSH password (stored locally on this machine)",
+      existing: existing?.ssh.password
+    });
+  }
+  const functionsPathPrompt = target === "local" ? "Edge functions volume path on this machine (absolute path to Docker volume mount)" : "Remote edge functions path on the server";
+  const defaultFunctionsPath = existing?.functions.remotePath ?? (target === "local" ? path8.resolve(cwd, "volumes/functions") : "/etc/supabase/volumes/functions");
+  const functionsDestinationPath = await input({
+    message: functionsPathPrompt,
+    default: defaultFunctionsPath,
+    validate: (value) => value.trim() ? true : "Functions path is required"
+  });
+  const projectRoot = findSupabaseProjectRoot(cwd);
+  const defaultLocalPath = projectRoot ? "supabase/functions" : existing?.functions.localPath ?? "supabase/functions";
+  const localFunctionsPath = await input({
+    message: "Local functions folder (relative to project root or absolute)",
+    default: defaultLocalPath,
+    validate: (value) => value.trim() ? true : "Local path is required"
+  });
+  logInfo("Database connection (for migrations and type generation)");
+  console.log("");
+  const tenantId = await input({
+    message: "Postgres tenant id (the part after postgres.)",
+    default: existing?.database.tenantId ?? "your-tenant-id",
+    validate: (value) => value.trim() ? true : "Tenant id is required"
+  });
+  const dbPassword = await promptSecretWithRetention({
+    label: "Database password",
+    existing: existing?.database.password
+  });
+  const defaultDbHost = target === "local" ? "127.0.0.1" : existing?.database.host ?? sshHost.trim();
+  const dbHost = await input({
+    message: "Database host",
+    default: defaultDbHost,
+    validate: (value) => value.trim() ? true : "Database host is required"
+  });
+  const defaultPushPort = target === "local" ? 5432 : existing?.database.pushPort ?? 5453;
+  const defaultTypesPort = target === "local" ? 5432 : existing?.database.typesPort ?? 6438;
+  const pushPort = await number({
+    message: "Database port for migrations (supabase db push)",
+    default: defaultPushPort,
+    min: 1,
+    max: 65535
+  });
+  const typesPort = await number({
+    message: "Database port for type generation (supabase gen types)",
+    default: defaultTypesPort,
+    min: 1,
+    max: 65535
+  });
+  logInfo("Deploy options");
+  console.log("");
+  const restartAfterDeploy = await confirm2({
+    message: "Restart Supabase after deploying functions by default?",
+    default: existing?.deploy.restartAfterDeploy ?? true
+  });
+  let restartCommand = existing?.deploy.restartCommand ?? "";
+  if (restartAfterDeploy) {
+    const restartPrompt = target === "local" ? "Restart command to run locally after deploy" : "Restart command to run over SSH after deploy";
+    restartCommand = await input({
+      message: restartPrompt,
+      default: restartCommand || (target === "local" ? LOCAL_RESTART_DEFAULT : REMOTE_RESTART_DEFAULT),
+      validate: (value) => value.trim() ? true : "Restart command is required"
+    });
+  }
+  const linkProject = options?.linkProject ?? await confirm2({
+    message: "Link this project directory to this profile (.supabase-selfhosted-cli.json)?",
+    default: true
+  });
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const config = {
+    profile,
+    target,
+    ssh: {
+      user: sshUser.trim(),
+      host: sshHost.trim(),
+      password: sshPassword
+    },
+    functions: {
+      localPath: localFunctionsPath.trim(),
+      remotePath: functionsDestinationPath.trim()
+    },
+    database: {
+      tenantId: tenantId.trim(),
+      password: dbPassword,
+      host: dbHost.trim(),
+      pushPort: pushPort ?? defaultPushPort,
+      typesPort: typesPort ?? defaultTypesPort,
+      database: "postgres"
+    },
+    deploy: {
+      restartAfterDeploy,
+      restartCommand: restartCommand.trim()
+    },
+    createdAt: existing?.createdAt ?? now,
+    updatedAt: now
+  };
+  saveConfig(config);
+  if (linkProject) {
+    saveProjectLink(cwd, profile);
+    logSuccess(`Linked ${cwd} to profile "${profile}".`);
+  }
+  printSummaryBlock("Setup complete", ...formatConfigSummary(config).split("\n"));
+  return config;
+}
+
+// src/commands/settings.ts
+async function runSettings(options) {
+  const cwd = process.cwd();
+  const profile = resolveProfile(cwd, options?.profile);
+  const config = loadConfig(profile);
+  if (!config) {
+    logError(
+      `No profile "${profile}" found. Run \`supabase-selfhosted-cli setup\` first.`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const action = await select2({
+    message: "Settings",
+    choices: [
+      { name: "Show current configuration", value: "show" },
+      { name: "Re-run setup wizard (update credentials)", value: "setup" },
+      { name: "Delete stored credentials for this profile", value: "delete" },
+      { name: "Cancel", value: "cancel" }
+    ]
+  });
+  if (action === "cancel") {
+    return;
+  }
+  if (action === "show") {
+    printSummaryBlock("Current configuration", ...formatConfigSummary(config).split("\n"));
+    return;
+  }
+  if (action === "setup") {
+    await runSetup({ profile, linkProject: true, forceUpdate: true });
+    return;
+  }
+  if (action === "delete") {
+    const profiles = listProfiles();
+    const confirmed = await confirm3({
+      message: `Delete profile "${profile}" and remove stored passwords?`,
+      default: false
+    });
+    if (!confirmed) {
+      logWarning("Cancelled.");
+      return;
+    }
+    deleteConfig(profile);
+    logSuccess(`Deleted profile "${profile}".`);
+    if (profiles.length === 1) {
+      logReview("No profiles remain. Run `supabase-selfhosted-cli setup` to configure again.");
+    }
+  }
+}
+
+// src/lib/menu.ts
+import readline from "readline";
+import process3 from "process";
+var MENU_ITEMS = [
+  {
+    label: "Setup",
+    description: "Configure SSH/local credentials",
+    run: async () => {
+      await runSetup({ profile: "default", linkProject: true });
+    }
+  },
+  {
+    label: "Deploy",
+    description: "Push edge functions to your instance",
+    run: async () => {
+      await runFunctionsDeploy();
+    }
+  },
+  {
+    label: "DB Push",
+    description: "Run supabase db push",
+    run: async () => {
+      await runDbPush();
+    }
+  },
+  {
+    label: "Gen Types",
+    description: "Generate TypeScript types",
+    run: async () => {
+      await runGenTypes();
+    }
+  },
+  {
+    label: "Settings",
+    description: "View or update stored profile",
+    run: async () => {
+      await runSettings();
+    }
+  }
+];
+function clearScreen() {
+  process3.stdout.write("\x1B[2J\x1B[H");
+}
+function clearLine() {
+  return "\r\x1B[2K";
+}
+function renderMenu(selected) {
+  clearScreen();
+  for (const line of showBrandBanner().split("\n")) {
+    process3.stdout.write(`${clearLine()}${line}
+`);
+  }
+  process3.stdout.write(`${clearLine()}
+`);
+  MENU_ITEMS.forEach((item, index) => {
+    const line = showMenuOption(
+      index + 1,
+      item.label,
+      item.description,
+      selected === index + 1
+    );
+    process3.stdout.write(`${clearLine()}${line}
+`);
+  });
+  if (process3.stdin.isTTY) {
+    process3.stdout.write(`${clearLine()}
+`);
+    const controls = `${colors.gray}\u2191\u2193  |  Enter  |  M More  |  V Version  |  Q Quit${colors.nc}`;
+    process3.stdout.write(`${clearLine()}${controls}
+`);
+    process3.stdout.write(`${clearLine()}
+`);
+  }
+  process3.stdout.write("\x1B[J");
+}
+async function readKey() {
+  if (!process3.stdin.isTTY) {
+    return { action: "QUIT" };
+  }
+  readline.emitKeypressEvents(process3.stdin);
+  process3.stdin.setRawMode(true);
+  process3.stdin.resume();
+  return new Promise((resolve) => {
+    const cleanup = () => {
+      process3.stdin.removeListener("keypress", onKeypress);
+      process3.stdin.setRawMode(false);
+    };
+    const onKeypress = (_str, key) => {
+      cleanup();
+      if (key.ctrl && key.name === "c") {
+        resolve({ action: "QUIT" });
+        return;
+      }
+      switch (key.name) {
+        case "up":
+        case "k":
+          resolve({ action: "UP" });
+          return;
+        case "down":
+        case "j":
+          resolve({ action: "DOWN" });
+          return;
+        case "return":
+        case "enter":
+          resolve({ action: "ENTER" });
+          return;
+        case "q":
+          resolve({ action: "QUIT" });
+          return;
+        case "m":
+          resolve({ action: "MORE" });
+          return;
+        case "v":
+          resolve({ action: "VERSION" });
+          return;
+        default:
+          if (/^[1-9]$/.test(key.sequence ?? "")) {
+            resolve({ action: "NUMBER", number: Number(key.sequence) });
+            return;
+          }
+          resolve({ action: "QUIT" });
+      }
+    };
+    process3.stdin.on("keypress", onKeypress);
+  });
+}
+function renderOverlay(content) {
+  clearScreen();
+  for (const line of content.split("\n")) {
+    process3.stdout.write(`${clearLine()}${line}
+`);
+  }
+  process3.stdout.write(`${clearLine()}
+`);
+  const controls = `${colors.gray}Esc  |  B Back  |  Enter${colors.nc}`;
+  process3.stdout.write(`${clearLine()}${controls}
+`);
+  process3.stdout.write("\x1B[J");
+}
+async function waitForBack() {
+  if (!process3.stdin.isTTY) {
+    return;
+  }
+  readline.emitKeypressEvents(process3.stdin);
+  process3.stdin.setRawMode(true);
+  process3.stdin.resume();
+  return new Promise((resolve) => {
+    const cleanup = () => {
+      process3.stdin.removeListener("keypress", onKeypress);
+      process3.stdin.setRawMode(false);
+    };
+    const onKeypress = (_str, key) => {
+      if (key.ctrl && key.name === "c") {
+        cleanup();
+        resolve();
+        return;
+      }
+      switch (key.name) {
+        case "escape":
+        case "backspace":
+        case "b":
+        case "return":
+        case "enter":
+          cleanup();
+          resolve();
+          return;
+        default:
+          break;
+      }
+    };
+    process3.stdin.on("keypress", onKeypress);
+  });
+}
+async function runMenuItem(index, leaveScreen, enterScreen) {
+  showCursor();
+  leaveScreen();
+  clearScreen();
+  await MENU_ITEMS[index].run();
+  process3.stdout.write("\n");
+  const controls = `${colors.gray}Press Enter to return to menu${colors.nc}
+`;
+  process3.stdout.write(controls);
+  await waitForBack();
+  enterScreen();
+  hideCursor();
+}
+async function runInteractiveMenu() {
+  if (!process3.stdin.isTTY || !process3.stdout.isTTY) {
+    showHelp();
+    return;
+  }
+  let usingAlternateScreen = false;
+  const enterScreen = () => {
+    if (!process3.stdout.isTTY) {
+      return;
+    }
+    process3.stdout.write("\x1B[?1049h");
+    usingAlternateScreen = true;
+    clearScreen();
+  };
+  const leaveScreen = () => {
+    if (!usingAlternateScreen || !process3.stdout.isTTY) {
+      return;
+    }
+    process3.stdout.write("\x1B[?1049l");
+    usingAlternateScreen = false;
+  };
+  let selected = 1;
+  enterScreen();
+  hideCursor();
+  const cleanup = () => {
+    showCursor();
+    leaveScreen();
+  };
+  process3.on("SIGINT", cleanup);
+  try {
+    while (true) {
+      renderMenu(selected);
+      const key = await readKey();
+      switch (key.action) {
+        case "UP":
+          if (selected > 1) {
+            selected -= 1;
+          }
+          break;
+        case "DOWN":
+          if (selected < MENU_ITEMS.length) {
+            selected += 1;
+          }
+          break;
+        case "ENTER":
+          await runMenuItem(selected - 1, leaveScreen, enterScreen);
+          break;
+        case "NUMBER":
+          if (key.number && key.number >= 1 && key.number <= MENU_ITEMS.length) {
+            await runMenuItem(key.number - 1, leaveScreen, enterScreen);
+          }
+          break;
+        case "MORE":
+          renderOverlay(formatHelp());
+          await waitForBack();
+          break;
+        case "VERSION":
+          renderOverlay(formatVersion());
+          await waitForBack();
+          break;
+        case "QUIT":
+          cleanup();
+          return;
+      }
+    }
+  } finally {
+    cleanup();
+    process3.removeListener("SIGINT", cleanup);
+  }
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("supabase-selfhosted-cli").description(
+  "CLI for self-hosted Supabase \u2014 deploy functions, push migrations, sync types (VPS, Docker, local)"
+).version(VERSION, "-V, --version", "Show version information").helpOption(false).option("-h, --help", "Show help");
+program.command("setup").description("Interactive setup \u2014 store SSH/local, database, and deploy settings").option("-p, --profile <name>", "Profile name", "default").action(async (options) => {
+  await runSetup({ profile: options.profile, linkProject: true });
+});
+program.command("settings").description("View, update, or delete stored credentials").option("-p, --profile <name>", "Profile name").action(async (options) => {
+  await runSettings(options);
+});
+var functionsCommand = program.command("functions").description("Edge function operations");
+functionsCommand.command("deploy").description("Deploy local supabase/functions to your self-hosted instance").option("-p, --profile <name>", "Profile name").option("--restart", "Restart Supabase after deploy").option("--no-restart", "Skip restart after deploy").option("--prune", "Remove destination files and folders not present locally").action(async (options) => {
+  await runFunctionsDeploy(options);
+});
+var dbCommand = program.command("db").description("Database operations");
+dbCommand.command("push").description("Push local migrations using supabase db push").option("-p, --profile <name>", "Profile name").option("--debug", "Pass --debug to supabase CLI").action(async (options) => {
+  await runDbPush(options);
+});
+var genCommand = program.command("gen").description("Code generation");
+genCommand.command("types").description("Generate TypeScript types from the remote database").option("-p, --profile <name>", "Profile name").option("-o, --output <file>", "Output file", "database.types.ts").option("--schema <name>", "Postgres schema", "public").option("--debug", "Pass --debug to supabase CLI").action(
+  async (options) => {
+    await runGenTypes(options);
+  }
+);
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    await runInteractiveMenu();
+    return;
+  }
+  if (args.includes("--help") || args.includes("-h")) {
+    showHelp();
+    return;
+  }
+  if (args.includes("--version") || args.includes("-V")) {
+    showVersion();
+    return;
+  }
+  await program.parseAsync(process.argv);
+}
+main().catch((error) => {
+  logError(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});