@rakay-technology/kraft 0.7.4

package/dist/chunk-WYNM7L22.js

@@ -0,0 +1,329 @@
+#!/usr/bin/env sh
+":" //# ; exec "$(command -v node || command -v bun)" "$0" "$@"
+import { createRequire as __ospCreateRequire } from "node:module";
+const require = __ospCreateRequire(import.meta.url);
+import {
+  containerIdFromCgroup,
+  isContainerPortForwarder,
+  managedDeploymentIdFromUnit,
+  tryExec
+} from "./chunk-N4OALTFK.js";
+import {
+  shellQuote
+} from "./chunk-PVOWHIND.js";
+
+// ../../packages/adapters/src/system/port-listen.ts
+var PROC_NET_TCP_FILES = ["/proc/net/tcp", "/proc/net/tcp6"];
+var PROBE_LISTENING = "__KRAFT_PORT_LISTENING__";
+var PROBE_FREE = "__KRAFT_PORT_FREE__";
+var PROBE_UNAVAILABLE = "__KRAFT_PORT_UNAVAILABLE__";
+function buildPortProbeCommand(port) {
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new RangeError(`Invalid TCP port: ${port}`);
+  }
+  return [
+    `lsof_output="$(lsof -nP -t -iTCP:${port} -sTCP:LISTEN 2>&1)"`,
+    `lsof_status=$?`,
+    `if [ "$lsof_status" -eq 0 ] && [ -n "$lsof_output" ] && printf '%s\\n' "$lsof_output" | grep -Eqv '^[0-9]+$'; then`,
+    `  : # Unexpected lsof output: fall through to ss instead of guessing.`,
+    `elif [ "$lsof_status" -eq 0 ] && [ -n "$lsof_output" ]; then`,
+    `  printf '${PROBE_LISTENING}\\n'`,
+    `  exit 0`,
+    `elif [ "$lsof_status" -eq 1 ] && [ -z "$lsof_output" ]; then`,
+    `  printf '${PROBE_FREE}\\n'`,
+    `  exit 0`,
+    `fi`,
+    `ss_output="$(ss -tln "sport = :${port}" 2>&1)"`,
+    `ss_status=$?`,
+    `if [ "$ss_status" -eq 0 ] && printf '%s\\n' "$ss_output" | grep -q LISTEN; then`,
+    `  printf '${PROBE_LISTENING}\\n'`,
+    `elif [ "$ss_status" -eq 0 ]; then`,
+    `  printf '${PROBE_FREE}\\n'`,
+    `else`,
+    `  printf '${PROBE_UNAVAILABLE}\\n'`,
+    `fi`
+  ].join("\n");
+}
+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;
+}
+function parsePortProbeOutput(out) {
+  const trimmed = out.trim();
+  if (trimmed === PROBE_LISTENING) return true;
+  if (trimmed === PROBE_FREE) return false;
+  if (trimmed === PROBE_UNAVAILABLE) return null;
+  return null;
+}
+async function probePortListeningOnce(executor, port) {
+  if (!Number.isInteger(port) || port < 1 || port > 65535) return null;
+  const readable = [];
+  for (const file of PROC_NET_TCP_FILES) {
+    try {
+      readable.push(
+        await executor.exec(`cat ${file} 2>/dev/null`, { timeout: 5e3 })
+      );
+    } catch {
+    }
+  }
+  if (readable.length > 0)
+    return parseListeningPorts(readable.join("\n")).has(port);
+  try {
+    const out = await executor.exec(buildPortProbeCommand(port), {
+      timeout: 5e3
+    });
+    return parsePortProbeOutput(out);
+  } catch {
+    return null;
+  }
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function waitForPortListening(executor, port, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? 45e3;
+  const intervalMs = opts.intervalMs ?? 1e3;
+  const deadline = Date.now() + timeoutMs;
+  let anyConclusive = false;
+  try {
+    for (; ; ) {
+      const result = await probePortListeningOnce(executor, port);
+      if (result === true) return { listening: true, checked: true };
+      if (result === false) anyConclusive = true;
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) break;
+      await delay(Math.min(intervalMs, remaining));
+    }
+  } catch {
+    return { listening: false, checked: false };
+  }
+  return anyConclusive ? { listening: false, checked: true } : { listening: false, checked: false };
+}
+async function waitForPortFree(executor, port, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? 15e3;
+  const intervalMs = opts.intervalMs ?? 500;
+  const deadline = Date.now() + timeoutMs;
+  let anyConclusive = false;
+  try {
+    for (; ; ) {
+      const result = await probePortListeningOnce(executor, port);
+      if (result === false) return { free: true, checked: true };
+      if (result === true) anyConclusive = true;
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) break;
+      await delay(Math.min(intervalMs, remaining));
+    }
+  } catch {
+    return { free: false, checked: false };
+  }
+  return anyConclusive ? { free: false, checked: true } : { free: false, checked: false };
+}
+
+// ../../packages/adapters/src/runtime/port-conflict.ts
+async function resolveListenerOwner(executor, pid) {
+  const cgroup = (await tryExec(executor, `cat /proc/${pid}/cgroup 2>/dev/null`))?.trim();
+  if (!cgroup) return { cgroupVerified: false };
+  const evidence = { cgroupVerified: true, processCgroup: cgroup };
+  const containerId = containerIdFromCgroup(cgroup);
+  if (containerId) return { ...evidence, containerId };
+  const systemdUnit = cgroup?.match(/(?:^|\/)([^/\n]+\.service)(?:$|\n|\/)/m)?.[1]?.trim();
+  if (!systemdUnit || !/^[A-Za-z0-9@._:-]+\.service$/.test(systemdUnit)) {
+    return evidence;
+  }
+  const description = await tryExec(
+    executor,
+    `systemctl show ${shellQuote(systemdUnit)} --property=Description --value 2>/dev/null || true`
+  );
+  const deploymentId = managedDeploymentIdFromUnit(systemdUnit);
+  return {
+    ...evidence,
+    systemdUnit,
+    systemdDescription: description?.trim() || void 0,
+    ...deploymentId ? { deploymentId, isManagedDeployment: true } : { isManagedDeployment: false }
+  };
+}
+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`
+  );
+  const listenerPid = (output) => {
+    if (!output) return null;
+    const ssMatch = output.match(/pid=(\d+)/);
+    const lsofMatch = !ssMatch ? output.match(/^\s*(\d+)\s*$/m) : null;
+    const parsed = ssMatch?.[1] ?? lsofMatch?.[1];
+    if (!parsed) return null;
+    const pid2 = Number.parseInt(parsed, 10);
+    return Number.isSafeInteger(pid2) && pid2 > 0 ? pid2 : null;
+  };
+  const pid = listenerPid(out);
+  if (pid) return { pid, occupied: true, checked: true };
+  const observedListener = Boolean(out?.trim());
+  if (observedListener) {
+    const privilegedOut = await tryExec(
+      executor,
+      `sudo -n ss -tlnp sport = :${port} 2>/dev/null | grep LISTEN || sudo -n lsof -ti tcp:${port} -sTCP:LISTEN 2>/dev/null || true`,
+      { timeout: 5e3 }
+    );
+    const privilegedPid = listenerPid(privilegedOut);
+    if (privilegedPid)
+      return { pid: privilegedPid, occupied: true, checked: true };
+  }
+  const listening = await probePortListeningOnce(executor, port);
+  return {
+    pid: null,
+    occupied: observedListener || listening === true,
+    checked: observedListener || listening !== null
+  };
+}
+function parseListenerPids(output) {
+  const lines = (output ?? "").split("\n").map((line) => line.trim()).filter(Boolean);
+  if (lines.length === 0) return { observed: false, complete: true, pids: [] };
+  const pids = /* @__PURE__ */ new Set();
+  let complete = true;
+  for (const line of lines) {
+    const matches = [...line.matchAll(/pid=(\d+)/g)].map((match) => match[1]);
+    const bare = matches.length === 0 ? line.match(/^(\d+)$/)?.[1] : void 0;
+    const values = bare ? [bare] : matches;
+    if (values.length === 0) complete = false;
+    for (const value of values) {
+      const pid = Number.parseInt(value, 10);
+      if (Number.isSafeInteger(pid) && pid > 0) pids.add(pid);
+      else complete = false;
+    }
+  }
+  return { observed: true, complete, pids: [...pids] };
+}
+async function probeListeningPortOwners(executor, port) {
+  const command = `ss -tlnp sport = :${port} 2>/dev/null | grep LISTEN || lsof -ti tcp:${port} -sTCP:LISTEN 2>/dev/null || true`;
+  const ordinary = parseListenerPids(await tryExec(executor, command));
+  let evidence = ordinary;
+  if (ordinary.observed && !ordinary.complete) {
+    const privileged = parseListenerPids(
+      await tryExec(
+        executor,
+        `sudo -n ss -tlnp sport = :${port} 2>/dev/null | grep LISTEN || sudo -n lsof -ti tcp:${port} -sTCP:LISTEN 2>/dev/null`,
+        { timeout: 5e3 }
+      )
+    );
+    if (privileged.observed && privileged.complete) evidence = privileged;
+    else {
+      evidence = {
+        observed: true,
+        complete: false,
+        pids: [.../* @__PURE__ */ new Set([...ordinary.pids, ...privileged.pids])]
+      };
+    }
+  }
+  if (!evidence.observed) {
+    const listening = await probePortListeningOnce(executor, port);
+    if (listening === null)
+      return { occupants: [], checked: false, ownershipComplete: false };
+    if (!listening)
+      return { occupants: [], checked: true, ownershipComplete: true };
+    return { occupants: [], checked: true, ownershipComplete: false };
+  }
+  const described = await Promise.all(
+    evidence.pids.map(
+      (pid) => describeProcess(executor, pid).catch(() => null)
+    )
+  );
+  const occupants = described.filter(
+    (row) => row !== null
+  );
+  return {
+    occupants,
+    checked: true,
+    ownershipComplete: evidence.complete && occupants.length === evidence.pids.length
+  };
+}
+async function probeListeningPortState(executor, port) {
+  try {
+    const { pid, occupied, checked } = await resolveListener(executor, port);
+    if (!checked || !occupied) return { occupant: null, checked };
+    if (pid === null) {
+      return {
+        occupant: { pid: null, command: "unknown listener" },
+        checked: true
+      };
+    }
+    return { occupant: await describeProcess(executor, pid), checked: true };
+  } catch {
+    return { occupant: null, checked: false };
+  }
+}
+async function probeListeningPort(executor, port) {
+  return (await probeListeningPortState(executor, port)).occupant;
+}
+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})`;
+    }
+  }
+  if (isContainerPortForwarder(rawCommand)) {
+    return { pid, command, rawCommand, dockerPublished: true };
+  }
+  const systemd = await resolveListenerOwner(executor, pid);
+  return { pid, command, rawCommand, ...systemd };
+}
+function portOccupantDetails(port, occupant, stopTarget) {
+  if (!occupant) return { port };
+  return {
+    port,
+    pid: occupant.pid,
+    command: occupant.command,
+    rawCommand: occupant.rawCommand,
+    systemdUnit: occupant.systemdUnit,
+    systemdDescription: occupant.systemdDescription,
+    deploymentId: occupant.deploymentId,
+    isManagedDeployment: occupant.isManagedDeployment,
+    containerId: occupant.containerId,
+    containerName: occupant.containerName,
+    containerImage: occupant.containerImage,
+    ownerProjectId: occupant.ownerProjectId,
+    serviceName: occupant.serviceName,
+    dockerPublished: occupant.dockerPublished,
+    platformContainer: occupant.platformContainer,
+    ambiguousOwners: occupant.ambiguousOwners,
+    ...stopTarget ? { stopTarget } : {}
+  };
+}
+
+export {
+  waitForPortListening,
+  waitForPortFree,
+  probeListeningPortOwners,
+  probeListeningPort,
+  describeProcess,
+  portOccupantDetails
+};

package/dist/chunk-XGCG4MD5.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env sh
+":" //# ; exec "$(command -v node || command -v bun)" "$0" "$@"
+import { createRequire as __ospCreateRequire } from "node:module";
+const require = __ospCreateRequire(import.meta.url);
+import {
+  PACKAGE_ROOT_ONLY_EXCLUDES
+} from "./chunk-PVOWHIND.js";
+
+// ../../packages/adapters/src/archive.ts
+import { execFile } from "child_process";
+import { mkdtemp, rm, stat, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var ROOT_ONLY_EXCLUDES = new Set(PACKAGE_ROOT_ONLY_EXCLUDES);
+var NOOP_CLEANUP = async () => {
+};
+function getTarCreateEnv() {
+  return {
+    ...process.env,
+    COPYFILE_DISABLE: "1",
+    COPY_EXTENDED_ATTRIBUTES_DISABLE: "1"
+  };
+}
+function tarCreateBaseArgs(localPath) {
+  const darwinFlags = process.platform === "darwin" ? ["--no-mac-metadata", "--no-xattrs", "--no-acls", "--no-fflags"] : [];
+  return [...darwinFlags, "-czf", "-", "-C", localPath];
+}
+async function gitTrackedFiles(localPath) {
+  try {
+    const { stdout } = await execFileAsync(
+      "git",
+      [
+        "-C",
+        localPath,
+        "ls-files",
+        "-z",
+        "--cached",
+        "--others",
+        "--exclude-standard"
+      ],
+      { maxBuffer: 256 * 1024 * 1024 }
+    );
+    const files = stdout.split("\0").filter(Boolean);
+    return files.length > 0 ? files : null;
+  } catch {
+    return null;
+  }
+}
+async function existingRelativePaths(root, paths) {
+  if (!paths?.length) return [];
+  const found = [];
+  for (const p of paths) {
+    try {
+      await stat(join(root, p));
+      found.push(p);
+    } catch {
+    }
+  }
+  return found;
+}
+async function prepareSourceTarArgs(localPath, options) {
+  if (options?.includes?.length) {
+    return {
+      args: getTarCreateArgs(localPath, options),
+      cleanup: NOOP_CLEANUP
+    };
+  }
+  const files = await gitTrackedFiles(localPath);
+  if (files) {
+    const extra = await existingRelativePaths(localPath, options?.alsoInclude);
+    const entries = extra.length ? [...files, ...extra] : files;
+    const tmpDir = await mkdtemp(join(tmpdir(), "kraft-tarlist-"));
+    const listFile = join(tmpDir, "files.null");
+    await writeFile(listFile, entries.join("\0"));
+    const args = [...tarCreateBaseArgs(localPath), "--null", "-T", listFile];
+    return {
+      args,
+      cleanup: () => rm(tmpDir, { recursive: true, force: true })
+    };
+  }
+  return { args: getTarCreateArgs(localPath, options), cleanup: NOOP_CLEANUP };
+}
+function getTarCreateArgs(localPath, options) {
+  const args = tarCreateBaseArgs(localPath);
+  if (options?.includes?.length) {
+    args.push(...options.includes);
+    return args;
+  }
+  for (const exclude of options?.excludes ?? []) {
+    const pattern = ROOT_ONLY_EXCLUDES.has(exclude) ? `./${exclude}` : exclude;
+    args.push(`--exclude=${pattern}`);
+  }
+  args.push(".");
+  return args;
+}
+
+export {
+  getTarCreateEnv,
+  prepareSourceTarArgs
+};

package/dist/chunk-XVKUFMIB.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env sh
+":" //# ; exec "$(command -v node || command -v bun)" "$0" "$@"
+import { createRequire as __ospCreateRequire } from "node:module";
+const require = __ospCreateRequire(import.meta.url);
+import {
+  getLocalExecEnv,
+  getLocalShellArgs,
+  getLocalShellPath,
+  logEntry,
+  sq
+} from "./chunk-MNV2QFHW.js";
+
+// ../../packages/adapters/src/system/local-executor.ts
+import { exec, spawn } from "child_process";
+import {
+  access,
+  mkdir as fsMkdir,
+  open as fsOpen,
+  readFile as fsReadFile,
+  rename as fsRename,
+  rm as fsRm,
+  writeFile as fsWriteFile
+} from "fs/promises";
+import { dirname } from "path";
+var LocalExecutor = class {
+  async exec(command, opts) {
+    return new Promise((resolve, reject) => {
+      const shell = getLocalShellPath();
+      exec(
+        command,
+        {
+          timeout: opts?.timeout ?? 3e4,
+          shell,
+          env: getLocalExecEnv()
+        },
+        (err, stdout, stderr) => {
+          if (err) {
+            const detail = [stderr.trim(), stdout.trim()].filter(Boolean).join("\n");
+            reject(new Error(detail || err.message));
+          } else resolve(stdout.trim());
+        }
+      );
+    });
+  }
+  streamExec(command, onLog, opts) {
+    return new Promise((resolve) => {
+      if (opts?.signal?.aborted) {
+        resolve({ code: 0, output: "" });
+        return;
+      }
+      const child = spawn(getLocalShellPath(), getLocalShellArgs(command), {
+        stdio: ["ignore", "pipe", "pipe"],
+        env: getLocalExecEnv()
+      });
+      const MAX_RETAINED_CHUNKS = 200;
+      const chunks = [];
+      const onChunk = (data, level) => {
+        const text = data.toString();
+        if (!text) return;
+        chunks.push(text);
+        if (chunks.length > MAX_RETAINED_CHUNKS) chunks.shift();
+        onLog(logEntry(text, level, data.toString("base64")));
+      };
+      const signal = opts?.signal;
+      const onAbort = () => {
+        try {
+          child.kill("SIGTERM");
+        } catch {
+        }
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+      const cleanup = () => signal?.removeEventListener("abort", onAbort);
+      child.stdout.on("data", (data) => onChunk(data, "info"));
+      child.stderr.on("data", (data) => onChunk(data, "warn"));
+      child.on("close", (code) => {
+        cleanup();
+        resolve({ code: code ?? 1, output: chunks.join("") });
+      });
+      child.on("error", (err) => {
+        cleanup();
+        onLog(logEntry(`Process error: ${err.message}`, "error"));
+        resolve({ code: 1, output: err.message });
+      });
+    });
+  }
+  async writeFile(path, content, opts) {
+    await fsMkdir(dirname(path), { recursive: true });
+    if (opts?.mode === void 0) {
+      await fsWriteFile(path, content, "utf-8");
+      return;
+    }
+    const file = await fsOpen(path, "w", opts.mode);
+    try {
+      await file.chmod(opts.mode);
+      await file.writeFile(content, "utf-8");
+    } finally {
+      await file.close();
+    }
+  }
+  async rename(from, to) {
+    await fsRename(from, to);
+  }
+  async readFile(path) {
+    return fsReadFile(path, "utf-8");
+  }
+  async exists(path) {
+    try {
+      await access(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async mkdir(path) {
+    await fsMkdir(path, { recursive: true });
+  }
+  async rm(path) {
+    try {
+      await fsRm(path, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  async transferIn(localPath, remotePath, onLog, options) {
+    const log = onLog ?? (() => {
+    });
+    if (options?.includes?.length) {
+      for (const p of options.includes) {
+        const { code: code2 } = await this.streamExec(
+          `cp -a ${sq(localPath + "/" + p)} ${sq(remotePath + "/" + p)}`,
+          log
+        );
+        if (code2 !== 0) throw new Error(`Failed to copy ${p}`);
+      }
+      return;
+    }
+    const { code } = await this.streamExec(
+      `cp -a ${sq(localPath + "/")}. ${sq(remotePath)}`,
+      log
+    );
+    if (code !== 0) throw new Error("Failed to copy local project files");
+  }
+  async dispose() {
+  }
+};
+
+export {
+  LocalExecutor
+};

package/dist/chunk-XZYFZ6A5.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env sh
+":" //# ; exec "$(command -v node || command -v bun)" "$0" "$@"
+import { createRequire as __ospCreateRequire } from "node:module";
+const require = __ospCreateRequire(import.meta.url);
+import {
+  setCredentialFeature
+} from "./chunk-DRK3MEDS.js";
+import {
+  CredentialsProviderError
+} from "./chunk-3NQQXMDR.js";
+
+// ../../node_modules/@aws-sdk/credential-provider-env/dist-es/fromEnv.js
+var ENV_KEY = "AWS_ACCESS_KEY_ID";
+var ENV_SECRET = "AWS_SECRET_ACCESS_KEY";
+var ENV_SESSION = "AWS_SESSION_TOKEN";
+var ENV_EXPIRATION = "AWS_CREDENTIAL_EXPIRATION";
+var ENV_CREDENTIAL_SCOPE = "AWS_CREDENTIAL_SCOPE";
+var ENV_ACCOUNT_ID = "AWS_ACCOUNT_ID";
+var fromEnv = (init) => async () => {
+  init?.logger?.debug("@aws-sdk/credential-provider-env - fromEnv");
+  const accessKeyId = process.env[ENV_KEY];
+  const secretAccessKey = process.env[ENV_SECRET];
+  const sessionToken = process.env[ENV_SESSION];
+  const expiry = process.env[ENV_EXPIRATION];
+  const credentialScope = process.env[ENV_CREDENTIAL_SCOPE];
+  const accountId = process.env[ENV_ACCOUNT_ID];
+  if (accessKeyId && secretAccessKey) {
+    const credentials = {
+      accessKeyId,
+      secretAccessKey,
+      ...sessionToken && { sessionToken },
+      ...expiry && { expiration: new Date(expiry) },
+      ...credentialScope && { credentialScope },
+      ...accountId && { accountId }
+    };
+    setCredentialFeature(credentials, "CREDENTIALS_ENV_VARS", "g");
+    return credentials;
+  }
+  throw new CredentialsProviderError("Unable to find environment variable credentials.", { logger: init?.logger });
+};
+
+export {
+  ENV_KEY,
+  ENV_SECRET,
+  ENV_SESSION,
+  ENV_EXPIRATION,
+  ENV_CREDENTIAL_SCOPE,
+  ENV_ACCOUNT_ID,
+  fromEnv
+};