@xanots/sdk 0.0.1

package/dist/chunk-NDZFBZHC.js

@@ -0,0 +1,167 @@
+import {
+  detail,
+  info,
+  warn
+} from "./chunk-EZG76F7R.js";
+
+// src/deploy/microservice-status.ts
+var TIMEOUT_MS = 3e4;
+var POLL_INTERVAL_MS = 2e3;
+var WAIT_DEADLINE_MS = 3e5;
+function asString(v) {
+  return typeof v === "string" && v !== "" ? v : void 0;
+}
+function asNumber(v) {
+  return typeof v === "number" ? v : void 0;
+}
+function classify(row) {
+  const status = row.status ?? "";
+  if (status === "disabled") return "disabled";
+  if ((row.tenantDeploy ?? "auto") === "manual") return "manual";
+  switch (status) {
+    case "ok": {
+      return "ready";
+    }
+    case "error": {
+      return "failed";
+    }
+    // `pending` is the state a freshly imported row sits in until the engine
+    // picks it up; both it and `deploying` mean "not serving yet, keep looking".
+    case "pending":
+    case "deploying": {
+      return "inFlight";
+    }
+    default: {
+      return "unknown";
+    }
+  }
+}
+function isAwaited(m) {
+  return m.disposition === "inFlight";
+}
+function project(row) {
+  const tenantDeploy = asString(row.tenant_deploy) ?? "auto";
+  const status = asString(row.status) ?? "";
+  return {
+    id: asNumber(row.id),
+    name: asString(row.name) ?? "",
+    kind: asString(row.kind),
+    tenantDeploy,
+    status,
+    statusDetail: asString(row.status_detail),
+    deployedAt: asString(row.deployed_at),
+    disposition: classify({ status, tenantDeploy })
+  };
+}
+function toRows(data) {
+  if (Array.isArray(data)) return data;
+  if (data && typeof data === "object" && Array.isArray(data.items)) {
+    return data.items;
+  }
+  return [];
+}
+async function listMicroservices(auth, target, opts = {}) {
+  const fetchFn = opts.fetchFn ?? fetch;
+  const root = `${target.baseUrl.replace(/\/$/, "")}/api:meta/workspace/${target.workspaceId}/microservice`;
+  const out = [];
+  let page = 1;
+  for (; ; ) {
+    const url = `${root}?page=${page}`;
+    const res = await fetchFn(url, {
+      method: "GET",
+      headers: { accept: "application/json", Authorization: `Bearer ${auth.access_token}` },
+      signal: AbortSignal.timeout(TIMEOUT_MS)
+    });
+    const text = await res.text();
+    if (!res.ok) {
+      throw new Error(`list microservices failed (${res.status} ${res.statusText}):
+${text}`);
+    }
+    let data;
+    try {
+      data = JSON.parse(text);
+    } catch {
+      throw new Error(`list microservices: could not parse the response as JSON:
+${text}`);
+    }
+    out.push(...toRows(data).map((r) => project(r)));
+    const next = data?.nextPage;
+    if (typeof next !== "number" || next <= page) return out;
+    page = next;
+  }
+}
+async function waitForMicroservices(auth, target, opts = {}) {
+  const now = opts.now ?? Date.now;
+  const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const totalDeadlineMs = opts.totalDeadlineMs ?? WAIT_DEADLINE_MS;
+  const pollIntervalMs = opts.pollIntervalMs ?? POLL_INTERVAL_MS;
+  const start = now();
+  let microservices = [];
+  let sawAnyRead = false;
+  for (; ; ) {
+    try {
+      microservices = await listMicroservices(auth, target, opts);
+      sawAnyRead = true;
+      opts.onPoll?.(microservices);
+      if (!microservices.some((m) => isAwaited(m))) {
+        return { microservices, timedOut: false, hadFailure: microservices.some((m) => m.disposition === "failed") };
+      }
+    } catch (err) {
+      if (!sawAnyRead) throw err;
+    }
+    if (now() - start + pollIntervalMs > totalDeadlineMs) {
+      return {
+        microservices,
+        timedOut: true,
+        hadFailure: microservices.some((m) => m.disposition === "failed")
+      };
+    }
+    await sleep(pollIntervalMs);
+  }
+}
+
+// src/emit/microservice-view.ts
+async function readMicroservices(auth, baseUrl, workspaceId = 1) {
+  try {
+    return await listMicroservices(auth, { baseUrl, workspaceId });
+  } catch (err) {
+    warn(`Could not read microservices: ${err instanceof Error ? err.message : String(err)}`);
+    return [];
+  }
+}
+var DISPOSITION_LABEL = {
+  ready: { icon: "\u2713", why: "ready" },
+  inFlight: { icon: "\u2026", why: "starting" },
+  failed: { icon: "\u2717", why: "failed" },
+  manual: { icon: "\u2013", why: "not started \u2014 set to deploy manually" },
+  disabled: { icon: "\u2013", why: "disabled" },
+  unknown: { icon: "\u2013", why: "unrecognized state" }
+};
+function microserviceLine(m) {
+  const { icon, why } = DISPOSITION_LABEL[m.disposition];
+  const useDetail = m.disposition !== "manual" && m.disposition !== "disabled";
+  const reason = (useDetail ? m.statusDetail : void 0) ?? why;
+  return `${icon} ${m.name} \u2014 ${m.disposition === "unknown" ? `${why} (${m.status})` : reason}`;
+}
+function readyRatio(microservices) {
+  return {
+    ready: microservices.filter((m) => m.disposition === "ready").length,
+    // Rows the engine was never going to start don't belong in a readiness ratio.
+    startable: microservices.filter((m) => m.disposition !== "manual" && m.disposition !== "disabled").length
+  };
+}
+function printMicroserviceSection(microservices) {
+  if (microservices.length === 0) return;
+  const { ready, startable } = readyRatio(microservices);
+  info(startable === 0 ? "Microservices (none set to start):" : `Microservices (${ready}/${startable} ready):`);
+  for (const m of microservices) detail(microserviceLine(m));
+}
+
+export {
+  waitForMicroservices,
+  readMicroservices,
+  microserviceLine,
+  readyRatio,
+  printMicroserviceSection
+};
+//# sourceMappingURL=chunk-NDZFBZHC.js.map

package/dist/chunk-NOO35BQ2.js

@@ -0,0 +1,37 @@
+import {
+  compileBundle
+} from "./chunk-YGPIY3WT.js";
+import {
+  missingArgument
+} from "./chunk-IZW6MK3U.js";
+
+// src/emit/bundle-input.ts
+import { existsSync, readFileSync } from "fs";
+function assertBundleInput(args, target) {
+  if (args.bundle === void 0 && args.file === void 0) throw missingArgument("file", target);
+}
+async function loadBundleText(args, target, opts = {}) {
+  assertBundleInput(args, target);
+  if (args.bundle !== void 0) {
+    if (args.file !== void 0) {
+      throw new Error(`Pass either an entry <file> or --bundle <path>, not both.`);
+    }
+    if (!existsSync(args.bundle)) {
+      throw new Error(
+        `${args.bundle} not found. Run \`xanots export <entry> --out ${args.bundle}\` first.`
+      );
+    }
+    return { bundle: readFileSync(args.bundle, "utf8"), source: args.bundle, content: [], nonPublicSeedValues: [] };
+  }
+  if (args.file !== void 0) {
+    const { bundle, content, nonPublicSeedValues } = await compileBundle(args, { seed: opts.withSeed });
+    return { bundle, source: args.file, content, nonPublicSeedValues };
+  }
+  throw missingArgument("file", target);
+}
+
+export {
+  assertBundleInput,
+  loadBundleText
+};
+//# sourceMappingURL=chunk-NOO35BQ2.js.map

package/dist/chunk-NUQCEOKA.js

@@ -0,0 +1,13 @@
+// src/emit/output.ts
+function isMachineOutput(args) {
+  return args.json === true || process.stdout.isTTY !== true;
+}
+function writeJson(value) {
+  process.stdout.write(JSON.stringify(value, null, 2) + "\n");
+}
+
+export {
+  isMachineOutput,
+  writeJson
+};
+//# sourceMappingURL=chunk-NUQCEOKA.js.map

package/dist/chunk-QTNO2WD6.js

@@ -0,0 +1,56 @@
+import {
+  decodeWorkspaceArchive
+} from "./chunk-ZUTSMMAG.js";
+import {
+  fetchReadOrExplain
+} from "./chunk-3IGNIP6R.js";
+
+// src/deploy/workspace-export.ts
+var EXPORT_TIMEOUT_MS = 12e4;
+async function exportWorkspaceBundle(auth, opts) {
+  const base = opts.base.replace(/\/$/, "");
+  const url = `${base}/api:meta/workspace/${opts.workspaceId}/export`;
+  const res = await fetchReadOrExplain(
+    url,
+    {
+      method: "POST",
+      headers: { Authorization: `Bearer ${auth.access_token}`, "Content-Type": "application/json" },
+      // `branch`/`password` are required; the defaults mean "current branch, no
+      // archive password". `records: false` skips table content — see above.
+      body: JSON.stringify({ branch: "", password: "", records: false }),
+      signal: AbortSignal.timeout(EXPORT_TIMEOUT_MS)
+    },
+    opts.label,
+    EXPORT_TIMEOUT_MS
+  );
+  if (!res.ok) {
+    throw new Error(
+      `${opts.label} failed (${res.status} ${res.statusText}):
+${describeErrorBody(
+        new Uint8Array(await res.arrayBuffer()),
+        res.headers.get("content-type")
+      )}`
+    );
+  }
+  const bundle = decodeWorkspaceArchive(new Uint8Array(await res.arrayBuffer()));
+  if (bundle === null || typeof bundle !== "object" || !("payload" in bundle)) {
+    throw new Error(`${opts.label}: the exported archive carried no \`payload\` \u2014 not a workspace bundle.`);
+  }
+  return bundle;
+}
+function describeErrorBody(bytes, contentType) {
+  const type = contentType ? ` (content-type: ${contentType})` : "";
+  const text = new TextDecoder("utf-8", { fatal: false }).decode(bytes);
+  const NOT_TEXT = /[\uFFFD\u0000-\u0008\u000B\u000C\u000E-\u001F]/;
+  if (bytes.length > 0 && !NOT_TEXT.test(text)) {
+    return text.length > 2e3 ? `${text.slice(0, 2e3)}
+\u2026 (${text.length} chars, truncated)` : text;
+  }
+  const gzip = bytes[0] === 31 && bytes[1] === 139;
+  return `<${bytes.length} bytes of ${gzip ? "gzip data" : "binary"}, not text${type}>` + (gzip ? ` \u2014 the body looks like a workspace archive, so the instance answered with a payload AND an error status. The status is what XanoTS goes by; re-run the export, and if it persists the instance is failing mid-export.` : "");
+}
+
+export {
+  exportWorkspaceBundle
+};
+//# sourceMappingURL=chunk-QTNO2WD6.js.map

package/dist/chunk-RVB7ITKN.js

@@ -0,0 +1,49 @@
+import {
+  RAW_ENVELOPE
+} from "./chunk-LH6Z6KFV.js";
+
+// src/statements/special/raw.ts
+var CANONICAL_KEYS = [
+  "as",
+  "name",
+  "_xsid",
+  "addon",
+  "input",
+  "mocks",
+  "output",
+  "context",
+  "runtime",
+  "disabled",
+  "description",
+  "settings_registry"
+];
+function raw(envelope) {
+  if (envelope == null || typeof envelope !== "object" || Array.isArray(envelope)) {
+    throw new Error(
+      'raw() expects a stored statement envelope object \u2014 at minimum `{ name: "mvp:\u2026", context: {\u2026} }` \u2014 but received ' + (envelope === null ? "null" : Array.isArray(envelope) ? "an array" : typeof envelope)
+    );
+  }
+  const name = envelope.name;
+  if (typeof name !== "string" || name === "") {
+    throw new Error(
+      'raw() envelope is missing a `name`. A stored statement envelope must carry its `mvp:` name, e.g. `{ name: "mvp:set_var", context: {\u2026} }`.'
+    );
+  }
+  const stored = {};
+  for (const key of CANONICAL_KEYS) {
+    if (key in envelope) stored[key] = envelope[key];
+  }
+  for (const key of Object.keys(envelope)) {
+    if (!(key in stored)) stored[key] = envelope[key];
+  }
+  return {
+    name,
+    context: stored.context,
+    [RAW_ENVELOPE]: stored
+  };
+}
+
+export {
+  raw
+};
+//# sourceMappingURL=chunk-RVB7ITKN.js.map