@xano/sdk 1.0.0

package/dist/chunk-6ELFRN3P.js

@@ -0,0 +1,365 @@
+import {
+  sha256Hex
+} from "./chunk-NA3PXMEF.js";
+import {
+  normalizeEngineVersion
+} from "./chunk-APWXY5SL.js";
+import {
+  localEngineBinDir,
+  localEngineHome
+} from "./chunk-AM4FKL4J.js";
+import {
+  SDK_PACKAGE,
+  composeToolchainConfig,
+  readProjectManifest,
+  readToolchainBlock,
+  writeToolchainConfig
+} from "./chunk-JTUKLCXS.js";
+import {
+  atomicWrite
+} from "./chunk-LLNZGEFK.js";
+
+// src/deploy/local-engine-cache.ts
+import {
+  lstatSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  realpathSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+  chmodSync
+} from "fs";
+import { randomBytes } from "crypto";
+import { basename, isAbsolute, join, relative, sep } from "path";
+var ENGINE_EXECUTABLE_FILE = "engine";
+var ENGINE_RECORD_FILE = "engine.json";
+var RELEASE_VERSION = /^v\d+\.\d+\.\d+$/;
+var OVERRIDE_DIR = /^src-[0-9a-f]{16}$/;
+function engineEntryDirName(key) {
+  if ("version" in key) {
+    if (!RELEASE_VERSION.test(key.version)) {
+      throw new Error(
+        `"${key.version}" is not an engine version \u2014 they are written vMAJOR.MINOR.PATCH, like v0.1.5 \u2014 so no cache path was built from it.`
+      );
+    }
+    return key.version;
+  }
+  return `src-${sha256Hex(key.source).slice(0, 16)}`;
+}
+function engineEntryDir(key, env = process.env) {
+  return join(localEngineBinDir(env), engineEntryDirName(key));
+}
+function ownerUid() {
+  return typeof process.getuid === "function" ? process.getuid() : void 0;
+}
+function assertSafeCacheDir(dir, env = process.env) {
+  const home = localEngineHome(env);
+  let base;
+  try {
+    base = realpathSync(home);
+  } catch {
+    return;
+  }
+  const rel = relative(home, dir);
+  const tail = rel === "" || rel.startsWith("..") || isAbsolute(rel) ? [] : rel.split(sep);
+  let current = base;
+  for (const part of [void 0, ...tail]) {
+    if (part !== void 0) current = join(current, part);
+    let st;
+    try {
+      st = lstatSync(current);
+    } catch {
+      return;
+    }
+    if (st.isSymbolicLink()) {
+      throw new Error(
+        `The local engine cache path is a symlink, and a symlink points somewhere these checks never looked: ${current}
+Replace it with a real directory, or point the cache elsewhere with XANOSDK_LOCAL_ENGINE_HOME.`
+      );
+    }
+    if ((st.mode & 18) !== 0) {
+      throw new Error(
+        `The local engine cache is writable by other users on this machine: ${current}
+Anything that can write there can replace the engine executable, and an executable this SDK spawns is not a file to leave open. Run \`chmod go-w\` on it, or point the cache somewhere private with XANOSDK_LOCAL_ENGINE_HOME.`
+      );
+    }
+    const uid = ownerUid();
+    if (uid !== void 0 && st.uid !== uid) {
+      throw new Error(
+        `The local engine cache is owned by another user: ${current}
+An executable this SDK spawns has to be one only you can replace. Take ownership of it, or point the cache somewhere you own with XANOSDK_LOCAL_ENGINE_HOME.`
+      );
+    }
+  }
+}
+function readRecord(dir) {
+  try {
+    const raw = JSON.parse(readFileSync(join(dir, ENGINE_RECORD_FILE), "utf8"));
+    if (typeof raw.url !== "string" || typeof raw.digest !== "string") return void 0;
+    if (raw.source !== "release" && raw.source !== "override") return void 0;
+    if (raw.source === "release" && typeof raw.version !== "string") return void 0;
+    return {
+      source: raw.source,
+      ...raw.source === "release" ? { version: raw.version } : {},
+      url: raw.url,
+      digest: raw.digest,
+      fetchedAt: typeof raw.fetchedAt === "number" ? raw.fetchedAt : 0,
+      ...typeof raw.archiveDigest === "string" ? { archiveDigest: raw.archiveDigest } : {}
+    };
+  } catch {
+    return void 0;
+  }
+}
+function entryAt(dir, name) {
+  const record = readRecord(dir);
+  if (record === void 0) return void 0;
+  if (RELEASE_VERSION.test(name)) {
+    if (record.source !== "release" || record.version !== name) return void 0;
+  } else if (OVERRIDE_DIR.test(name)) {
+    if (record.source !== "override") return void 0;
+  } else {
+    return void 0;
+  }
+  const executable = join(dir, ENGINE_EXECUTABLE_FILE);
+  try {
+    if (!statSync(executable).isFile()) return void 0;
+  } catch {
+    return void 0;
+  }
+  return {
+    dir,
+    executable,
+    source: record.source,
+    ...record.version !== void 0 ? { version: record.version } : {},
+    url: record.url,
+    digest: record.digest,
+    fetchedAt: record.fetchedAt,
+    ...record.archiveDigest !== void 0 ? { archiveDigest: record.archiveDigest } : {}
+  };
+}
+function readEngineEntry(key, env = process.env) {
+  const name = engineEntryDirName(key);
+  return entryAt(join(localEngineBinDir(env), name), name);
+}
+function entriesMatching(pattern, env) {
+  const bin = localEngineBinDir(env);
+  let names;
+  try {
+    names = readdirSync(bin, { withFileTypes: true }).filter((e) => e.isDirectory() && pattern.test(e.name)).map((e) => e.name);
+  } catch {
+    return [];
+  }
+  return names.flatMap((name) => entryAt(join(bin, name), name) ?? []);
+}
+function semverParts(version) {
+  return version.slice(1).split(".").map(Number);
+}
+function listReleaseEntries(env = process.env) {
+  return entriesMatching(RELEASE_VERSION, env).sort((a, b) => {
+    const pa = semverParts(a.version);
+    const pb = semverParts(b.version);
+    for (let i = 0; i < 3; i++) if (pa[i] !== pb[i]) return pb[i] - pa[i];
+    return 0;
+  });
+}
+function listOverrideEntries(env = process.env) {
+  return entriesMatching(OVERRIDE_DIR, env).sort((a, b) => b.fetchedAt - a.fetchedAt);
+}
+var LEGACY_DIR = /^[0-9a-f]{16}$/;
+function listLegacyCacheDirs(env = process.env) {
+  const bin = localEngineBinDir(env);
+  try {
+    return readdirSync(bin, { withFileTypes: true }).filter((e) => e.isDirectory() && LEGACY_DIR.test(e.name)).map((e) => join(bin, e.name)).sort();
+  } catch {
+    return [];
+  }
+}
+function verifiedEngineExecutable(entry, env = process.env) {
+  assertSafeCacheDir(entry.dir, env);
+  let bytes;
+  try {
+    bytes = readFileSync(entry.executable);
+  } catch {
+    throw new Error(
+      `The cached engine is gone from ${entry.dir}.
+Re-run the same \`xanosdk deploy --local-engine\` and it is fetched again.`
+    );
+  }
+  const actual = sha256Hex(bytes);
+  if (actual !== entry.digest) {
+    throw new Error(
+      `The cached engine's bytes do not match the digest recorded when it was fetched, so it will not be run: ${entry.dir}
+Something replaced it after it was downloaded. Delete that directory and re-run the same \`xanosdk deploy --local-engine\` to get it again.`
+    );
+  }
+  return entry.executable;
+}
+function stageEngine(opts) {
+  const env = opts.env ?? process.env;
+  const key = opts.version !== void 0 ? { version: opts.version } : { source: opts.url };
+  const dir = engineEntryDir(key, env);
+  const source = opts.version !== void 0 ? "release" : "override";
+  const bin = localEngineBinDir(env);
+  assertSafeCacheDir(bin, env);
+  mkdirSync(bin, { recursive: true, mode: 448 });
+  assertSafeCacheDir(bin, env);
+  const staging = mkdtempSync(join(bin, ".staging-"));
+  try {
+    const executable = join(staging, ENGINE_EXECUTABLE_FILE);
+    writeFileSync(executable, opts.executable, { mode: 384 });
+    const record = {
+      source,
+      ...opts.version !== void 0 ? { version: opts.version } : {},
+      url: opts.url,
+      digest: opts.digest,
+      fetchedAt: Date.now(),
+      ...opts.archiveDigest !== void 0 ? { archiveDigest: opts.archiveDigest } : {}
+    };
+    atomicWrite(join(staging, ENGINE_RECORD_FILE), JSON.stringify(record, null, 2) + "\n", {
+      mode: 384
+    });
+    chmodSync(executable, 448);
+    opts.beforeCommit?.(staging);
+    const winner = publishStaged(staging, dir, opts.digest, bin);
+    if (winner !== void 0) return winner;
+    return {
+      dir,
+      executable: join(dir, ENGINE_EXECUTABLE_FILE),
+      source,
+      ...opts.version !== void 0 ? { version: opts.version } : {},
+      url: opts.url,
+      digest: opts.digest,
+      fetchedAt: record.fetchedAt,
+      ...opts.archiveDigest !== void 0 ? { archiveDigest: opts.archiveDigest } : {}
+    };
+  } catch (err) {
+    rmSync(staging, { recursive: true, force: true });
+    throw err;
+  }
+}
+var ENTRY_TAKEN = /* @__PURE__ */ new Set(["ENOTEMPTY", "EEXIST"]);
+function publishStaged(staging, dir, digest, bin) {
+  const name = basename(dir);
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      renameSync(staging, dir);
+      return void 0;
+    } catch (err) {
+      if (!ENTRY_TAKEN.has(err.code ?? "")) throw err;
+    }
+    const existing = entryAt(dir, name);
+    if (existing !== void 0 && existing.digest === digest) {
+      rmSync(staging, { recursive: true, force: true });
+      return existing;
+    }
+    const retired = join(bin, `.retired-${randomBytes(8).toString("hex")}`);
+    try {
+      renameSync(dir, retired);
+    } catch (err) {
+      if (err.code === "ENOENT") continue;
+      throw err;
+    }
+    rmSync(retired, { recursive: true, force: true });
+  }
+  throw new Error(
+    `Another run kept writing a different engine to ${dir} while this one staged, so this run stopped without publishing its own. Let the other deploy finish and re-run this one.`
+  );
+}
+function diskBytes(path) {
+  let st;
+  try {
+    st = lstatSync(path);
+  } catch {
+    return 0;
+  }
+  if (!st.isDirectory()) return st.size;
+  let total = 0;
+  let names;
+  try {
+    names = readdirSync(path);
+  } catch {
+    return 0;
+  }
+  for (const name of names) total += diskBytes(join(path, name));
+  return total;
+}
+
+// src/deploy/local-engine-pin.ts
+import { existsSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+var PIN_FIELD = "localEngine";
+function isUnusablePin(pin) {
+  return typeof pin === "object" && pin !== null;
+}
+function readPin(projectDir, opts = {}) {
+  const path = join2(projectDir, "package.json");
+  if (!existsSync(path)) return void 0;
+  const manifest = readProjectManifest(projectDir);
+  if (manifest === null) {
+    opts.warn?.(
+      `${path} could not be parsed as a JSON object, so its local engine pin was not read.`
+    );
+    return { unusable: void 0 };
+  }
+  const own = readToolchainBlock(projectDir, manifest)[SDK_PACKAGE];
+  if (typeof own !== "object" || own === null || Array.isArray(own)) return null;
+  if (!(PIN_FIELD in own)) return null;
+  const value = own[PIN_FIELD];
+  if (typeof value === "string") {
+    try {
+      return normalizeEngineVersion(value);
+    } catch {
+    }
+  }
+  opts.warn?.(
+    `the "${PIN_FIELD}" pin under "xanosdk"."${SDK_PACKAGE}" in ${path} is ${JSON.stringify(value)}, not a version like "v0.1.5", so it was ignored.`
+  );
+  return { unusable: value };
+}
+function writePin(projectDir, version) {
+  if (!RELEASE_VERSION.test(version)) {
+    throw new Error(
+      `cannot pin local engine version ${JSON.stringify(version)}: expected vMAJOR.MINOR.PATCH, like "v0.1.5".`
+    );
+  }
+  const path = join2(projectDir, "package.json");
+  if (!existsSync(path)) {
+    const text = composeToolchainConfig("{}\n", { [SDK_PACKAGE]: { [PIN_FIELD]: version } });
+    try {
+      writeFileSync2(path, text, { flag: "wx" });
+      return { created: true, changed: true, path };
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+    }
+  }
+  const block = readToolchainBlock(projectDir);
+  const own = block[SDK_PACKAGE];
+  const next = {
+    ...block,
+    [SDK_PACKAGE]: {
+      ...typeof own === "object" && own !== null && !Array.isArray(own) ? own : {},
+      [PIN_FIELD]: version
+    }
+  };
+  const changed = writeToolchainConfig(projectDir, next);
+  return { created: false, changed, path };
+}
+
+export {
+  RELEASE_VERSION,
+  readEngineEntry,
+  listReleaseEntries,
+  listOverrideEntries,
+  listLegacyCacheDirs,
+  verifiedEngineExecutable,
+  stageEngine,
+  diskBytes,
+  isUnusablePin,
+  readPin,
+  writePin
+};
+//# sourceMappingURL=chunk-6ELFRN3P.js.map