@rakay-technology/kraft 0.7.4

package/dist/node-bootstrap.js

@@ -0,0 +1,277 @@
+// src/node-bootstrap.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { join as join4 } from "path";
+import { createInterface } from "readline";
+
+// src/lib/node-runtime.ts
+import { execFileSync, spawnSync } from "child_process";
+import {
+  chmodSync,
+  existsSync,
+  lstatSync,
+  mkdirSync as mkdirSync2,
+  rmSync,
+  symlinkSync,
+  writeFileSync
+} from "fs";
+import { join as join3 } from "path";
+
+// src/lib/cache.ts
+import { createHash } from "crypto";
+import { createReadStream, createWriteStream, mkdirSync } from "fs";
+import { dirname, join as join2 } from "path";
+
+// src/lib/paths.ts
+import { homedir } from "os";
+import { join, resolve } from "path";
+var DEFAULT_HOME = join(homedir(), ".kraft");
+var override = process.env.KRAFT_HOME?.trim();
+var OS_DIR = override ? resolve(override) : DEFAULT_HOME;
+var DATA_DIR = join(OS_DIR, "data");
+var LOG_DIR = join(OS_DIR, "logs");
+var AUTH_SECRET_FILE = join(OS_DIR, "auth-secret");
+var INTERNAL_TOKEN_FILE = join(OS_DIR, "internal-token");
+
+// src/lib/cache.ts
+var CACHE_DIR = join2(OS_DIR, "cache");
+var RELEASES_DIR = join2(CACHE_DIR, "releases");
+async function downloadToFile(url, dest, onProgress) {
+  const res = await fetch(url, { headers: { "User-Agent": "kraft-cli" } });
+  if (!res.ok || !res.body) throw new Error(`HTTP ${res.status} for ${url}`);
+  mkdirSync(dirname(dest), { recursive: true });
+  const total = Number(res.headers.get("content-length")) || 0;
+  const hash = createHash("sha256");
+  const file = createWriteStream(dest);
+  const reader = res.body.getReader();
+  let received = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      hash.update(value);
+      if (!file.write(Buffer.from(value))) {
+        await new Promise((r) => file.once("drain", r));
+      }
+      received += value.length;
+      onProgress?.(received, total);
+    }
+  } finally {
+    file.end();
+  }
+  await new Promise((resolve2, reject) => {
+    file.on("finish", () => resolve2());
+    file.on("error", reject);
+  });
+  return { sha256: hash.digest("hex"), size: received };
+}
+
+// src/lib/node-runtime.ts
+var NODE_MAJOR = 22;
+var NODE_DIST = "https://nodejs.org/dist";
+var RUNTIME_DIR = join3(OS_DIR, "runtime");
+var RUNTIME_CURRENT = join3(RUNTIME_DIR, "current");
+var BIN_DIR = join3(OS_DIR, "bin");
+var LAUNCHER_PATH = join3(BIN_DIR, "kraft");
+var LAUNCHER_SH = `#!/bin/sh
+# Kraft CLI launcher \u2014 runs the tarball-installed CLI under Node.
+# Managed by scripts/install.sh and \`kraft update\`; manual edits are overwritten.
+SELF="$0"
+while [ -L "$SELF" ]; do
+  _t="$(readlink "$SELF")"
+  case "$_t" in /*) SELF="$_t" ;; *) SELF="$(dirname "$SELF")/$_t" ;; esac
+done
+BIN_DIR="$(cd "$(dirname "$SELF")" && pwd)"
+HOME_DIR="$(dirname "$BIN_DIR")"
+CLI="$HOME_DIR/cli/current/dist/index.js"
+VENDORED_NODE="$HOME_DIR/runtime/current/bin/node"
+# Prefer a system node >= ${NODE_MAJOR}; fall back to the vendored runtime.
+if command -v node >/dev/null 2>&1 && node -e 'process.exit(+process.versions.node.split(".")[0]>=${NODE_MAJOR}?0:1)' 2>/dev/null; then
+  exec node "$CLI" "$@"
+elif [ -x "$VENDORED_NODE" ]; then
+  exec "$VENDORED_NODE" "$CLI" "$@"
+else
+  echo "kraft: no Node >= ${NODE_MAJOR} found (system or vendored). Reinstall: curl -fsSL https://get.kraft.io | sh" >&2
+  exit 127
+fi
+`;
+function nodeDistOs() {
+  if (process.platform === "darwin") return "darwin";
+  if (process.platform === "linux") return "linux";
+  throw new Error(
+    `Unsupported platform for vendored Node: ${process.platform}`
+  );
+}
+function nodeDistArch() {
+  if (process.arch === "x64") return "x64";
+  if (process.arch === "arm64") return "arm64";
+  throw new Error(`Unsupported arch for vendored Node: ${process.arch}`);
+}
+function majorOf(bin) {
+  try {
+    const out = execFileSync(
+      bin,
+      ["-e", "process.stdout.write(process.versions.node)"],
+      {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }
+    );
+    const m = Number(out.trim().split(".")[0]);
+    return Number.isInteger(m) ? m : null;
+  } catch {
+    return null;
+  }
+}
+function repoint(link, target) {
+  try {
+    if (lstatSync(link)) rmSync(link, { recursive: true, force: true });
+  } catch {
+  }
+  symlinkSync(target, link);
+}
+async function resolveLatestNode() {
+  const res = await fetch(`${NODE_DIST}/index.json`, {
+    headers: { "User-Agent": "kraft-cli" },
+    signal: AbortSignal.timeout(15e3)
+  });
+  if (!res.ok)
+    throw new Error(`Node dist index lookup failed: HTTP ${res.status}`);
+  const rows = await res.json();
+  const prefix = `v${NODE_MAJOR}.`;
+  const row = rows.find((r) => r.version.startsWith(prefix) && r.lts) ?? rows.find((r) => r.version.startsWith(prefix));
+  if (!row)
+    throw new Error(`No Node ${NODE_MAJOR}.x release found on nodejs.org`);
+  return row.version;
+}
+async function fetchVendoredNode(onLog) {
+  const ver = await resolveLatestNode();
+  const os = nodeDistOs();
+  const arch = nodeDistArch();
+  const name = `node-${ver}-${os}-${arch}.tar.gz`;
+  mkdirSync2(RUNTIME_DIR, { recursive: true });
+  const tarball = join3(RUNTIME_DIR, name);
+  onLog?.(`Fetching Node ${ver} (${os}-${arch}) from nodejs.org\u2026`);
+  const { sha256 } = await downloadToFile(
+    `${NODE_DIST}/${ver}/${name}`,
+    tarball
+  );
+  const shaRes = await fetch(`${NODE_DIST}/${ver}/SHASUMS256.txt`, {
+    headers: { "User-Agent": "kraft-cli" },
+    signal: AbortSignal.timeout(15e3)
+  });
+  if (!shaRes.ok) {
+    rmSync(tarball, { force: true });
+    throw new Error(`Node checksum list fetch failed: HTTP ${shaRes.status}`);
+  }
+  const expected = (await shaRes.text()).split("\n").map((l) => l.trim()).find((l) => l.endsWith(` ${name}`) || l.endsWith(`  ${name}`))?.split(/\s+/)[0]?.toLowerCase();
+  if (!expected) {
+    rmSync(tarball, { force: true });
+    throw new Error(`No checksum for ${name} in SHASUMS256.txt`);
+  }
+  if (expected !== sha256) {
+    rmSync(tarball, { force: true });
+    throw new Error(
+      `Node download checksum mismatch (expected ${expected}, got ${sha256}).`
+    );
+  }
+  const unpacked = join3(RUNTIME_DIR, `node-${ver}-${os}-${arch}`);
+  rmSync(unpacked, { recursive: true, force: true });
+  const untar = spawnSync("tar", ["-xzf", tarball, "-C", RUNTIME_DIR], {
+    stdio: "inherit"
+  });
+  if (untar.status !== 0)
+    throw new Error(
+      "Failed to extract the Node runtime (is `tar` available?)."
+    );
+  rmSync(tarball, { force: true });
+  const nodeBin = join3(unpacked, "bin", "node");
+  if (!existsSync(nodeBin))
+    throw new Error(
+      `Node unpacked but ${nodeBin} is missing (unexpected layout).`
+    );
+  repoint(RUNTIME_CURRENT, unpacked);
+  return nodeBin;
+}
+async function ensureNodeRuntime(onLog) {
+  if ((majorOf("node") ?? 0) >= NODE_MAJOR)
+    return { node: "node", source: "system" };
+  const existing = join3(RUNTIME_CURRENT, "bin", "node");
+  if (existsSync(existing) && (majorOf(existing) ?? 0) >= NODE_MAJOR) {
+    return { node: existing, source: "vendored" };
+  }
+  return { node: await fetchVendoredNode(onLog), source: "vendored" };
+}
+
+// src/node-bootstrap.ts
+var NODE_REEXEC_ENV = "KRAFT_NODE_REEXEC";
+var VENDOR_ENV = "KRAFT_VENDOR_NODE";
+var vendoredNode = () => join4(OS_DIR, "runtime", "current", "bin", "node");
+function majorOf2(bin) {
+  const out = spawnSync2(
+    bin,
+    ["-e", "process.stdout.write(process.versions.node)"],
+    {
+      encoding: "utf8"
+    }
+  );
+  if (out.status !== 0) return 0;
+  return Number.parseInt(out.stdout.trim().split(".")[0] ?? "", 10) || 0;
+}
+function reexec(nodeBin, cliPath) {
+  const res = spawnSync2(nodeBin, [cliPath, ...process.argv.slice(2)], {
+    stdio: "inherit",
+    env: { ...process.env, [NODE_REEXEC_ENV]: "1" }
+  });
+  return { handled: true, status: res.status ?? 1 };
+}
+function isAffirmative(answer) {
+  return !/^n/i.test(answer.trim());
+}
+function ask(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve2) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve2(isAffirmative(answer));
+    });
+  });
+}
+async function recoverOldNode(opts) {
+  const existing = vendoredNode();
+  if (existsSync2(existing) && majorOf2(existing) >= NODE_MAJOR) {
+    return reexec(existing, opts.cliPath);
+  }
+  if (!opts.offerDownload) return { handled: false };
+  if (process.platform === "win32") return { handled: false };
+  const forced = process.env[VENDOR_ENV]?.trim();
+  if (forced === "0") return { handled: false };
+  if (forced !== "1") {
+    if (!process.stdin.isTTY) return { handled: false };
+    const yes = await ask(
+      `
+Kraft can download its own Node ${NODE_MAJOR} (~50 MB) into ${OS_DIR}/runtime
+and use it for Kraft only \u2014 your system Node is left exactly as it is.
+
+Download it now? [Y/n] `
+    );
+    if (!yes) return { handled: false };
+  }
+  let nodeBin;
+  try {
+    nodeBin = (await ensureNodeRuntime(opts.log)).node;
+  } catch (e) {
+    opts.log(`Could not set up Node ${NODE_MAJOR}: ${e.message}`);
+    return { handled: false };
+  }
+  if (nodeBin === "node") return { handled: false };
+  opts.log(
+    `Using Node ${NODE_MAJOR} from ${OS_DIR}/runtime \u2014 future runs pick it up automatically.`
+  );
+  return reexec(nodeBin, opts.cliPath);
+}
+export {
+  NODE_REEXEC_ENV,
+  isAffirmative,
+  recoverOldNode
+};

package/dist/node-entry.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+// src/node-entry.ts
+import { fileURLToPath } from "url";
+var HARD_FLOOR = 20;
+var SUPPORTED = 22;
+var INSTALLER = "curl -fsSL https://get.kraft.io | sh";
+var CLI_PATH = fileURLToPath(new URL("./index.js", import.meta.url));
+var log = (msg) => process.stderr.write(`${msg}
+`);
+var runningBun = typeof process.versions.bun === "string";
+var major = Number.parseInt(process.versions.node?.split(".")[0] ?? "", 10);
+var reexeced = process.env.KRAFT_NODE_REEXEC === "1";
+var tooOld = !runningBun && !reexeced && Number.isFinite(major) && major < SUPPORTED;
+if (tooOld) {
+  try {
+    const { recoverOldNode } = await import("./node-bootstrap.js");
+    const outcome = await recoverOldNode({
+      cliPath: CLI_PATH,
+      // 20 and 21 DO run: reuse a Node already on disk, but don't prompt to download
+      // one on every invocation to fix a setup that already works.
+      offerDownload: major < HARD_FLOOR,
+      log
+    });
+    if (outcome.handled) process.exit(outcome.status ?? 0);
+  } catch {
+  }
+  if (major < HARD_FLOOR) {
+    process.stderr.write(
+      `
+Kraft needs Node ${SUPPORTED} or newer \u2014 this is Node v${process.versions.node}.
+
+  Install Node ${SUPPORTED}+ and re-run, or use the official installer, which
+  brings its own Node and doesn't touch the one you have:
+
+    ${INSTALLER}
+
+  Non-interactive (CI, a service)? Set KRAFT_VENDOR_NODE=1 and Kraft
+  fetches its own Node ${SUPPORTED} without asking.
+
+If you upgrade Node with a version manager (nvm, fnm, volta), global packages
+live per Node version \u2014 reinstall the CLI afterwards or the command will go
+missing: npm i -g @rakay-technology/kraft
+
+`
+    );
+    process.exit(1);
+  }
+  process.stderr.write(
+    `Warning: Node v${process.versions.node} is below Kraft's supported floor (Node ${SUPPORTED}+). It may work; it isn't tested. Upgrade, or install with:
+  ${INSTALLER}
+`
+  );
+}
+await import("./index.js");

package/dist/noop-CLLJHCPL.js

@@ -0,0 +1,11 @@
+#!/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 {
+  NoopInfraProvider
+} from "./chunk-RHLNVZMS.js";
+import "./chunk-PXKCZB2I.js";
+export {
+  NoopInfraProvider
+};

package/dist/openresty-lua-6I3Z6PEQ.js

@@ -0,0 +1,90 @@
+#!/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 {
+  ACME_CHALLENGE_LOCATION,
+  ACME_HTTP01_PORT,
+  EDGE_CHALLENGE_DIR,
+  EDGE_CHALLENGE_HOST_DIR,
+  EDGE_CHALLENGE_LOCATION,
+  EDGE_CHALLENGE_ROOT,
+  EDGE_CHALLENGE_URL_PREFIX,
+  EDGE_CLIENT_MAX_BODY_SIZE,
+  EDGE_CONTAINER_MOUNTS,
+  EDGE_DEFAULT_CERT_CN,
+  EDGE_DEFAULT_CERT_DIRNAME,
+  EDGE_HOST_PATHS,
+  EDGE_HOST_STATE_DIR,
+  EDGE_HTTPS_REJECT_BLOCK,
+  EDGE_LUA_PACKAGE_PATH,
+  EDGE_MGMT_SERVER_BLOCK,
+  EDGE_SAME_PATH_MOUNTS,
+  EDGE_SERVER_NAMES_HASH_BUCKET_SIZE,
+  EDGE_SHARED_DICTS,
+  GEOIP_DB_PATH,
+  GEOIP_DIR,
+  LUA_LOGGER_PATH,
+  OPENRESTY_DEFAULT_PATHS,
+  OPENRESTY_LUA_DIR,
+  OPENRESTY_MGMT_PORT,
+  RULES_GUARD_PATH,
+  buildReloadCommand,
+  deployLuaScripts,
+  detectOpenRestyPaths,
+  edgeChallengeVhostConf,
+  edgeDefaultCatchAllConf,
+  edgeDefaultCertPaths,
+  edgeHttpsDefaultBlock,
+  ensureLuaScripts,
+  ensureOpenRestyConfig,
+  luaSourceAvailable,
+  parseNginxVersion
+} from "./chunk-BQMFIXHI.js";
+import "./chunk-WYNM7L22.js";
+import "./chunk-N4OALTFK.js";
+import "./chunk-YRSZPVMB.js";
+import "./chunk-OFXBNFNL.js";
+import "./chunk-3CJLKL6E.js";
+import "./chunk-MNV2QFHW.js";
+import "./chunk-PVOWHIND.js";
+import "./chunk-PXKCZB2I.js";
+export {
+  ACME_CHALLENGE_LOCATION,
+  ACME_HTTP01_PORT,
+  EDGE_CHALLENGE_DIR,
+  EDGE_CHALLENGE_HOST_DIR,
+  EDGE_CHALLENGE_LOCATION,
+  EDGE_CHALLENGE_ROOT,
+  EDGE_CHALLENGE_URL_PREFIX,
+  EDGE_CLIENT_MAX_BODY_SIZE,
+  EDGE_CONTAINER_MOUNTS,
+  EDGE_DEFAULT_CERT_CN,
+  EDGE_DEFAULT_CERT_DIRNAME,
+  EDGE_HOST_PATHS,
+  EDGE_HOST_STATE_DIR,
+  EDGE_HTTPS_REJECT_BLOCK,
+  EDGE_LUA_PACKAGE_PATH,
+  EDGE_MGMT_SERVER_BLOCK,
+  EDGE_SAME_PATH_MOUNTS,
+  EDGE_SERVER_NAMES_HASH_BUCKET_SIZE,
+  EDGE_SHARED_DICTS,
+  GEOIP_DB_PATH,
+  GEOIP_DIR,
+  LUA_LOGGER_PATH,
+  OPENRESTY_DEFAULT_PATHS,
+  OPENRESTY_LUA_DIR,
+  OPENRESTY_MGMT_PORT,
+  RULES_GUARD_PATH,
+  buildReloadCommand,
+  deployLuaScripts,
+  detectOpenRestyPaths,
+  edgeChallengeVhostConf,
+  edgeDefaultCatchAllConf,
+  edgeDefaultCertPaths,
+  edgeHttpsDefaultBlock,
+  ensureLuaScripts,
+  ensureOpenRestyConfig,
+  luaSourceAvailable,
+  parseNginxVersion
+};

package/dist/privilege-UQAI2HV4.js

@@ -0,0 +1,20 @@
+#!/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 {
+  privilegedExecutor,
+  rootChecked,
+  rootOrDegrade
+} from "./chunk-S3QBGGVP.js";
+import "./chunk-YRSZPVMB.js";
+import "./chunk-OFXBNFNL.js";
+import "./chunk-3CJLKL6E.js";
+import "./chunk-MNV2QFHW.js";
+import "./chunk-PVOWHIND.js";
+import "./chunk-PXKCZB2I.js";
+export {
+  privilegedExecutor,
+  rootChecked,
+  rootOrDegrade
+};