openship 0.4.5 → 0.4.6

package/dist/chunk-FQGJZ2HS.js

@@ -0,0 +1,248 @@
+#!/usr/bin/env sh
+":" //# ; exec "$(command -v bun || command -v node)" "$0" "$@"
+import { createRequire as __ospCreateRequire } from "node:module";
+const require = __ospCreateRequire(import.meta.url);
+import {
+  describeProcess,
+  probeListeningPort
+} from "./chunk-ILFETZOM.js";
+import {
+  OPENRESTY_LUA_DIR
+} from "./chunk-VFINNTUL.js";
+import {
+  AppError
+} from "./chunk-6APULWSU.js";
+
+// ../../packages/adapters/src/system/proxy/detect.ts
+var EDGE_PORTS = [80, 443];
+var EdgeConflictError = class extends AppError {
+  constructor(status) {
+    super(
+      `Ports ${status.occupants.map((o) => o.port).join("/") || "80/443"} are in use by another service (${status.classification}). Accept a migrate or takeover to continue.`,
+      409,
+      "EDGE_CONFLICT"
+    );
+    this.status = status;
+    this.name = "EdgeConflictError";
+  }
+};
+var EdgeMigrateRequested = class extends Error {
+  constructor(status, sites, warnings = []) {
+    super("Edge migration requested by user");
+    this.status = status;
+    this.sites = sites;
+    this.warnings = warnings;
+    this.name = "EdgeMigrateRequested";
+  }
+};
+async function tryExec(executor, command) {
+  try {
+    return await executor.exec(command);
+  } catch {
+    return null;
+  }
+}
+function classifyProxy(text) {
+  if (!text) return void 0;
+  const t = text.toLowerCase();
+  if (t.includes("openresty")) return "openresty";
+  if (/(^|[\s/:])nginx/.test(t)) return "nginx";
+  if (/(^|[\s/:])caddy/.test(t)) return "caddy";
+  if (/(apache2|httpd)/.test(t)) return "apache";
+  if (/(^|[\s/:])traefik/.test(t)) return "traefik";
+  if (/(^|[\s/:])haproxy/.test(t)) return "haproxy";
+  return void 0;
+}
+function sq(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function isOurEdgeContainer(name, image) {
+  return /openship-edge/i.test(`${name ?? ""} ${image ?? ""}`);
+}
+async function ourEdgeContainerRunning(executor) {
+  return Boolean(await resolveOurEdgeContainer(executor));
+}
+var EDGE_CONTAINER_TTL_MS = 2e4;
+var edgeContainerMemo = /* @__PURE__ */ new WeakMap();
+var edgeMemoGeneration = 0;
+function invalidateEdgeContainer(executor) {
+  if (executor) edgeContainerMemo.delete(executor);
+  else edgeMemoGeneration++;
+}
+async function resolveOurEdgeContainer(executor, opts) {
+  if (!opts?.fresh) {
+    const hit = edgeContainerMemo.get(executor);
+    if (hit && hit.generation === edgeMemoGeneration && Date.now() - hit.at < EDGE_CONTAINER_TTL_MS) {
+      return hit.value;
+    }
+  }
+  const resolved = await probeOurEdgeContainer(executor);
+  edgeContainerMemo.set(executor, {
+    value: resolved,
+    at: Date.now(),
+    generation: edgeMemoGeneration
+  });
+  return resolved;
+}
+async function probeOurEdgeContainer(executor) {
+  const byName = await tryExec(
+    executor,
+    `docker ps --filter name=openship-edge --format '{{.Names}}' 2>/dev/null | head -1`
+  );
+  if (byName?.trim()) return byName.trim();
+  const all = await tryExec(executor, `docker ps --format '{{.Names}}	{{.Image}}' 2>/dev/null`);
+  if (!all) return null;
+  for (const line of all.split("\n").map((l) => l.trim()).filter(Boolean)) {
+    const [name, image] = line.split("	");
+    if (name && isOurEdgeContainer(name, image)) return name;
+  }
+  return null;
+}
+async function ourLuaOnHost(executor) {
+  const lua = await tryExec(
+    executor,
+    `test -f ${OPENRESTY_LUA_DIR}/site_logger.lua && echo ok`
+  );
+  return Boolean(lua && lua.includes("ok"));
+}
+async function detectDockerOnPort(executor, port) {
+  const out = await tryExec(
+    executor,
+    `docker ps --filter publish=${port} --format '{{.Names}}	{{.Image}}' 2>/dev/null | head -1`
+  );
+  const line = out?.trim();
+  if (!line) return null;
+  const [name, image] = line.split("	");
+  if (!name) return null;
+  return { name, image: image ?? "" };
+}
+async function listenerIsOurOpenResty(executor, listener) {
+  if (!listener) return false;
+  if (/openresty/i.test(`${listener.rawCommand ?? ""} ${listener.command ?? ""}`)) return true;
+  if (listener.pid) {
+    const exe = await tryExec(executor, `readlink -f /proc/${listener.pid}/exe 2>/dev/null || true`);
+    if (exe && /openresty/i.test(exe)) return true;
+  }
+  return false;
+}
+var WORKER_RE = /\b(?:nginx|openresty)\s*:\s*worker process/i;
+var MASTER_RE = /\b(?:nginx|openresty)\s*:\s*master process/i;
+async function resolveProxyMaster(executor, listener) {
+  if (!listener?.pid) return listener;
+  if (!WORKER_RE.test(`${listener.rawCommand ?? ""} ${listener.command ?? ""}`)) return listener;
+  const ppidRaw = await tryExec(
+    executor,
+    `awk '/^PPid:/{print $2}' /proc/${listener.pid}/status 2>/dev/null || true`
+  );
+  const ppid = Number.parseInt((ppidRaw ?? "").trim(), 10);
+  if (!Number.isInteger(ppid) || ppid <= 1) return listener;
+  const master = await describeProcess(executor, ppid);
+  if (!master || !MASTER_RE.test(`${master.rawCommand ?? ""} ${master.command ?? ""}`)) {
+    return listener;
+  }
+  return master;
+}
+async function probeEdgePort(executor, port, ours) {
+  const listener = await resolveProxyMaster(executor, await probeListeningPort(executor, port));
+  const docker = await detectDockerOnPort(executor, port);
+  if (!listener && !docker) return null;
+  const proxy = classifyProxy(
+    [
+      docker?.image,
+      docker?.name,
+      listener?.rawCommand,
+      listener?.command,
+      listener?.systemdUnit
+    ].filter(Boolean).join(" ")
+  );
+  const foreignDockerProxy = Boolean(docker) && !isOurEdgeContainer(docker?.name, docker?.image);
+  const managedByOpenship = isOurEdgeContainer(docker?.name, docker?.image) || ours.containerRunning && !foreignDockerProxy || !docker && ours.luaOnHost && await listenerIsOurOpenResty(executor, listener);
+  return {
+    port,
+    pid: listener?.pid ?? void 0,
+    command: docker ? `docker container ${docker.name} (${docker.image})` : listener?.command,
+    rawCommand: listener?.rawCommand,
+    systemdUnit: listener?.systemdUnit,
+    systemdDescription: listener?.systemdDescription,
+    isDocker: Boolean(docker),
+    containerName: docker?.name,
+    proxy,
+    managedByOpenship
+  };
+}
+async function probeEdge(executor) {
+  const containerRunning = await ourEdgeContainerRunning(executor);
+  const luaOnHost = await ourLuaOnHost(executor);
+  const all = [];
+  for (const port of EDGE_PORTS) {
+    const occ = await probeEdgePort(executor, port, { containerRunning, luaOnHost });
+    if (occ) all.push(occ);
+  }
+  const foreign = all.filter((o) => !o.managedByOpenship);
+  let classification;
+  if (all.length === 0) classification = "free";
+  else if (foreign.length === 0) classification = "ours";
+  else if (foreign.every((o) => o.proxy && o.proxy !== "openresty")) classification = "known";
+  else classification = "unknown";
+  return {
+    classification,
+    occupants: foreign,
+    canProceedClean: classification === "free" || classification === "ours"
+  };
+}
+function stopTargetsForStatus(status) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const o of status.occupants) {
+    const identity = o.systemdUnit ?? o.containerName ?? (o.pid ? `pid:${o.pid}` : `port:${o.port}`);
+    if (seen.has(identity)) continue;
+    seen.add(identity);
+    out.push({
+      port: o.port,
+      unit: o.systemdUnit,
+      pid: o.pid,
+      container: o.containerName,
+      // Prefer the proxy kind over the raw cmdline — `nginx (PID 123)` reads
+      // better in "Stopping …" than `nginx: master process /usr/sbin/nginx …`.
+      label: o.proxy && o.pid ? `${o.proxy} (PID ${o.pid})` : o.command
+    });
+  }
+  return out;
+}
+async function freeEdgeTargets(executor, targets, onLog) {
+  for (const t of targets) {
+    const where = t.port ? ` (port ${t.port})` : "";
+    if (t.container) {
+      onLog(`Stopping container ${t.container}${where}...`, "warn");
+      await tryExec(executor, `docker update --restart=no ${sq(t.container)} 2>/dev/null || true`);
+      await tryExec(executor, `docker stop ${sq(t.container)} 2>/dev/null || true`);
+    } else if (t.unit) {
+      onLog(`Stopping & disabling service ${t.unit}${where}...`, "warn");
+      await tryExec(
+        executor,
+        `systemctl disable --now ${sq(t.unit)} 2>/dev/null || systemctl stop ${sq(t.unit)} 2>/dev/null || true; systemctl reset-failed ${sq(t.unit)} 2>/dev/null || true`
+      );
+    } else if (t.pid) {
+      onLog(`Stopping ${t.label ?? `process ${t.pid}`}${where}...`, "warn");
+      await tryExec(executor, `kill ${t.pid} 2>/dev/null || true`);
+      await new Promise((r) => setTimeout(r, 800));
+      await tryExec(executor, `kill -9 ${t.pid} 2>/dev/null || true`);
+    }
+  }
+  await new Promise((r) => setTimeout(r, 1e3));
+}
+
+export {
+  EdgeConflictError,
+  EdgeMigrateRequested,
+  classifyProxy,
+  sq,
+  isOurEdgeContainer,
+  ourEdgeContainerRunning,
+  invalidateEdgeContainer,
+  resolveOurEdgeContainer,
+  ourLuaOnHost,
+  probeEdge,
+  stopTargetsForStatus,
+  freeEdgeTargets
+};

package/dist/{chunk-FZJX6XP7.js → chunk-FRNAR33O.js}

@@ -1,11 +1,13 @@
+#!/usr/bin/env sh
+":" //# ; exec "$(command -v bun || command -v node)" "$0" "$@"
 import { createRequire as __ospCreateRequire } from "node:module";
 const require = __ospCreateRequire(import.meta.url);
 import {
   setCredentialFeature
-} from "./chunk-65KKUJBR.js";
+} from "./chunk-VWPEKOH6.js";
 import {
   CredentialsProviderError
-} from "./chunk-GHXGCANU.js";
+} from "./chunk-W73X43R7.js";
 
 // ../../node_modules/@aws-sdk/credential-provider-env/dist-es/fromEnv.js
 var ENV_KEY = "AWS_ACCESS_KEY_ID";