openship 0.4.8 → 0.5.0

package/dist/{chunk-BBHX7T4R.js → chunk-BS2AXYZX.js}

@@ -101,10 +101,10 @@ import {
 } from "./chunk-W73X43R7.js";
 import {
   CloudRuntime
-} from "./chunk-5NYUCONN.js";
+} from "./chunk-JLKKYUZA.js";
 import {
   systemCatalog
-} from "./chunk-SLTYVHU7.js";
+} from "./chunk-NXFIRK2Z.js";
 import {
   AwsCrc32,
   __awaiter,
@@ -139,10 +139,10 @@ import {
   DockerRuntime,
   isHostPathSource,
   scopedVolumeName
-} from "./chunk-SJIFLLX4.js";
+} from "./chunk-CUJXGK7R.js";
 import {
   BareRuntime
-} from "./chunk-VDMQJHPI.js";
+} from "./chunk-YWMODKWL.js";
 import {
   LocalExecutor
 } from "./chunk-TYVME3XD.js";
@@ -151,15 +151,16 @@ import {
   edgeCrashReason,
   invalidateEdgeContainer,
   sanitizeEdgeVhosts
-} from "./chunk-2D3I5G6P.js";
+} from "./chunk-6PIYRG5I.js";
 import {
   EDGE_CONTAINER_MOUNTS,
   EDGE_HOST_STATE_DIR
-} from "./chunk-VFINNTUL.js";
+} from "./chunk-EAAGSQXN.js";
 import {
   DEFAULT_IMAGE_REGISTRY,
+  isAwsS3Endpoint,
   safeErrorMessage
-} from "./chunk-6APULWSU.js";
+} from "./chunk-UMQP7SYT.js";
 
 // src/lib/edge-import.ts
 import chalk from "chalk";
@@ -691,7 +692,15 @@ var DockerBackupExecutor = class {
     await this.ensureImage(helperImage);
     const hostConfig = {
       Binds: [`${source.source}:/mnt:ro`],
-      AutoRemove: true
+      AutoRemove: true,
+      // The archive streams over `attach()` below — the daemon's default
+      // json-file driver would ALSO write every byte of it to
+      // /var/lib/docker/containers as a log. That's a second copy of the whole
+      // backup, and worse than a copy: json-file escapes binary, so a 4.6 GB
+      // volume ballooned to a 12 GB log file here. Backups then spike the
+      // host's disk by more than the data they read and only release it when
+      // the helper exits. Nothing ever reads these logs.
+      LogConfig: { Type: "none", Config: {} }
     };
     const helper = await this.dockerode.createContainer({
       Image: helperImage,
@@ -12191,7 +12200,7 @@ var S3DestinationImpl = class {
     if (!accessKeyId || !secretAccessKey) {
       throw new Error(`S3Destination "${row.name}" missing access credentials`);
     }
-    const isAws = !row.endpoint || row.endpoint.includes(".amazonaws.com") || row.endpoint === "https://s3.amazonaws.com";
+    const isAws = isAwsS3Endpoint(row.endpoint);
     this.client = new S3Client({
       endpoint: row.endpoint ?? void 0,
       region: row.region ?? "auto",
@@ -12668,11 +12677,11 @@ registerDestination("sftp", (row) => new SftpDestinationImpl(row));
 registerDestination("openship_server", (row) => new SftpDestinationImpl(row));
 
 // src/lib/compose.ts
-import { spawnSync as spawnSync3 } from "child_process";
+import { spawn as spawn2, spawnSync as spawnSync3 } from "child_process";
 import { randomBytes as randomBytes5 } from "crypto";
-import { chmodSync, existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { chmodSync, existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir2, userInfo } from "os";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 
 // src/lib/paths.ts
 import { homedir } from "os";
@@ -12682,15 +12691,185 @@ var override = process.env.OPENSHIP_HOME?.trim();
 var OS_DIR = override ? resolve2(override) : DEFAULT_HOME;
 var IS_ALT_HOME = OS_DIR !== DEFAULT_HOME;
 
+// src/lib/ports.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join as join4 } from "path";
+
+// ../../packages/core/src/ports.ts
+import { createServer } from "net";
+var DEFAULT_API_PORT = 4e3;
+var DEFAULT_DASHBOARD_PORT = 3001;
+var LOOPBACK = "127.0.0.1";
+var SCAN_SPAN = 20;
+var MAX_PORT = 65535;
+function isPortFree(port, host = LOOPBACK) {
+  return new Promise((resolve4) => {
+    const srv = createServer();
+    srv.once("error", () => resolve4(false));
+    srv.listen(port, host, () => srv.close(() => resolve4(true)));
+  });
+}
+async function waitPortFree(port, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? 6e3;
+  const intervalMs = opts.intervalMs ?? 250;
+  const host = opts.host ?? LOOPBACK;
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    if (await isPortFree(port, host)) return true;
+    if (Date.now() >= deadline) return false;
+    await new Promise((r2) => setTimeout(r2, intervalMs));
+  }
+}
+function getFreePort(host = LOOPBACK) {
+  return new Promise((resolve4, reject) => {
+    const srv = createServer();
+    srv.once("error", reject);
+    srv.listen(0, host, () => {
+      const addr = srv.address();
+      const port = addr && typeof addr === "object" ? addr.port : 0;
+      srv.close(() => port ? resolve4(port) : reject(new Error("no free port")));
+    });
+  });
+}
+async function findPortNear(from, opts = {}) {
+  const host = opts.host ?? LOOPBACK;
+  const span = opts.span ?? SCAN_SPAN;
+  const skip = opts.skip ?? (() => false);
+  for (let port2 = from; port2 <= Math.min(from + span, MAX_PORT); port2++) {
+    if (!skip(port2) && await isPortFree(port2, host)) return port2;
+  }
+  let port = await getFreePort(host);
+  for (let tries = 0; tries < 10 && skip(port); tries++) port = await getFreePort(host);
+  return port;
+}
+async function resolvePortPair(prefs = {}) {
+  const host = prefs.bindAddr?.trim() || LOOPBACK;
+  const ours = new Set(prefs.reclaimable ?? []);
+  const prefFor = (kind) => prefs[kind] ?? prefs.previous?.[kind] ?? prefs.stored?.[kind] ?? prefs.defaults?.[kind];
+  const remembered = (kind, pref) => prefs[kind] === void 0 && (prefs.previous?.[kind] === pref || prefs.stored?.[kind] === pref);
+  const availableForPref = async (port) => ours.has(port) || await isPortFree(port, host);
+  const apiPref = prefFor("api");
+  const dashPref = prefFor("dashboard");
+  let api;
+  if (apiPref === void 0) api = await getFreePort(host);
+  else if (await availableForPref(apiPref)) api = apiPref;
+  else if (remembered("api", apiPref) && await waitPortFree(apiPref, { host })) api = apiPref;
+  else {
+    api = await findPortNear(apiPref + 1, {
+      host,
+      skip: (p2) => ours.has(p2) || p2 === dashPref
+    });
+  }
+  const skipForDash = (p2) => ours.has(p2) || p2 === api;
+  let dashboard;
+  if (dashPref === void 0) {
+    dashboard = await getFreePort(host);
+    for (let tries = 0; tries < 10 && dashboard === api; tries++) {
+      dashboard = await getFreePort(host);
+    }
+  } else if (dashPref !== api && await availableForPref(dashPref)) {
+    dashboard = dashPref;
+  } else if (dashPref !== api && remembered("dashboard", dashPref) && await waitPortFree(dashPref, { host })) {
+    dashboard = dashPref;
+  } else {
+    dashboard = await findPortNear(dashPref + 1, { host, skip: skipForDash });
+  }
+  return {
+    api,
+    dashboard,
+    switched: {
+      api: apiPref !== void 0 && api !== apiPref,
+      dashboard: dashPref !== void 0 && dashboard !== dashPref
+    },
+    preferred: { api: apiPref ?? api, dashboard: dashPref ?? dashboard }
+  };
+}
+
+// src/lib/ports.ts
+var PORTS_FILE = join4(OS_DIR, "ports.json");
+var INSTANCE_FILE = join4(OS_DIR, "instance.json");
+function saveInstanceUrl(publicUrl) {
+  try {
+    if (!existsSync(OS_DIR)) mkdirSync(OS_DIR, { recursive: true, mode: 448 });
+    writeFileSync(INSTANCE_FILE, JSON.stringify({ publicUrl: publicUrl ?? null }));
+  } catch {
+  }
+}
+function readInstanceUrl() {
+  try {
+    return JSON.parse(readFileSync(INSTANCE_FILE, "utf8")).publicUrl ?? null;
+  } catch {
+    return null;
+  }
+}
+function readStoredPorts() {
+  try {
+    return JSON.parse(readFileSync(PORTS_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function storedApiPort() {
+  return readStoredPorts().api ?? DEFAULT_API_PORT;
+}
+function storedDashboardPort() {
+  return readStoredPorts().dashboard ?? DEFAULT_DASHBOARD_PORT;
+}
+function saveStoredPorts(api, dashboard) {
+  try {
+    if (!existsSync(OS_DIR)) mkdirSync(OS_DIR, { recursive: true, mode: 448 });
+    writeFileSync(PORTS_FILE, JSON.stringify({ api, dashboard }));
+  } catch {
+  }
+}
+function portMoveNotice(resolved, trustedOriginUrls = []) {
+  if (!resolved.switched.api && !resolved.switched.dashboard) return [];
+  const lines = [
+    `A preferred port was busy \u2014 using API ${resolved.api}, dashboard ${resolved.dashboard}.`
+  ];
+  const stale = [...new Set(stalePortOrigins(resolved.preferred.dashboard, trustedOriginUrls))];
+  if (stale.length) {
+    lines.push(
+      `Heads up: ${stale.join(", ")} still names port ${resolved.preferred.dashboard}, so logins`,
+      `from that origin will be rejected. Point it at :${resolved.dashboard} (or free port`,
+      `${resolved.preferred.dashboard} and re-run to move back).`
+    );
+  }
+  return lines;
+}
+function stalePortOrigins(movedFrom, urls) {
+  const stale = [];
+  for (const raw of urls) {
+    for (const candidate of (raw ?? "").split(",")) {
+      const value = candidate.trim();
+      if (!value) continue;
+      try {
+        if (new URL(value).port === String(movedFrom)) stale.push(value);
+      } catch {
+      }
+    }
+  }
+  return stale;
+}
+async function resolvePorts(prefs) {
+  const resolved = await resolvePortPair({
+    ...prefs,
+    stored: readStoredPorts(),
+    defaults: { api: DEFAULT_API_PORT, dashboard: DEFAULT_DASHBOARD_PORT }
+  });
+  saveStoredPorts(resolved.api, resolved.dashboard);
+  return resolved;
+}
+
 // src/lib/source-install.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync2, readFileSync } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { join as join6 } from "path";
 
 // src/lib/from-source.ts
 import { spawn, spawnSync } from "child_process";
-import { existsSync, mkdirSync } from "fs";
-import { join as join4, resolve as resolve3 } from "path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join5, resolve as resolve3 } from "path";
 var DEFAULT_REPO = "https://github.com/oblien/openship.git";
 function has(cmd) {
   try {
@@ -12720,7 +12899,7 @@ function shortSha(cwd) {
   return r2.status === 0 ? (r2.stdout ?? "").trim() || "unknown" : "unknown";
 }
 function isMonorepo(dir) {
-  return existsSync(join4(dir, "package.json")) && existsSync(join4(dir, "apps/api/package.json")) && existsSync(join4(dir, "apps/dashboard/package.json"));
+  return existsSync2(join5(dir, "package.json")) && existsSync2(join5(dir, "apps/api/package.json")) && existsSync2(join5(dir, "apps/dashboard/package.json"));
 }
 async function prepareFromSource(opts) {
   if (!has("bun")) {
@@ -12744,9 +12923,9 @@ async function prepareFromSource(opts) {
     }
     ref = (opts.ref || "main").trim();
     const repoUrl = opts.repo || DEFAULT_REPO;
-    sourceDir = join4(OS_DIR, "src");
-    mkdirSync(OS_DIR, { recursive: true });
-    if (!existsSync(join4(sourceDir, ".git"))) {
+    sourceDir = join5(OS_DIR, "src");
+    mkdirSync2(OS_DIR, { recursive: true });
+    if (!existsSync2(join5(sourceDir, ".git"))) {
       console.log(`  Cloning ${repoUrl} \u2192 ${sourceDir}`);
       await run("git", ["clone", repoUrl, sourceDir], OS_DIR);
     }
@@ -12761,29 +12940,29 @@ async function prepareFromSource(opts) {
   console.log(`  Source: ${sourceDir} @ ${ref} (${sha})`);
   console.log("  Installing workspace dependencies (bun install)\u2026");
   await run("bun", ["install"], sourceDir);
-  const distDir = join4(OS_DIR, "from-source-dist");
+  const distDir = join5(OS_DIR, "from-source-dist");
   console.log("  Building release dist (compiles the dashboard \u2014 needs RAM/CPU)\u2026");
   await run(
     "bun",
-    ["run", join4(sourceDir, "apps/api/scripts/build-release.ts")],
+    ["run", join5(sourceDir, "apps/api/scripts/build-release.ts")],
     sourceDir,
     { DIST_DIR: distDir, NODE_ENV: "production", CLOUD_MODE: "false", OPENSHIP_TARGET: "local" }
   );
   console.log("  Installing runtime dependencies in the dist\u2026");
   await run("bun", ["install", "--production", "--frozen-lockfile"], distDir);
-  const apiDir = join4(distDir, "api");
-  const dashboardDir = join4(distDir, "dashboard");
-  if (!existsSync(join4(apiDir, "src/index.ts"))) {
+  const apiDir = join5(distDir, "api");
+  const dashboardDir = join5(distDir, "dashboard");
+  if (!existsSync2(join5(apiDir, "src/index.ts"))) {
     throw new Error(`Build produced no API at ${apiDir}/src/index.ts \u2014 build-release layout drift?`);
   }
-  if (!existsSync(join4(dashboardDir, "apps/dashboard/server.js"))) {
+  if (!existsSync2(join5(dashboardDir, "apps/dashboard/server.js"))) {
     throw new Error(`Build produced no dashboard at ${dashboardDir}/apps/dashboard/server.js.`);
   }
   return { apiDir, dashboardDir, ref, sha, sourceDir };
 }
 
 // src/lib/source-install.ts
-var MARKER = join5(OS_DIR, "source-install.json");
+var MARKER = join6(OS_DIR, "source-install.json");
 function parseSourceInstall(raw) {
   try {
     const obj = JSON.parse(raw);
@@ -12794,9 +12973,9 @@ function parseSourceInstall(raw) {
   }
 }
 function readSourceInstall() {
-  if (!existsSync2(MARKER)) return null;
+  if (!existsSync3(MARKER)) return null;
   try {
-    return parseSourceInstall(readFileSync(MARKER, "utf8"));
+    return parseSourceInstall(readFileSync2(MARKER, "utf8"));
   } catch {
     return null;
   }
@@ -12817,7 +12996,7 @@ async function rebuildFromSource(info) {
   if (!has("git")) {
     throw new Error("`git` is required to update the source checkout but wasn't found on PATH.");
   }
-  if (!existsSync2(join5(info.dir, ".git"))) {
+  if (!existsSync3(join6(info.dir, ".git"))) {
     throw new Error(
       `Source checkout ${info.dir} is missing (no .git) \u2014 reinstall from source with scripts/install-source.sh.`
     );
@@ -12826,7 +13005,7 @@ async function rebuildFromSource(info) {
   await run("git", ["checkout", info.ref], info.dir);
   await run("git", ["pull", "--ff-only", "origin", info.ref], info.dir).catch(() => {
   });
-  const cliDir = join5(info.dir, "apps/cli");
+  const cliDir = join6(info.dir, "apps/cli");
   await run("bun", ["install"], info.dir);
   await run("bun", ["run", "build"], cliDir);
   await run("bun", ["run", "build/stage-dashboard.ts"], cliDir);
@@ -12839,11 +13018,11 @@ var EDGE_ACME_HOST_DIR = `${EDGE_HOST_STATE_DIR}/acme`;
 function edgeVolumeYaml(indent) {
   return EDGE_CONTAINER_MOUNTS.map((m2) => `${indent}- ${m2.host}:${m2.container}:z`).join("\n");
 }
-var COMPOSE_DIR = join6(OS_DIR, "compose");
-var INSTALL_METHOD_FILE = join6(OS_DIR, "install-method");
-var COMPOSE_FILE = join6(COMPOSE_DIR, "docker-compose.yml");
-var BUILD_FILE = join6(COMPOSE_DIR, "docker-compose.build.yml");
-var ENV_FILE = join6(COMPOSE_DIR, ".env");
+var COMPOSE_DIR = join7(OS_DIR, "compose");
+var INSTALL_METHOD_FILE = join7(OS_DIR, "install-method");
+var COMPOSE_FILE = join7(COMPOSE_DIR, "docker-compose.yml");
+var BUILD_FILE = join7(COMPOSE_DIR, "docker-compose.build.yml");
+var ENV_FILE = join7(COMPOSE_DIR, ".env");
 var BUILT_SERVICES = [
   { service: "api", dockerfile: "apps/api/Dockerfile" },
   { service: "dashboard", dockerfile: "apps/dashboard/Dockerfile" },
@@ -12852,21 +13031,45 @@ var BUILT_SERVICES = [
 var ENV_CONSUMING_SERVICES = ["api", "dashboard", "edge"];
 function readInstallMethod() {
   try {
-    const v2 = readFileSync2(INSTALL_METHOD_FILE, "utf8").trim();
+    const v2 = readFileSync3(INSTALL_METHOD_FILE, "utf8").trim();
     return v2 === "compose" || v2 === "bare" ? v2 : null;
   } catch {
     return null;
   }
 }
 function writeInstallMethod(method) {
-  mkdirSync2(OS_DIR, { recursive: true, mode: 448 });
-  writeFileSync(INSTALL_METHOD_FILE, method, { mode: 384 });
+  mkdirSync3(OS_DIR, { recursive: true, mode: 448 });
+  writeFileSync2(INSTALL_METHOD_FILE, method, { mode: 384 });
+}
+function dockerState() {
+  const ok = (args) => spawnSync3("docker", args, { stdio: "ignore" }).status === 0;
+  if (!ok(["--version"])) return { binary: false, plugin: false, daemon: false };
+  return { binary: true, plugin: ok(["compose", "version"]), daemon: ok(["version"]) };
+}
+function dockerGap(state = dockerState()) {
+  if (!state.binary) {
+    return { summary: "Docker isn't installed", installable: true };
+  }
+  if (!state.plugin) {
+    return {
+      summary: "Docker is installed but the Compose plugin (`docker compose`) is missing",
+      installable: true
+    };
+  }
+  if (!state.daemon) {
+    const asRoot = typeof process.getuid === "function" && process.getuid() === 0;
+    return {
+      summary: "Docker is installed but its daemon isn't reachable",
+      // Reinstalling changes nothing: a group change only applies to NEW logins,
+      // and a stopped daemon needs starting, not installing.
+      installable: false,
+      hint: asRoot ? "Start it with: systemctl start docker" : `Add your user to the docker group: sudo usermod -aG docker ${userInfo().username} \u2014 then log out and back in (or run: newgrp docker). If the daemon is stopped: sudo systemctl start docker`
+    };
+  }
+  return null;
 }
 function hasDockerCompose() {
-  const docker = spawnSync3("docker", ["version"], { stdio: "ignore" });
-  if (docker.status !== 0) return false;
-  const compose2 = spawnSync3("docker", ["compose", "version"], { stdio: "ignore" });
-  return compose2.status === 0;
+  return dockerGap() === null;
 }
 function composeIsViableDefault() {
   return process.platform === "linux" && hasDockerCompose();
@@ -12877,9 +13080,18 @@ function hasCmd(cmd) {
 function shQuote(s2) {
   return `'${s2.replace(/'/g, `'\\''`)}'`;
 }
-async function ensureDocker() {
-  if (hasDockerCompose()) return true;
+async function ensureDocker(opts = {}) {
+  const notice = opts.onNotice ?? ((line) => process.stderr.write(`  ${line}
+`));
+  const state = dockerState();
+  const gap = dockerGap(state);
+  if (!gap) return true;
   if (process.platform !== "linux") return false;
+  if (!gap.installable) {
+    notice(gap.summary + ".");
+    if (gap.hint) notice(gap.hint);
+    return false;
+  }
   const plan = systemCatalog.installs.docker({
     os: "linux",
     serviceManager: "systemd"
@@ -12887,12 +13099,36 @@ async function ensureDocker() {
   if (!plan.supported || !plan.installCommand) return false;
   const asRoot = typeof process.getuid === "function" && process.getuid() === 0;
   const sudo = !asRoot && hasCmd("sudo") ? "sudo " : "";
-  const sh = (script) => spawnSync3("sh", ["-c", sudo ? `${sudo}sh -c ${shQuote(script)}` : script], {
-    stdio: "inherit"
-  }).status ?? 1;
-  if (sh(plan.installCommand) !== 0) return false;
-  if (plan.startCommand) sh(plan.startCommand);
-  return hasDockerCompose();
+  notice("This can take 2-5 minutes on a small VPS (~150 MB of packages) and stays quiet while apt works.");
+  if (state.binary) {
+    notice("Docker's installer will warn that docker already exists and pause ~20s before continuing \u2014 that's expected.");
+  }
+  const sh = (script) => new Promise((resolve4) => {
+    const child = spawn2("sh", ["-c", sudo ? `${sudo}sh -c ${shQuote(script)}` : script], {
+      stdio: "inherit"
+    });
+    const started = Date.now();
+    const tick = setInterval(() => {
+      const s2 = Math.round((Date.now() - started) / 1e3);
+      notice(`still installing Docker \u2014 ${Math.floor(s2 / 60)}m${String(s2 % 60).padStart(2, "0")}s elapsed\u2026`);
+    }, 3e4);
+    const done = (code) => {
+      clearInterval(tick);
+      resolve4(code);
+    };
+    child.on("error", () => done(1));
+    child.on("close", (code) => done(code ?? 1));
+  });
+  if (await sh(plan.installCommand) !== 0) return false;
+  if (plan.startCommand) await sh(plan.startCommand);
+  const after = dockerGap();
+  if (!after) {
+    notice("Docker ready.");
+    return true;
+  }
+  notice(after.summary + ".");
+  if (after.hint) notice(after.hint);
+  return false;
 }
 var COMPOSE_YAML = `# Managed by \`openship up\` \u2014 do not edit; re-run \`openship up\` to regenerate.
 services:
@@ -12900,6 +13136,12 @@ services:
     image: postgres:16-alpine
     restart: unless-stopped
     environment:
+      # Keep the data dir in a subdirectory of the volume so a fresh install never
+      # runs initdb against a bare mount root (which fails on quirky host
+      # filesystems with EPERM \u2014 #350). OPENSHIP_PGDATA is decided ONCE at install
+      # by the CLI (fresh \u2192 subdir, pre-existing volume \u2192 root) and preserved in
+      # .env, so this never moves an existing database.
+      PGDATA: \${OPENSHIP_PGDATA:-/var/lib/postgresql/data/pgdata}
       POSTGRES_USER: \${POSTGRES_USER:-openship}
       POSTGRES_PASSWORD: \${POSTGRES_PASSWORD:?missing from .env \u2014 re-run openship up to regenerate it}
       POSTGRES_DB: \${POSTGRES_DB:-openship}
@@ -12995,7 +13237,7 @@ function keepSecret(existing, key) {
 function readEnvFile() {
   const out = {};
   try {
-    for (const line of readFileSync2(ENV_FILE, "utf8").split("\n")) {
+    for (const line of readFileSync3(ENV_FILE, "utf8").split("\n")) {
       const m2 = line.match(/^([A-Z0-9_]+)=(.*)$/);
       if (m2) out[m2[1]] = m2[2];
     }
@@ -13015,10 +13257,10 @@ function rewriteHostAuthorizedKeys(existing, pub) {
 function provisionHostSshChannel() {
   if (process.platform !== "linux") return null;
   try {
-    const sshDir = join6(COMPOSE_DIR, "host-ssh");
-    mkdirSync2(sshDir, { recursive: true, mode: 448 });
-    const keyPath = join6(sshDir, "id_ed25519");
-    if (!existsSync3(keyPath)) {
+    const sshDir = join7(COMPOSE_DIR, "host-ssh");
+    mkdirSync3(sshDir, { recursive: true, mode: 448 });
+    const keyPath = join7(sshDir, "id_ed25519");
+    if (!existsSync4(keyPath)) {
       const g2 = spawnSync3(
         "ssh-keygen",
         ["-t", "ed25519", "-N", "", "-q", "-f", keyPath, "-C", HOST_KEY_COMMENT],
@@ -13026,7 +13268,7 @@ function provisionHostSshChannel() {
       );
       if (g2.status !== 0) return null;
     }
-    const pub = readFileSync2(`${keyPath}.pub`, "utf8").trim();
+    const pub = readFileSync3(`${keyPath}.pub`, "utf8").trim();
     if (!pub) return null;
     const user = (() => {
       try {
@@ -13035,12 +13277,12 @@ function provisionHostSshChannel() {
         return process.env.USER || process.env.LOGNAME || "root";
       }
     })();
-    const userSshDir = join6(homedir2(), ".ssh");
-    mkdirSync2(userSshDir, { recursive: true, mode: 448 });
-    const authKeys = join6(userSshDir, "authorized_keys");
-    const existing = existsSync3(authKeys) ? readFileSync2(authKeys, "utf8") : "";
+    const userSshDir = join7(homedir2(), ".ssh");
+    mkdirSync3(userSshDir, { recursive: true, mode: 448 });
+    const authKeys = join7(userSshDir, "authorized_keys");
+    const existing = existsSync4(authKeys) ? readFileSync3(authKeys, "utf8") : "";
     const next = rewriteHostAuthorizedKeys(existing, pub);
-    if (next !== existing) writeFileSync(authKeys, next, { mode: 384 });
+    if (next !== existing) writeFileSync2(authKeys, next, { mode: 384 });
     chmodSync(authKeys, 384);
     return { user, keyPath };
   } catch {
@@ -13051,6 +13293,11 @@ function composeProjectName(prev) {
   if (prev.COMPOSE_PROJECT_NAME) return prev.COMPOSE_PROJECT_NAME;
   return Object.keys(prev).length > 0 ? "compose" : "openship";
 }
+var PGDATA_ROOT = "/var/lib/postgresql/data";
+function resolvePgData(prev) {
+  if (prev.OPENSHIP_PGDATA) return prev.OPENSHIP_PGDATA;
+  return dbVolumeExists(composeProjectName(prev)) ? PGDATA_ROOT : `${PGDATA_ROOT}/pgdata`;
+}
 function orphanedStackContainers(project) {
   const r2 = spawnSync3(
     "docker",
@@ -13150,7 +13397,7 @@ function migrateLegacyEdgeVolumes(project) {
   const existing = new Set(ls.stdout.split("\n").map((l2) => l2.trim()).filter(Boolean));
   for (const { volume, host } of pairs) {
     if (!existing.has(volume)) continue;
-    mkdirSync2(host, { recursive: true });
+    mkdirSync3(host, { recursive: true });
     const alreadyThere = spawnSync3("sh", ["-c", `ls -A ${JSON.stringify(host)} 2>/dev/null | head -1`], {
       encoding: "utf8"
     });
@@ -13202,9 +13449,11 @@ function keepConfig(prev, key, explicit) {
 }
 function resolveEnvConfig(prev, opts) {
   const publicUrl = keepConfig(prev, "OPENSHIP_PUBLIC_URL", opts.publicUrl);
+  const bindAddr = keepConfig(prev, "OPENSHIP_BIND_ADDR");
   return {
-    apiPort: keepConfig(prev, "API_PORT", opts.apiPort) ?? "4000",
-    dashPort: keepConfig(prev, "DASHBOARD_PORT", opts.dashboardPort) ?? "3001",
+    apiPort: keepConfig(prev, "API_PORT", opts.apiPort) ?? String(DEFAULT_API_PORT),
+    dashPort: keepConfig(prev, "DASHBOARD_PORT", opts.dashboardPort) ?? String(DEFAULT_DASHBOARD_PORT),
+    ...bindAddr ? { bindAddr } : {},
     ...publicUrl ? { publicUrl } : {},
     // A public URL always implies a proxy in front; otherwise keep whatever the
     // install was configured with.
@@ -13222,6 +13471,47 @@ function resolveEnvConfig(prev, opts) {
     hostControl: opts.noHostControl === void 0 ? prev.OPENSHIP_HOST_CONTROL !== "false" : !opts.noHostControl
   };
 }
+function toPort(value) {
+  const n2 = Number(value);
+  return Number.isInteger(n2) && n2 > 0 && n2 <= 65535 ? n2 : void 0;
+}
+function composeEnvPorts() {
+  const env = readEnvFile();
+  return { api: toPort(env.API_PORT), dashboard: toPort(env.DASHBOARD_PORT) };
+}
+function composeBindAddr() {
+  return readEnvFile().OPENSHIP_BIND_ADDR?.trim() || "0.0.0.0";
+}
+function composeTrustedOriginUrls() {
+  const env = readEnvFile();
+  return [env.OPENSHIP_PUBLIC_URL, env.OPENSHIP_EXTRA_TRUSTED_ORIGINS].filter(
+    (v2) => !!v2?.trim()
+  );
+}
+function composeHeldPorts() {
+  const r2 = spawnSync3(
+    "docker",
+    ["ps", "--format", '{{.Label "com.docker.compose.project.config_files"}}	{{.Ports}}'],
+    { encoding: "utf8" }
+  );
+  if (r2.status !== 0 || !r2.stdout) return [];
+  const ports = /* @__PURE__ */ new Set();
+  for (const line of r2.stdout.split("\n")) {
+    const [configFiles = "", published = ""] = line.split("	");
+    if (!configFiles.split(",").some((f2) => f2.trim() === COMPOSE_FILE)) continue;
+    for (const m2 of published.matchAll(/:(\d+)->/g)) ports.add(Number(m2[1]));
+  }
+  return [...ports];
+}
+async function resolveComposePorts(prefs) {
+  return resolvePorts({
+    api: toPort(prefs.api),
+    dashboard: toPort(prefs.dashboard),
+    previous: composeEnvPorts(),
+    bindAddr: composeBindAddr(),
+    reclaimable: composeHeldPorts()
+  });
+}
 function renderEnv(opts, host, cfg) {
   const prev = readEnvFile();
   const lines = [
@@ -13235,13 +13525,21 @@ function renderEnv(opts, host, cfg) {
     // (hides the local row). Written explicitly so the policy is visible in .env.
     `OPENSHIP_HOST_CONTROL=${cfg.hostControl ? "true" : "false"}`,
     `OPENSHIP_IMAGE_REGISTRY=${cfg.registry}`,
-    `OPENSHIP_VERSION=${opts.version || (true ? "0.4.8" : "latest")}`,
+    `OPENSHIP_VERSION=${opts.version || (true ? "0.5.0" : "latest")}`,
     `POSTGRES_PASSWORD=${keepSecret(prev, "POSTGRES_PASSWORD")}`,
+    // Pinned once (see resolvePgData): fresh install → subdir, existing volume → root.
+    `OPENSHIP_PGDATA=${resolvePgData(prev)}`,
     `BETTER_AUTH_SECRET=${keepSecret(prev, "BETTER_AUTH_SECRET")}`,
     `INTERNAL_TOKEN=${keepSecret(prev, "INTERNAL_TOKEN")}`,
     `API_PORT=${cfg.apiPort}`,
-    `DASHBOARD_PORT=${cfg.dashPort}`
+    `DASHBOARD_PORT=${cfg.dashPort}`,
+    // The api's OWN view of the dashboard port: the self-app boot reconcile points
+    // the operator's domain at the dashboard through this (self-deploy.ts), and it
+    // silently defaults to 3001 when unset. Ports are dynamic now, so leaving it
+    // out publishes a domain routed to a port nothing is listening on.
+    `OPENSHIP_DASHBOARD_PORT=${cfg.dashPort}`
   ];
+  if (cfg.bindAddr) lines.push(`OPENSHIP_BIND_ADDR=${cfg.bindAddr}`);
   if (cfg.publicUrl) lines.push(`OPENSHIP_PUBLIC_URL=${cfg.publicUrl}`);
   if (cfg.extraTrustedOrigins) {
     lines.push(`OPENSHIP_EXTRA_TRUSTED_ORIGINS=${cfg.extraTrustedOrigins}`);
@@ -13261,7 +13559,7 @@ function renderEnv(opts, host, cfg) {
 function sourceBuildDir() {
   const marker = readSourceInstall();
   if (!marker?.dir) return null;
-  const hasAll = BUILT_SERVICES.every((s2) => existsSync3(join6(marker.dir, s2.dockerfile)));
+  const hasAll = BUILT_SERVICES.every((s2) => existsSync4(join7(marker.dir, s2.dockerfile)));
   return hasAll ? marker.dir : null;
 }
 function renderBuildOverride(repoDir) {
@@ -13277,20 +13575,20 @@ services:
 ${services}`;
 }
 function materialize(opts) {
-  mkdirSync2(COMPOSE_DIR, { recursive: true, mode: 448 });
+  mkdirSync3(COMPOSE_DIR, { recursive: true, mode: 448 });
   const prev = readEnvFile();
   const cfg = resolveEnvConfig(prev, opts);
   const host = cfg.hostControl ? provisionHostSshChannel() : null;
   let before = "";
   try {
-    before = readFileSync2(ENV_FILE, "utf8");
+    before = readFileSync3(ENV_FILE, "utf8");
   } catch {
   }
   const rendered = renderEnv(opts, host, cfg);
-  writeFileSync(COMPOSE_FILE, COMPOSE_YAML);
-  writeFileSync(ENV_FILE, rendered, { mode: 384 });
+  writeFileSync2(COMPOSE_FILE, COMPOSE_YAML);
+  writeFileSync2(ENV_FILE, rendered, { mode: 384 });
   const buildDir = opts.build === false ? null : sourceBuildDir();
-  if (buildDir) writeFileSync(BUILD_FILE, renderBuildOverride(buildDir));
+  if (buildDir) writeFileSync2(BUILD_FILE, renderBuildOverride(buildDir));
   return { buildDir, cfg, envChanged: before !== "" && rendered !== before };
 }
 function dbVolumeExists(project) {
@@ -13365,12 +13663,12 @@ function onEdgeContainerChanged() {
   invalidateEdgeContainer();
 }
 function composeDown() {
-  if (!existsSync3(COMPOSE_FILE)) return false;
+  if (!existsSync4(COMPOSE_FILE)) return false;
   return compose(["down"]) === 0;
 }
 function composeUninstall(opts = {}) {
   const removedImages = [];
-  const ok = existsSync3(COMPOSE_FILE) ? compose(["down", "-v", "--remove-orphans"]) === 0 : false;
+  const ok = existsSync4(COMPOSE_FILE) ? compose(["down", "-v", "--remove-orphans"]) === 0 : false;
   if (opts.removeImages) {
     const env = readEnvFile();
     const registry = env.OPENSHIP_IMAGE_REGISTRY || DEFAULT_IMAGE_REGISTRY;
@@ -13385,7 +13683,7 @@ function composeUninstall(opts = {}) {
   return { ok, removedImages };
 }
 async function composeUpdate(version) {
-  if (!existsSync3(COMPOSE_FILE)) return false;
+  if (!existsSync4(COMPOSE_FILE)) return false;
   return (await composeUp(version ? { version } : {})).ok;
 }
 function composePs() {
@@ -13421,6 +13719,15 @@ async function waitForApiHealth(port, tries) {
   }
   return false;
 }
+async function waitForEdgeRunning(tries) {
+  const exec = new LocalExecutor();
+  for (let i2 = 0; i2 < tries; i2++) {
+    const out = await exec.exec(`docker inspect -f '{{.State.Running}}' ${EDGE_CONTAINER_NAME}`).catch(() => "");
+    if (out.trim() === "true") return true;
+    await new Promise((r2) => setTimeout(r2, 1e3));
+  }
+  return false;
+}
 async function importMigratedSites(apiPort, sites, certPems) {
   const token = composeInternalToken();
   if (!token) {
@@ -13437,6 +13744,11 @@ async function importMigratedSites(apiPort, sites, certPems) {
     spinner.warn(`${error} \u2014 migrated sites not imported. Re-run \`openship up\` to retry.`);
     return { ok: false, registered: [], error };
   }
+  if (!await waitForEdgeRunning(60)) {
+    const error = `the ${EDGE_CONTAINER_NAME} container isn't running yet`;
+    spinner.warn(`${error} \u2014 migrated sites not imported. Re-run \`openship up\` to retry.`);
+    return { ok: false, registered: [], error };
+  }
   try {
     const r2 = await fetch(`http://127.0.0.1:${apiPort}/api/system/edge/import-sites`, {
       method: "POST",
@@ -13496,15 +13808,27 @@ async function importMigratedSites(apiPort, sites, certPems) {
 export {
   OS_DIR,
   IS_ALT_HOME,
+  DEFAULT_API_PORT,
+  DEFAULT_DASHBOARD_PORT,
+  saveInstanceUrl,
+  readInstanceUrl,
+  readStoredPorts,
+  storedApiPort,
+  storedDashboardPort,
+  portMoveNotice,
+  resolvePorts,
   shortSha,
   prepareFromSource,
   readSourceInstall,
   remoteSha,
   rebuildFromSource,
   readInstallMethod,
+  dockerGap,
   hasDockerCompose,
   composeIsViableDefault,
   ensureDocker,
+  composeTrustedOriginUrls,
+  resolveComposePorts,
   sourceBuildDir,
   composePrefetch,
   composeUp,
@@ -13517,5 +13841,6 @@ export {
   composeRestart,
   composeInternalToken,
   waitForApiHealth,
+  waitForEdgeRunning,
   importMigratedSites
 };