@xanots/sdk 0.0.1

package/dist/completion-TIPPZN7H.js

@@ -0,0 +1,298 @@
+import {
+  FLAGS,
+  flagKey,
+  flagValues,
+  getCommand,
+  liveCommandNames,
+  liveSubcommandNames
+} from "./chunk-YYRDLFSJ.js";
+
+// src/emit/completion.ts
+var COMPLETION_SHELLS = ["bash", "zsh", "fish"];
+function isCompletionShell(s) {
+  return COMPLETION_SHELLS.includes(s);
+}
+function flagTokens(ref) {
+  const spec = FLAGS[flagKey(ref)]?.spec ?? "";
+  return spec.match(/-{1,2}[a-z][a-z-]*/g) ?? [];
+}
+function tokensFor(flags) {
+  return (flags ?? []).flatMap(flagTokens);
+}
+function wantsPaths(args) {
+  return (args ?? []).some((a) => a.path === true);
+}
+function argValues(args) {
+  return [...args?.[0]?.values ?? []];
+}
+function valuedFlags(flags) {
+  const out = [];
+  for (const ref of flags ?? []) {
+    const values = flagValues(ref);
+    if (values === void 0) continue;
+    for (const token of flagTokens(ref)) out.push([token, [...values]]);
+  }
+  return out;
+}
+function describe(text) {
+  return text.replace(/`/g, "").replace(/[:]/g, " -").replace(/\s+/g, " ").trim();
+}
+function sq(text) {
+  return `'${text.replace(/'/g, `'\\''`)}'`;
+}
+function scopes() {
+  const out = [];
+  for (const name of liveCommandNames()) {
+    const spec = getCommand(name);
+    out.push({
+      key: name,
+      flags: tokensFor(spec.flags),
+      paths: wantsPaths(spec.args),
+      values: argValues(spec.args),
+      valued: valuedFlags(spec.flags)
+    });
+    for (const verb of liveSubcommandNames(name)) {
+      const sub = spec.subcommands[verb];
+      out.push({
+        key: `${name} ${verb}`,
+        flags: tokensFor(sub.flags),
+        paths: wantsPaths(sub.args),
+        values: argValues(sub.args),
+        valued: valuedFlags(sub.flags)
+      });
+    }
+  }
+  return out;
+}
+function commandRows() {
+  return liveCommandNames().map((n) => [n, describe(getCommand(n).summary)]);
+}
+function subcommandRows(command) {
+  const spec = getCommand(command);
+  return liveSubcommandNames(command).map((v) => [v, describe(spec.subcommands[v].summary)]);
+}
+function renderBash() {
+  const commands = liveCommandNames().join(" ");
+  const subLines = liveCommandNames().filter((c) => liveSubcommandNames(c).length > 0).map((c) => `    ${c}) echo ${sq(liveSubcommandNames(c).join(" "))} ;;`);
+  const flagLines = scopes().filter((s) => s.flags.length > 0).map((s) => `    ${sq(s.key)}) echo ${sq(s.flags.join(" "))} ;;`);
+  const pathLines = scopes().filter((s) => s.paths).map((s) => sq(s.key)).join("|");
+  const valueLines = scopes().filter((s) => s.values.length > 0).map((s) => `    ${sq(s.key)}) echo ${sq(s.values.join(" "))} ;;`);
+  const flagValueLines = scopes().flatMap((s) => s.valued.map(([token, values]) => [`${s.key} ${token}`, values])).map(([k, values]) => `    ${sq(k)}) echo ${sq(values.join(" "))} ;;`);
+  return `# xanots completion for bash. Regenerate after upgrading:
+#   xanots completion bash > ~/.xanots-completion.bash
+#   echo 'source ~/.xanots-completion.bash' >> ~/.bashrc
+
+_xanots_subcommands() {
+  case "$1" in
+${subLines.join("\n")}
+  esac
+}
+
+_xanots_flags() {
+  case "$1" in
+${flagLines.join("\n")}
+  esac
+}
+
+_xanots_argvalues() {
+  case "$1" in
+${valueLines.join("\n")}
+  esac
+}
+
+_xanots_flagvalues() {
+  case "$1" in
+${flagValueLines.join("\n")}
+  esac
+}
+
+_xanots() {
+  local cur cmd sub scope
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  cmd="\${COMP_WORDS[1]}"
+  sub="\${COMP_WORDS[2]}"
+  COMPREPLY=()
+
+  # Position 1 is always the command.
+  if [ "$COMP_CWORD" -eq 1 ]; then
+    COMPREPLY=( $(compgen -W ${sq(commands)} -- "$cur") )
+    return
+  fi
+
+  # Position 2 under a noun command is its verb.
+  local subs
+  subs="$(_xanots_subcommands "$cmd")"
+  if [ "$COMP_CWORD" -eq 2 ] && [ -n "$subs" ]; then
+    COMPREPLY=( $(compgen -W "$subs" -- "$cur") )
+    return
+  fi
+
+  scope="$cmd"
+  if [ -n "$subs" ]; then scope="$cmd $sub"; fi
+
+  # A dash starts a flag; anything else is a positional.
+  case "$cur" in
+    -*)
+      COMPREPLY=( $(compgen -W "$(_xanots_flags "$scope")" -- "$cur") )
+      return
+      ;;
+  esac
+
+  # Directly after a flag that takes a closed set, offer that set.
+  local prev values
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  values="$(_xanots_flagvalues "$scope $prev")"
+  if [ -n "$values" ]; then
+    COMPREPLY=( $(compgen -W "$values" -- "$cur") )
+    return
+  fi
+
+  values="$(_xanots_argvalues "$scope")"
+  if [ -n "$values" ]; then
+    COMPREPLY=( $(compgen -W "$values" -- "$cur") )
+    return
+  fi
+
+  case "$scope" in
+    ${pathLines || "''"}) COMPREPLY=( $(compgen -f -- "$cur") ) ;;
+  esac
+}
+
+complete -o default -F _xanots xanots
+`;
+}
+function renderZsh() {
+  const commandBlock = commandRows().map(([n, d]) => `    ${sq(`${n}:${d}`)}`).join("\n");
+  const familyBlocks = liveCommandNames().filter((c) => liveSubcommandNames(c).length > 0).map((c) => {
+    const rows = subcommandRows(c).map(([v, d]) => `        ${sq(`${v}:${d}`)}`).join("\n");
+    return `      ${c})
+        _xanots_verbs=(
+${rows}
+        )
+        ;;`;
+  }).join("\n");
+  const flagBlocks = scopes().filter((s) => s.flags.length > 0).map((s) => `      ${sq(s.key)}) _xanots_flags=(${s.flags.map(sq).join(" ")}) ;;`).join("\n");
+  const pathBlock = scopes().filter((s) => s.paths).map((s) => sq(s.key)).join("|");
+  const valueBlocks = scopes().filter((s) => s.values.length > 0).map((s) => `      ${sq(s.key)}) compadd ${s.values.map(sq).join(" ")}; return ;;`).join("\n");
+  const flagValueBlocks = scopes().flatMap((s) => s.valued.map(([token, values]) => [`${s.key} ${token}`, values])).map(([k, values]) => `      ${sq(k)}) compadd ${values.map(sq).join(" ")}; return ;;`).join("\n");
+  return `#compdef xanots
+# xanots completion for zsh. Regenerate after upgrading:
+#   xanots completion zsh > "\${fpath[1]}/_xanots"
+#   # \u2026then restart your shell, or: autoload -U compinit && compinit
+
+_xanots() {
+  local -a _xanots_commands _xanots_verbs _xanots_flags
+  local cmd sub scope
+  _xanots_commands=(
+${commandBlock}
+  )
+
+  if (( CURRENT == 2 )); then
+    _describe -t commands 'xanots command' _xanots_commands
+    return
+  fi
+
+  cmd="\${words[2]}"
+  case "$cmd" in
+${familyBlocks}
+  esac
+
+  if (( CURRENT == 3 )) && (( \${#_xanots_verbs} )); then
+    _describe -t subcommands "xanots $cmd subcommand" _xanots_verbs
+    return
+  fi
+
+  scope="$cmd"
+  if (( \${#_xanots_verbs} )); then
+    sub="\${words[3]}"
+    scope="$cmd $sub"
+  fi
+
+  case "$scope" in
+${flagBlocks}
+  esac
+
+  if [[ "\${words[CURRENT]}" == -* ]]; then
+    compadd -a _xanots_flags
+    return
+  fi
+
+  # Directly after a flag that takes a closed set, offer that set.
+  case "$scope \${words[CURRENT-1]}" in
+${flagValueBlocks}
+  esac
+
+  case "$scope" in
+${valueBlocks}
+  esac
+
+  case "$scope" in
+    ${pathBlock || "'__none__'"}) _files ;;
+  esac
+}
+
+_xanots "$@"
+`;
+}
+function renderFish() {
+  const lines = [
+    "# xanots completion for fish. Regenerate after upgrading:",
+    "#   xanots completion fish > ~/.config/fish/completions/xanots.fish",
+    "",
+    // Without this, fish offers files at every position.
+    "complete -c xanots -f",
+    ""
+  ];
+  for (const [name, desc] of commandRows()) {
+    lines.push(`complete -c xanots -n __fish_use_subcommand -a ${sq(name)} -d ${sq(desc)}`);
+  }
+  for (const command of liveCommandNames()) {
+    const verbs = subcommandRows(command);
+    if (verbs.length === 0) continue;
+    lines.push("");
+    for (const [verb, desc] of verbs) {
+      lines.push(
+        `complete -c xanots -n ${sq(`__fish_seen_subcommand_from ${command}; and not __fish_seen_subcommand_from ${verbs.map(([v]) => v).join(" ")}`)} -a ${sq(verb)} -d ${sq(desc)}`
+      );
+    }
+  }
+  lines.push("");
+  for (const scope of scopes()) {
+    if (scope.flags.length === 0 && !scope.paths && scope.values.length === 0) continue;
+    const words = scope.key.split(" ");
+    const condition = `__fish_seen_subcommand_from ${words.join(" ")}`;
+    const values = new Map(scope.valued);
+    for (const token of scope.flags) {
+      const bare = token.replace(/^-+/, "");
+      const which = token.startsWith("--") ? "-l" : "-s";
+      const set = values.get(token);
+      const suffix = set ? ` -r -a ${sq(set.join(" "))}` : "";
+      lines.push(`complete -c xanots -n ${sq(condition)} ${which} ${sq(bare)}${suffix}`);
+    }
+    if (scope.values.length > 0) {
+      lines.push(`complete -c xanots -n ${sq(condition)} -a ${sq(scope.values.join(" "))}`);
+    }
+    if (scope.paths) lines.push(`complete -c xanots -n ${sq(condition)} -F`);
+  }
+  return lines.join("\n") + "\n";
+}
+function renderCompletion(shell) {
+  switch (shell) {
+    case "bash":
+      return renderBash();
+    case "zsh":
+      return renderZsh();
+    case "fish":
+      return renderFish();
+  }
+}
+function runCompletionCommand(shell) {
+  process.stdout.write(renderCompletion(shell));
+}
+export {
+  COMPLETION_SHELLS,
+  isCompletionShell,
+  renderCompletion,
+  runCompletionCommand
+};
+//# sourceMappingURL=completion-TIPPZN7H.js.map

package/dist/config-NL33PN4D.js

@@ -0,0 +1,84 @@
+// src/validate/config.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve as resolvePath } from "path";
+var AUTH_CHECK_TIMEOUT_MS = 3e4;
+var ENV_INSTANCE = "XANO_VALIDATE_INSTANCE";
+var ENV_TOKEN = "XANO_VALIDATE_TOKEN";
+var ENV_WORKSPACE = "XANO_VALIDATE_WORKSPACE_ID";
+function loadDotEnv() {
+  const path = resolvePath(process.cwd(), ".env");
+  if (!existsSync(path)) return;
+  for (const line of readFileSync(path, "utf8").split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("#")) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq <= 0) continue;
+    const key = trimmed.slice(0, eq).trim();
+    let val = trimmed.slice(eq + 1).trim();
+    if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
+      val = val.slice(1, -1);
+    }
+    if (!(key in process.env)) process.env[key] = val;
+  }
+}
+function resolveOrigin(raw) {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new Error(`${ENV_INSTANCE} must be a full URL (got "${raw}"), e.g. https://your-instance.xano.io or http://localhost:8080.`);
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    throw new Error(`${ENV_INSTANCE} must be an http(s) URL (got protocol "${url.protocol}").`);
+  }
+  return url.origin;
+}
+function resolveValidateConfig(overrides = {}) {
+  loadDotEnv();
+  const rawInstance = overrides.instance ?? process.env[ENV_INSTANCE];
+  if (rawInstance === void 0 || rawInstance === "") {
+    throw new Error(`Missing target instance. Set ${ENV_INSTANCE} (a base URL) or pass --instance <url>.`);
+  }
+  const instance = resolveOrigin(rawInstance);
+  const token = process.env[ENV_TOKEN];
+  if (token === void 0 || token === "") {
+    throw new Error(`Missing token. Set ${ENV_TOKEN} in your environment or a .env file (kept out of git).`);
+  }
+  let workspaceId = overrides.workspaceId;
+  if (workspaceId === void 0) {
+    const raw = process.env[ENV_WORKSPACE];
+    if (raw !== void 0 && raw !== "") {
+      workspaceId = Number(raw);
+      if (!Number.isInteger(workspaceId) || workspaceId < 1) {
+        throw new Error(`${ENV_WORKSPACE} must be a positive integer (got "${raw}").`);
+      }
+    }
+  }
+  return { instance, token, workspaceId };
+}
+async function verifyToken(config) {
+  const url = new URL("/api:meta/auth/me", config.instance);
+  const res = await fetch(url.href, {
+    headers: { Authorization: `Bearer ${config.token}` },
+    signal: AbortSignal.timeout(AUTH_CHECK_TIMEOUT_MS)
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    throw new Error(
+      `Token check failed (${res.status} ${res.statusText}) against ${url.host}. Is ${ENV_TOKEN} valid for this instance?
+${text}`
+    );
+  }
+  let data = {};
+  try {
+    data = JSON.parse(text);
+  } catch {
+  }
+  const name = typeof data.name === "string" ? data.name : void 0;
+  return { name };
+}
+export {
+  resolveValidateConfig,
+  verifyToken
+};
+//# sourceMappingURL=config-NL33PN4D.js.map