@xanots/sdk 0.0.1

package/dist/chunk-X4DVXBFY.js

@@ -0,0 +1,38 @@
+// src/util/tar.ts
+import { gzipSync } from "zlib";
+function tarHeader(name, size) {
+  if (Buffer.byteLength(name, "utf8") > 100) {
+    throw new Error(`tar entry name too long for ustar (>100 bytes): ${name}`);
+  }
+  const h = Buffer.alloc(512, 0);
+  h.write(name, 0, "utf8");
+  h.write("0000644\0", 100, "ascii");
+  h.write("0000000\0", 108, "ascii");
+  h.write("0000000\0", 116, "ascii");
+  h.write(size.toString(8).padStart(11, "0") + "\0", 124, "ascii");
+  h.write("00000000000\0", 136, "ascii");
+  h.write("        ", 148, "ascii");
+  h.write("0", 156, "ascii");
+  h.write("ustar\0", 257, "ascii");
+  h.write("00", 263, "ascii");
+  let sum = 0;
+  for (let i = 0; i < 512; i++) sum += h[i];
+  h.write(sum.toString(8).padStart(6, "0") + "\0 ", 148, "ascii");
+  return h;
+}
+function tarGz(files) {
+  const blocks = [];
+  for (const f of files) {
+    blocks.push(tarHeader(f.name, f.data.length));
+    blocks.push(f.data);
+    const pad = (512 - f.data.length % 512) % 512;
+    if (pad > 0) blocks.push(Buffer.alloc(pad, 0));
+  }
+  blocks.push(Buffer.alloc(1024, 0));
+  return gzipSync(Buffer.concat(blocks));
+}
+
+export {
+  tarGz
+};
+//# sourceMappingURL=chunk-X4DVXBFY.js.map

package/dist/chunk-XQ22GLYS.js

@@ -0,0 +1,118 @@
+import {
+  exportWorkspaceBundle
+} from "./chunk-QTNO2WD6.js";
+import {
+  sandboxBaseUrl
+} from "./chunk-7DKX2SPN.js";
+import {
+  getAccessToken
+} from "./chunk-C56BC2FY.js";
+import {
+  step,
+  success
+} from "./chunk-EZG76F7R.js";
+
+// src/emit/sandbox-export-command.ts
+import { statSync, writeFileSync } from "fs";
+import { join, resolve } from "path";
+var SANDBOX_TIMEOUT_MS = 12e4;
+var MULTIDOC_PATH = "/api:meta/sandbox/multidoc";
+var SANDBOX_ME_PATH = "/api:meta/sandbox/me";
+var DEFAULT_NAME = "sandbox";
+var DEFAULT_FORMAT = "json";
+function resolveOutputTarget(opts) {
+  const { path, name, ext } = opts;
+  if (path === "-") return { kind: "stdout" };
+  const basename = `${name ?? DEFAULT_NAME}.${ext}`;
+  if (path === void 0 || path === "") {
+    return { kind: "file", path: resolve(basename) };
+  }
+  const endsWithSep = path.endsWith("/") || path.endsWith("\\");
+  const isDir = statSync(path, { throwIfNoEntry: false })?.isDirectory() ?? false;
+  if (endsWithSep || isDir) {
+    return { kind: "file", path: resolve(join(path, basename)) };
+  }
+  return { kind: "file", path: resolve(path) };
+}
+async function fetchSandboxMultidoc(auth) {
+  const url = new URL(MULTIDOC_PATH, auth.instance);
+  const res = await fetch(url.href, {
+    headers: {
+      accept: "text/x-xanoscript",
+      Authorization: `Bearer ${auth.access_token}`
+    },
+    signal: AbortSignal.timeout(SANDBOX_TIMEOUT_MS)
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    throw new Error(`sandbox export (multidoc) failed (${res.status} ${res.statusText}):
+${text}`);
+  }
+  return text;
+}
+async function getJson(url, auth, label) {
+  const res = await fetch(url, {
+    headers: { accept: "application/json", Authorization: `Bearer ${auth.access_token}` },
+    signal: AbortSignal.timeout(SANDBOX_TIMEOUT_MS)
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    throw new Error(`sandbox export (${label}) failed (${res.status} ${res.statusText}):
+${text}`);
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(`sandbox export (${label}): could not parse the response as JSON:
+${text.slice(0, 200)}`);
+  }
+}
+async function fetchSandboxBundle(auth) {
+  const tenant = await getJson(`${auth.instance}${SANDBOX_ME_PATH}`, auth, "sandbox/me");
+  const base = sandboxBaseUrl(tenant, auth.instance);
+  const list = await getJson(`${base}/api:meta/workspace`, auth, "workspace list");
+  const workspaces = Array.isArray(list) ? list : [];
+  const workspaceId = workspaces.find((w) => typeof w.id === "number")?.id;
+  if (workspaceId === void 0) {
+    throw new Error(
+      `Your sandbox has no workspace to export yet. Run \`xanots deploy --dest sandbox\` first, then export.`
+    );
+  }
+  return exportWorkspaceBundle(auth, {
+    base,
+    workspaceId,
+    label: "sandbox export (workspace export)"
+  });
+}
+async function fetchSandboxWorkspaceJson(auth) {
+  return JSON.stringify(await fetchSandboxBundle(auth), null, 2);
+}
+async function produce(args, format) {
+  if (args.bundle !== void 0) {
+    throw new Error(
+      `\`sandbox export\` takes no input \u2014 it exports the workspace CURRENTLY DEPLOYED to your sandbox (run \`xanots deploy --dest sandbox\` first). To compile a LOCAL workspace to JSON, use \`xanots export <file>\`.`
+    );
+  }
+  const auth = await getAccessToken(args);
+  return format === "json" ? { content: await fetchSandboxWorkspaceJson(auth), ext: "json" } : { content: await fetchSandboxMultidoc(auth), ext: "xs" };
+}
+async function runSandboxExportCommand(args) {
+  const format = args.format ?? DEFAULT_FORMAT;
+  const { content, ext } = await produce(args, format);
+  const target = resolveOutputTarget({ path: args.path, name: args.name, ext });
+  if (target.kind === "stdout") {
+    process.stdout.write(content + "\n");
+    return;
+  }
+  writeFileSync(target.path, content + "\n", "utf8");
+  step(`Exported ${format} \u2192 ${target.path}`);
+  success(`Wrote ${target.path}`);
+}
+
+export {
+  resolveOutputTarget,
+  fetchSandboxMultidoc,
+  fetchSandboxBundle,
+  runSandboxExportCommand
+};
+//# sourceMappingURL=chunk-XQ22GLYS.js.map