openship 0.2.3 → 0.4.0

package/dist/chunk-3U4SPZD5.js

@@ -0,0 +1,241 @@
+import {
+  formatDuration,
+  isRemoteConnectionError,
+  systemDebug
+} from "./chunk-4LEL3H2Z.js";
+import {
+  safeErrorMessage
+} from "./chunk-JZLNHGLW.js";
+
+// ../../packages/adapters/src/system/port-listen.ts
+var PROC_NET_TCP_CMD = "cat /proc/net/tcp 2>/dev/null; cat /proc/net/tcp6 2>/dev/null; true";
+var TCP_LISTEN = "0A";
+function parseListeningPorts(procText) {
+  const ports = /* @__PURE__ */ new Set();
+  for (const rawLine of procText.split("\n")) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    const fields = line.split(/\s+/);
+    if (fields.length < 4) continue;
+    if (fields[3] !== TCP_LISTEN) continue;
+    const local = fields[1];
+    const colon = local.lastIndexOf(":");
+    if (colon === -1) continue;
+    const hexPort = local.slice(colon + 1);
+    if (!/^[0-9A-Fa-f]{1,4}$/.test(hexPort)) continue;
+    const port = parseInt(hexPort, 16);
+    if (port > 0) ports.add(port);
+  }
+  return ports;
+}
+async function probePortListeningOnce(executor, port) {
+  try {
+    const out = await executor.exec(PROC_NET_TCP_CMD, { timeout: 5e3 });
+    return parseListeningPorts(out).has(port);
+  } catch {
+    return null;
+  }
+}
+
+// ../../packages/adapters/src/runtime/port-conflict.ts
+async function tryExec(executor, command) {
+  try {
+    return await executor.exec(command);
+  } catch {
+    return null;
+  }
+}
+async function resolveSystemdUnit(executor, pid) {
+  const cgroup = await tryExec(executor, `cat /proc/${pid}/cgroup 2>/dev/null || true`);
+  const unitMatch = cgroup?.match(/(?:^|\/)([^/\n]+\.service)(?:$|\n|\/)/m) ?? cgroup?.match(/(?:^|\/)([^/\n]+\.service)(?:$|\n|\/)/m);
+  const systemdUnit = unitMatch?.[1]?.trim();
+  if (!systemdUnit || !/^[A-Za-z0-9@._:\\-]+\.service$/.test(systemdUnit)) {
+    return {};
+  }
+  const description = await tryExec(
+    executor,
+    `systemctl show ${systemdUnit} --property=Description --value 2>/dev/null || true`
+  );
+  const managedMatch = systemdUnit.match(/^openship-(.+)\.service$/);
+  return {
+    systemdUnit,
+    systemdDescription: description?.trim() || void 0,
+    deploymentId: managedMatch?.[1],
+    isManagedDeployment: Boolean(managedMatch)
+  };
+}
+async function resolveListener(executor, port) {
+  const out = await tryExec(
+    executor,
+    `ss -tlnp sport = :${port} 2>/dev/null | grep LISTEN || lsof -ti tcp:${port} -sTCP:LISTEN 2>/dev/null || true`
+  );
+  if (out) {
+    const ssMatch = out.match(/pid=(\d+)/);
+    const lsofMatch = !ssMatch ? out.match(/^\s*(\d+)\s*$/m) : null;
+    const pid = ssMatch ? parseInt(ssMatch[1], 10) : lsofMatch ? parseInt(lsofMatch[1], 10) : null;
+    if (pid) return { pid, occupied: true };
+  }
+  const listening = await probePortListeningOnce(executor, port);
+  return { pid: null, occupied: listening === true };
+}
+async function probeListeningPort(executor, port) {
+  try {
+    const { pid, occupied } = await resolveListener(executor, port);
+    if (!occupied) return null;
+    if (pid === null) return { pid: null, command: "unknown listener" };
+    return await describeProcess(executor, pid);
+  } catch {
+    return null;
+  }
+}
+async function describeProcess(executor, pid) {
+  let command = `PID ${pid}`;
+  let rawCommand;
+  const args = await tryExec(executor, `ps -p ${pid} -o args= 2>/dev/null || true`);
+  if (args?.trim()) {
+    rawCommand = args.trim();
+    command = `${rawCommand} (PID ${pid})`;
+  } else {
+    const cmd = await tryExec(executor, `ps -p ${pid} -o comm= 2>/dev/null || true`);
+    if (cmd?.trim()) {
+      rawCommand = cmd.trim();
+      command = `${rawCommand} (PID ${pid})`;
+    }
+  }
+  const systemd = await resolveSystemdUnit(executor, pid);
+  return { pid, command, rawCommand, ...systemd };
+}
+
+// ../../packages/adapters/src/system/environment.ts
+var profileCache = /* @__PURE__ */ new WeakMap();
+async function execSafe(executor, command, timeout = 5e3) {
+  const startedAt = Date.now();
+  systemDebug("environment", `exec:start ${command}`);
+  try {
+    const result = await executor.exec(command, { timeout });
+    systemDebug(
+      "environment",
+      `exec:ok ${command} (${formatDuration(startedAt)})`
+    );
+    return result;
+  } catch (err) {
+    if (isRemoteConnectionError(err)) {
+      systemDebug(
+        "environment",
+        `exec:abort ${command} (${formatDuration(startedAt)}) ${safeErrorMessage(err)}`
+      );
+      throw err;
+    }
+    const msg = safeErrorMessage(err);
+    systemDebug(
+      "environment",
+      `exec:fail ${command} (${formatDuration(startedAt)}) ${msg}`
+    );
+    return null;
+  }
+}
+function parseOs(uname) {
+  const value = uname?.trim().toLowerCase();
+  if (value === "linux") return "linux";
+  if (value === "darwin") return "darwin";
+  return "unknown";
+}
+function parseArch(uname) {
+  const value = uname?.trim().toLowerCase() ?? "";
+  if (["x86_64", "amd64"].includes(value)) return "amd64";
+  if (["aarch64", "arm64"].includes(value)) return "arm64";
+  return "unknown";
+}
+function parseDistro(osRelease) {
+  if (!osRelease) return null;
+  const lower = osRelease.toLowerCase();
+  const match = lower.match(/^id=(.+)$/m);
+  const id = match?.[1]?.replaceAll('"', "").trim();
+  switch (id) {
+    case "ubuntu":
+      return "ubuntu";
+    case "debian":
+      return "debian";
+    case "fedora":
+      return "fedora";
+    case "rhel":
+    case "rhel server":
+      return "rhel";
+    case "centos":
+      return "centos";
+    case "alpine":
+      return "alpine";
+    default:
+      return "unknown";
+  }
+}
+async function detectPackageManager(executor) {
+  const checks = [
+    ["apt", "command -v apt-get"],
+    ["dnf", "command -v dnf"],
+    ["yum", "command -v yum"],
+    ["apk", "command -v apk"],
+    ["brew", "command -v brew"]
+  ];
+  for (const [pm, command] of checks) {
+    if (await execSafe(executor, command)) return pm;
+  }
+  return "none";
+}
+async function detectServiceManager(executor) {
+  if (await execSafe(executor, "command -v systemctl")) return "systemd";
+  if (await execSafe(executor, "command -v launchctl")) return "launchd";
+  return "none";
+}
+async function detectPrivilege(executor) {
+  const uid = await execSafe(executor, "id -u");
+  const isRoot = uid?.trim() === "0";
+  if (isRoot) return { isRoot: true, canSudo: false };
+  const sudo = await execSafe(
+    executor,
+    "sudo -n true 2>/dev/null && echo yes || echo no"
+  );
+  return { isRoot: false, canSudo: sudo?.trim() === "yes" };
+}
+async function detectProfile(executor) {
+  const startedAt = Date.now();
+  systemDebug("environment", "detect:start");
+  const unameOs = await execSafe(executor, "uname -s");
+  const unameArch = await execSafe(executor, "uname -m");
+  const osRelease = await execSafe(executor, "cat /etc/os-release");
+  const packageManager = await detectPackageManager(executor);
+  const serviceManager = await detectServiceManager(executor);
+  const { isRoot, canSudo } = await detectPrivilege(executor);
+  const os = parseOs(unameOs);
+  const profile = {
+    os,
+    arch: parseArch(unameArch),
+    distro: os === "linux" ? parseDistro(osRelease) : null,
+    packageManager,
+    serviceManager,
+    isRoot,
+    canSudo
+  };
+  systemDebug(
+    "environment",
+    `detect:done (${formatDuration(startedAt)}) ${JSON.stringify(profile)}`
+  );
+  return profile;
+}
+async function resolveEnvironment(executor) {
+  let promise = profileCache.get(executor);
+  if (!promise) {
+    systemDebug("environment", "cache:miss");
+    promise = detectProfile(executor);
+    profileCache.set(executor, promise);
+  } else {
+    systemDebug("environment", "cache:hit");
+  }
+  return promise;
+}
+
+export {
+  resolveEnvironment,
+  probeListeningPort,
+  describeProcess
+};