@xano/sdk 1.0.0

package/dist/marketplace-command-K5YL42NO.js

@@ -0,0 +1,977 @@
+import {
+  assertProjectDir
+} from "./chunk-3XI5CTUE.js";
+import {
+  callsImportedAtTop,
+  registerState,
+  registerWrappers,
+  withoutComments
+} from "./chunk-5HVXPTU4.js";
+import {
+  canPrompt
+} from "./chunk-IDOTCMDV.js";
+import "./chunk-65HWOMGV.js";
+import {
+  isProjectDir
+} from "./chunk-6NNTNXN7.js";
+import {
+  retryCommand
+} from "./chunk-T5KELPAR.js";
+import "./chunk-622HUCZT.js";
+import "./chunk-NAQDMEHV.js";
+import {
+  backendDirIn
+} from "./chunk-5A2PLKZB.js";
+import "./chunk-AHJWCYQO.js";
+import "./chunk-DX4QR4B2.js";
+import {
+  addDependency,
+  refusePlugAndPlay,
+  removeDependency
+} from "./chunk-6QXLMMT3.js";
+import {
+  condenseNpmError
+} from "./chunk-ZFDZKNGG.js";
+import "./chunk-FWD7AL6N.js";
+import {
+  MarketplaceModuleNotFoundError,
+  ModuleNotFoundError,
+  fetchCatalogue,
+  fetchModule,
+  isLocalSpecifier,
+  nearPackage,
+  notInMarketplaceError,
+  resolveMarketplaceSpec,
+  resolveMarketplaceSpecs,
+  resolveProjectModuleListing,
+  searchCatalogue,
+  unlistedModuleError
+} from "./chunk-2GNFDZA2.js";
+import {
+  declaredDependencies,
+  readProjectManifest,
+  readToolchainBlock
+} from "./chunk-JTUKLCXS.js";
+import "./chunk-4KHEMC32.js";
+import "./chunk-ROY4YAEQ.js";
+import {
+  addCommandFor,
+  installCommandFor,
+  removeArgs,
+  removeCommandFor
+} from "./chunk-WRBKLYSJ.js";
+import {
+  localPackageName,
+  localPathOf,
+  moduleKind,
+  packageNameOf,
+  readInstalledManifestState
+} from "./chunk-3LDULPRE.js";
+import "./chunk-XW6KISBB.js";
+import "./chunk-AWQ7BQTQ.js";
+import "./chunk-EUUUMY7J.js";
+import "./chunk-YLDALTWZ.js";
+import "./chunk-5FBYXK5P.js";
+import "./chunk-LLNZGEFK.js";
+import "./chunk-QXTKSOFI.js";
+import "./chunk-X2NL4KUO.js";
+import "./chunk-UCQ2VUTG.js";
+import "./chunk-DGWHAVRG.js";
+import {
+  UsageError,
+  blank,
+  detail,
+  formatFields,
+  indentBlock,
+  info,
+  installedCliAt,
+  isMachineOutput,
+  missingArgument,
+  printHuman,
+  relForwardSlash,
+  safeText,
+  spellProjectCli,
+  spinner,
+  stdoutStyle,
+  style,
+  success,
+  terminalText,
+  unknownFlag,
+  warn,
+  writeJson
+} from "./chunk-PTHVMXZI.js";
+import "./chunk-UTI5G6OJ.js";
+import "./chunk-2EZ3ZJZZ.js";
+import "./chunk-5ZSO4T2G.js";
+import "./chunk-TFFGOFVZ.js";
+import "./chunk-VAX3UZOY.js";
+import "./chunk-OHX6MIUZ.js";
+import "./chunk-36JUQZVQ.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/emit/marketplace-command.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { dirname, join, resolve } from "path";
+function resolvePackage(args, verb = "install") {
+  const typed = args.positionals[0];
+  const pkg = typed === void 0 ? typed : /^(?:(?:@[^/\s]+\/)?[^@/\s]+@)?npm:(.+)$/i.exec(typed)?.[1] ?? typed;
+  if (pkg === void 0 || pkg === "") {
+    throw missingArgument("package", { command: "marketplace", subcommand: verb });
+  }
+  if (verb !== "details" && !pkg.startsWith("-") && packageNameOf(pkg) === "@xano/sdk") {
+    throw new UsageError(
+      `\`xanosdk marketplace ${verb}\` manages modules, and @xano/sdk is the SDK this project is built on, not a module` + (verb === "remove" ? ` \u2014 the backend cannot load without it.` : `.`) + ` To move it to the latest release, run \`xanosdk upgrade\`.`
+    );
+  }
+  if (pkg.startsWith("-")) {
+    throw new UsageError(
+      verb === "details" ? `\`xanosdk marketplace details\`: "${pkg}" starts with a dash, so it is a mistyped flag, not a package.` : `\`xanosdk marketplace ${verb}\`: "${pkg}" starts with a dash, so npm would read it as a flag, not a package.`,
+      { helpFor: { command: "marketplace", subcommand: verb } }
+    );
+  }
+  return pkg;
+}
+function openVerb(args, verb) {
+  refusePromptFlag(args, verb);
+  const pkg = resolvePackage(args, verb);
+  const dir = process.cwd();
+  assertProjectDir(dir, {
+    what: `\`xanosdk marketplace ${verb}\` runs inside a Xano SDK project`,
+    remedy: "cd into your project first, or run `xanosdk init` to create one."
+  });
+  if (verb !== "remove") refuseOutsideXanoSdkProject(dir, verb);
+  refusePlugAndPlay(dir, retryCommand(args, { command: `marketplace ${verb}` }).command);
+  return { pkg, dir };
+}
+function refuseOutsideXanoSdkProject(dir, verb) {
+  if (isProjectDir(dir)) return;
+  throw new UsageError(
+    `\`xanosdk marketplace ${verb}\` wires a module into a Xano SDK project, and ${dir} is not one \u2014 it has no backend entry (\`xano/index.ts\`) and no \`.xano/\` from an earlier deploy.
+  cd into your project first, or run \`xanosdk init\` to create one.`
+  );
+}
+async function refuseCommaList(spec) {
+  if (isLocalSpecifier(spec) || !spec.includes(",")) return;
+  const names = [...new Set(spec.split(",").map((s) => s.trim()).filter((s) => s !== ""))];
+  if (names.length < 2) return;
+  const pkgs = await resolveMarketplaceSpecs(names, "xanosdk marketplace install").catch((err) => {
+    if (!(err instanceof MarketplaceModuleNotFoundError) || err.corrected === void 0) throw err;
+    const fixed = new MarketplaceModuleNotFoundError(
+      `${err.message} It installs one module at a time: run ${err.corrected.map((p) => `\`xanosdk marketplace install ${p}\``).join(", then ")}.`,
+      err.suggestions ?? (err.suggestion === void 0 ? [] : [err.suggestion])
+    );
+    throw fixed;
+  });
+  throw new UsageError(
+    `\`xanosdk marketplace install\` installs one module at a time, and "${spec}" names ${pkgs.length}. Run ${pkgs.map((p) => `\`xanosdk marketplace install ${p}\``).join(", then ")}.`,
+    { hintFor: { command: "marketplace", subcommand: "install" } }
+  );
+}
+async function runMarketplaceInstallCommand(args) {
+  const opened = openVerb(args, "install");
+  const dir = opened.dir;
+  await refuseCommaList(opened.pkg);
+  const pkg = await resolveMarketplaceSpec(opened.pkg, "xanosdk marketplace install");
+  const name = localPackageName(pkg, dir) ?? packageNameOf(pkg);
+  const projectManifest = readProjectManifest(dir);
+  const added = projectManifest === null || !isDependency(projectManifest, name);
+  const sameSource = pkg === name || sameLocalSource(dir, pkg, projectManifest, name);
+  const alreadyInstalled = !added && sameSource && readInstalledManifestState(dir, name).kind !== "absent";
+  if (alreadyInstalled) await refuseUnclaimedFlags(args, dir, "install");
+  const installed = alreadyInstalled ? null : await install(pkg, dir, "install", retryCommand(args, { command: "marketplace install" }).command);
+  if (!alreadyInstalled) await refuseUnclaimedFlags(args, dir, "install", added ? { undo: name } : {});
+  await assertInstalledSdkPeer(name, dir, { undo: added, verb: "install" });
+  if (!alreadyInstalled) blank();
+  const shown = pkg === name ? pkg : `${name} (${pkg})`;
+  if (alreadyInstalled) info(`${shown} is already installed \u2014 npm was not run.`);
+  else success(`Installed ${shown}.`);
+  const { syncContributions } = await import("./sync-contributions-UCEROO26.js");
+  const sync = await syncContributions(dir, {
+    apply: true,
+    ask: "unanswered",
+    host: "install",
+    json: args.json,
+    unknownFlags: args.unknownFlags
+  });
+  await reportNextStep(dir, name);
+  reportSync(sync, args.json);
+  if (isMachineOutput(args)) {
+    writeJson({
+      installed: pkg,
+      alreadyInstalled,
+      legacyPeerDeps: installed !== null && installed.peerConflict !== null,
+      modules: sync.modules,
+      unconfigured: sync.unconfigured,
+      written: sync.written,
+      changed: sync.changed
+    });
+  }
+}
+function sameLocalSource(dir, spec, manifest, name) {
+  const path = localPathOf(spec);
+  if (path === void 0 || manifest === null) return false;
+  for (const block of ["dependencies", "devDependencies", "optionalDependencies"]) {
+    const range = manifest[block]?.[name];
+    if (typeof range === "string" && range.startsWith("file:")) return resolve(dir, range.slice(5)) === resolve(dir, path);
+  }
+  return false;
+}
+async function runMarketplaceReinstallCommand(args) {
+  const opened = openVerb(args, "reinstall");
+  const dir = opened.dir;
+  const { pkg, listing } = await resolveProjectModuleListing(opened.pkg, dir);
+  if (listing === "unlisted") throw await unlistedModuleError("xanosdk marketplace reinstall", pkg);
+  assertDependency(dir, pkg, listing);
+  const onDisk = classifyInstalled(dir, pkg);
+  if (onDisk === "workspace" || onDisk === "ordinary") refuseNotReaskable(dir, pkg, onDisk);
+  if (onDisk !== "absent") await refuseUnclaimedFlags(args, dir, "reinstall", { enable: pkg });
+  await install(pkg, dir, "reinstall", retryCommand(args, { command: "marketplace reinstall" }).command);
+  if (onDisk === "absent") await refuseUnclaimedFlags(args, dir, "reinstall", { enable: pkg });
+  await assertInstalledSdkPeer(pkg, dir, { undo: false, verb: "reinstall" });
+  const declared = await assertReaskable(dir, pkg);
+  blank();
+  success(`Reinstalled ${pkg}.`);
+  const disabled = announceReEnable(pkg, declared.config);
+  await reportMissingInverse(pkg, declared);
+  const { syncContributions } = await import("./sync-contributions-UCEROO26.js");
+  const sync = await syncContributions(dir, {
+    apply: true,
+    ask: "package",
+    pkg,
+    host: "reinstall",
+    // The re-enabling, as a pending change rather than a write already made.
+    // Discovery folds it in before deciding what to import, so the flag and
+    // everything the re-ask settles land in the reconciler's ONE write — and a
+    // refusal leaves the module exactly as switched off as it was.
+    ...disabled ? { enable: [pkg] } : {},
+    json: args.json,
+    // The same obligation `install` carries: the parser deferred the check on
+    // this verb, it did not cancel it. Whatever no question of this module's
+    // claims is refused by name, naming `marketplace reinstall`.
+    unknownFlags: args.unknownFlags
+  });
+  reportSync(sync, args.json);
+  if (isMachineOutput(args)) {
+    const mod = sync.modules.find((m) => m.pkg === pkg);
+    writeJson({
+      reinstalled: pkg,
+      modules: sync.modules,
+      unconfigured: sync.unconfigured,
+      written: sync.written,
+      changed: sync.changed,
+      ...mod?.sources === void 0 ? {} : { sources: mod.sources },
+      // Hoisted alongside `sources` for the same reason it is: this verb is
+      // ABOUT one package, so its caller should not have to find it in the
+      // table. Names the flag that answers each question, which a caller
+      // cannot derive from the ids `sources` is keyed by.
+      ...mod?.flags === void 0 ? {} : { flags: mod.flags }
+    });
+  }
+}
+async function refuseUnclaimedFlags(args, dir, verb, opts = {}) {
+  if (args.unknownFlags.length === 0) return;
+  const { undo, enable } = opts;
+  const [{ discoverToolchainPlugins }, { questionSets, flagFor, hostHelpTarget }] = await Promise.all([
+    import("./toolchain-modules-5EAZUONB.js"),
+    import("./plugin-questions-JTSYA74Q.js")
+  ]);
+  let flags;
+  try {
+    const { loaded } = await discoverToolchainPlugins(dir, {
+      frozen: false,
+      configuring: true,
+      ...enable === void 0 ? {} : { configOverride: { [enable]: { enabled: true } } }
+    });
+    flags = questionSets(loaded).flatMap((set) => set.questions.map(flagFor));
+  } catch {
+    return;
+  }
+  const claimable = (arg) => {
+    if (!arg.startsWith("--")) return false;
+    const name = arg.slice(2).split("=", 1)[0];
+    return flags.some((f) => name === f || name === `no-${f}`);
+  };
+  const unclaimed = args.unknownFlags.filter((arg) => !claimable(arg));
+  if (unclaimed.length === 0) return;
+  let undone = false;
+  if (undo !== void 0) {
+    try {
+      await uninstall(undo, dir);
+      undone = true;
+    } catch {
+    }
+  }
+  const err = unknownFlag(unclaimed, hostHelpTarget(verb), flags);
+  if (undo !== void 0) {
+    err.message += undone ? `
+  ${undo} was uninstalled again, so this project is exactly as it was.` : `
+  ${undo} is still installed: run \`xanosdk marketplace remove ${undo}\` to drop it.`;
+  }
+  throw err;
+}
+function isDependency(manifest, pkg) {
+  return declaredDependencies(manifest).includes(pkg);
+}
+function inProject(dir, pkg) {
+  const manifest = readProjectManifest(dir);
+  return manifest !== null && isDependency(manifest, pkg) || pkg in readToolchainBlock(dir, manifest);
+}
+function installedModules(dir) {
+  const manifest = readProjectManifest(dir);
+  const modules = (manifest === null ? [] : declaredDependencies(manifest)).filter((pkg) => {
+    const state = readInstalledManifestState(dir, pkg);
+    const field = state.kind === "ok" ? state.manifest["xanosdk"] : void 0;
+    return typeof field === "object" && field !== null;
+  });
+  return [.../* @__PURE__ */ new Set([...modules, ...Object.keys(readToolchainBlock(dir, manifest))])];
+}
+function classifyInstalled(dir, pkg) {
+  const state = readInstalledManifestState(dir, pkg);
+  if (state.kind !== "ok") return "absent";
+  const field = state.manifest["xanosdk"];
+  if (typeof field !== "object" || field === null) return "ordinary";
+  try {
+    return moduleKind(pkg, state.manifest);
+  } catch (error) {
+    warn(
+      `${pkg} does not declare a module kind we recognize, so it is read as an ordinary package.`,
+      "module.kind-unknown",
+      [error instanceof Error ? error.message : String(error)]
+    );
+    return "ordinary";
+  }
+}
+function hasXanoSdkField(dir, pkg) {
+  const state = readInstalledManifestState(dir, pkg);
+  return state.kind === "ok" && typeof state.manifest["xanosdk"] === "object" && state.manifest["xanosdk"] !== null;
+}
+function refusal(message, next) {
+  return new UsageError(`${message} ${next}`);
+}
+function assertDependency(dir, pkg, listing) {
+  const manifest = readProjectManifest(dir);
+  if (manifest !== null && isDependency(manifest, pkg)) return;
+  throw refusal(
+    `\`xanosdk marketplace reinstall\`: ${pkg} is not a dependency of this project, so there are no settings to re-ask.`,
+    // `install` is the next step only for a name it would install — a module
+    // the catalogue lists. Anything else it refuses too (exit 8).
+    listing === "catalogue" || listing === "project" ? `Run \`xanosdk marketplace install ${pkg}\` to add it.` : `Check the name \u2014 \`xanosdk marketplace list\` shows what is published.`
+  );
+}
+async function assertReaskable(dir, pkg) {
+  const { declaredToolchainPlugins } = await import("./toolchain-modules-5EAZUONB.js");
+  const declared = declaredToolchainPlugins(dir).find((d) => d.pkg === pkg);
+  if (declared !== void 0 && declared.unreadable === void 0) return declared;
+  const installed = classifyInstalled(dir, pkg);
+  if (installed === "absent") {
+    throw refusal(
+      `\`xanosdk marketplace reinstall\`: ${pkg} is a dependency but is not installed, so its questions cannot be read.`,
+      `Run \`${installCommandFor(dir)}\` to restore node_modules, then re-run this command.`
+    );
+  }
+  return refuseNotReaskable(dir, pkg, installed === "workspace" ? "workspace" : "ordinary");
+}
+function refuseNotReaskable(dir, pkg, installed) {
+  const workspace = installed === "workspace";
+  const importers = workspace ? backendImporters(dir, pkg) : [];
+  throw refusal(
+    workspace ? `\`xanosdk marketplace reinstall\`: ${pkg} is a workspace module, not a toolchain module \u2014 it contributes no project settings to re-ask.` : `\`xanosdk marketplace reinstall\`: ${pkg} is an ordinary npm package, not a Xano SDK toolchain module, so it has no questions to re-ask.`,
+    !workspace ? `Run \`${addCommandFor(dir, pkg)}\` to update it.` : importers.length > 0 ? `It is already imported in ${importers.join(", ")}; run \`${addCommandFor(dir, pkg)}\` to update it.` : `Import it in \`xano/index.ts\` and register it onto your workspace.`
+  );
+}
+function announceReEnable(pkg, config) {
+  if (config?.["enabled"] !== false) return false;
+  warn(
+    `${pkg} is switched off in this project (\`"enabled": false\`).`,
+    "module.disabled",
+    [
+      `Re-enabling it, because re-asking a module its questions is asking whether you want it. Answer no to its enabling question to switch it straight back off.`
+    ]
+  );
+  return true;
+}
+async function reportMissingInverse(pkg, declared) {
+  if (declared.pluginFile === null) return;
+  if (declared.config === null || Object.keys(declared.config).length === 0) return;
+  const { loadFile } = await import("./module-manifest-JFGHU2TC.js");
+  const loaded = await loadFile(declared.pluginFile);
+  if (loaded.kind !== "loaded") return;
+  const plugin = loaded.exports["default"];
+  if (typeof plugin !== "object" || plugin === null) return;
+  const shape = plugin;
+  if ((shape.questions?.length ?? 0) === 0) return;
+  if (typeof shape.answersFromConfig === "function") return;
+  detail(
+    `${pkg} does not map its stored settings back to answers, so the questions below start from the defaults it ships rather than from this project's current settings.`
+  );
+}
+async function runMarketplaceRemoveCommand(args) {
+  const opened = openVerb(args, "remove");
+  const dir = opened.dir;
+  const { pkg, listing } = await resolveProjectModuleListing(opened.pkg, dir);
+  if (listing === "catalogue" || listing === "unlisted" || listing === "unknown" && !inProject(dir, pkg)) {
+    success(`${pkg} is not installed in this project \u2014 nothing to remove.`);
+    const near = nearPackage(opened.pkg, installedModules(dir));
+    if (near !== void 0) {
+      detail(
+        `Did you mean \`${near.hit}\`${near.pkg === near.hit ? "" : ` (${near.pkg})`}? It is installed: \`xanosdk marketplace remove ${near.hit}\`.`
+      );
+    }
+    const followUp2 = await afterWorkspaceModuleRemoved(dir);
+    if (isMachineOutput(args)) {
+      writeJson({
+        removed: pkg,
+        alreadyGone: true,
+        droppedConfig: false,
+        modules: [],
+        unconfigured: [],
+        written: [],
+        changed: followUp2.routes === "written",
+        routes: followUp2.routes,
+        lockOrphans: followUp2.lockOrphans,
+        ...near === void 0 ? {} : { suggestion: near.hit }
+      });
+    }
+    return;
+  }
+  const target = await assertRemovable(dir, pkg, args.json === true ? " --json" : "");
+  if (target.dependency) {
+    await uninstall(pkg, dir, retryCommand(args, { command: "marketplace remove" }).command);
+    blank();
+    success(`Uninstalled ${pkg}.`);
+  } else {
+    blank();
+    warn(
+      `${pkg} is no longer a dependency, but this project still records settings for it.`,
+      "module.stale-settings",
+      [`Nothing to uninstall \u2014 dropping what was left behind, which nothing else reports.`]
+    );
+  }
+  const { syncContributions } = await import("./sync-contributions-UCEROO26.js");
+  const sync = await syncContributions(dir, {
+    apply: true,
+    ask: "none",
+    host: "remove",
+    json: args.json
+  });
+  reportSync(sync, args.json);
+  if (!sync.removed.includes(pkg) && !target.workspace) {
+    detail(`No settings or file lines were recorded for ${pkg}, so there was nothing else to drop.`);
+  }
+  const followUp = await afterWorkspaceModuleRemoved(dir);
+  if (isMachineOutput(args)) {
+    writeJson({
+      removed: pkg,
+      alreadyGone: false,
+      droppedConfig: sync.removed.includes(pkg),
+      modules: sync.modules,
+      unconfigured: sync.unconfigured,
+      written: sync.written,
+      // `npm uninstall` rewrote package.json even when the reconcile had nothing to do.
+      changed: sync.changed || target.dependency || followUp.routes === "written",
+      routes: followUp.routes,
+      lockOrphans: followUp.lockOrphans
+    });
+  }
+}
+async function afterWorkspaceModuleRemoved(dir) {
+  const backend = backendDirIn(dir);
+  const entry = join(backend, "index.ts");
+  const rel = relForwardSlash(dir, backend) || ".";
+  if (!existsSync(entry)) return { routes: "absent", lockOrphans: 0 };
+  const routesFile = join(backend, "routes.gen.ts");
+  try {
+    const { refreshRouteManifest } = await import("./cli.js");
+    const { manifest, lockOrphans } = await refreshRouteManifest(entry, routesFile);
+    if (manifest === "written") info(`Regenerated ${rel}/routes.gen.ts without the removed module's endpoints.`);
+    if (manifest === "skipped") {
+      warn(`${rel}/routes.gen.ts could not be regenerated here \u2014 run \`npm run xano:routes\` and commit it.`, "routes.not-written");
+    }
+    if (lockOrphans > 0) {
+      warn(
+        `${rel}/xano.lock still pins ${lockOrphans} ${lockOrphans === 1 ? "entry" : "entries"} the workspace no longer exports (the removed module's objects). Once they are gone for good: \`xanosdk lock prune ./${rel}/index.ts --yes\`.`,
+        "lock.module-orphans"
+      );
+    }
+    return { routes: manifest, lockOrphans };
+  } catch (err) {
+    warn(
+      `Could not load ${rel}/index.ts to update what the module left behind (${err instanceof Error ? err.message.split("\n")[0] : String(err)}). Run \`npm run xano:routes\` and \`xanosdk lock prune ./${rel}/index.ts --yes\` once it loads.`,
+      "module.load-failed"
+    );
+    return { routes: "skipped", lockOrphans: 0 };
+  }
+}
+async function assertRemovable(dir, pkg, outputFlag = "") {
+  const manifest = readProjectManifest(dir);
+  const dependency = manifest !== null && isDependency(manifest, pkg);
+  const configured = pkg in readToolchainBlock(dir, manifest);
+  if (!dependency && !configured) {
+    throw refusal(
+      `\`xanosdk marketplace remove\`: ${pkg} is not a dependency of this project and this project records no settings for it, so there is nothing to remove.`,
+      `Check the name \u2014 \`xanosdk marketplace list\` shows what is published.`
+    );
+  }
+  const { declaredToolchainPlugins } = await import("./toolchain-modules-5EAZUONB.js");
+  const declared = declaredToolchainPlugins(dir).find((d) => d.pkg === pkg);
+  if (declared?.config?.["enabled"] === false) {
+    throw refusal(
+      `\`xanosdk marketplace remove\`: ${pkg} is switched off in this project (\`"enabled": false\`), which is not the same as removed \u2014 it is still installed and still in dependencies.`,
+      `Run \`xanosdk marketplace reinstall ${pkg}\` to switch it back on if you still want it, or delete its entry from this project's package.json "xanosdk" block and re-run this command to drop it for good.`
+    );
+  }
+  if (declared !== void 0 || !dependency) return { dependency };
+  const installed = classifyInstalled(dir, pkg);
+  if (installed === "absent") {
+    throw refusal(
+      `\`xanosdk marketplace remove\`: ${pkg} is a dependency but is not installed, so there is no way to tell whether it contributed anything to remove.`,
+      `Run \`${removeCommandFor(dir, pkg)}\` \u2014 this project records no Xano SDK settings for it.`
+    );
+  }
+  if (installed === "workspace") {
+    const importers2 = backendImporters(dir, pkg);
+    if (importers2.length > 0) {
+      throw refusal(
+        `\`xanosdk marketplace remove\`: ${pkg} is a workspace module your backend still imports (${importers2.join(", ")}), so uninstalling it would break the next export.`,
+        `Drop its import and registration from ${importers2.length === 1 ? "that file" : "those files"}, then re-run \`xanosdk marketplace remove ${pkg}${outputFlag}\`.`
+      );
+    }
+    return { dependency, workspace: true };
+  }
+  const importers = backendImporters(dir, pkg);
+  throw refusal(
+    `\`xanosdk marketplace remove\`: ${pkg} is an ordinary npm package, not a Xano SDK module, so it contributed nothing this command would reconcile` + (importers.length > 0 ? ` \u2014 but your backend imports it (${importers.join(", ")}).` : `.`),
+    importers.length > 0 ? `Drop its import and registration from ${importers.length === 1 ? "that file" : "those files"}, then run \`${removeCommandFor(dir, pkg)}\`.` : `Run \`${removeCommandFor(dir, pkg)}\`.`
+  );
+}
+var SOURCE_FILE = /\.(?:[cm]?[jt]s|tsx|jsx)$/;
+function backendSources(dir) {
+  const found = [];
+  const walk = (at) => {
+    let entries;
+    try {
+      entries = readdirSync(at, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+      const full = join(at, entry.name);
+      if (entry.isDirectory()) walk(full);
+      else if (entry.isFile() && SOURCE_FILE.test(entry.name)) {
+        try {
+          found.push({ rel: relForwardSlash(dir, full), code: withoutComments(readFileSync(full, "utf8")) });
+        } catch {
+        }
+      }
+    }
+  };
+  walk(backendDirIn(dir));
+  return found.sort((a, b) => a.rel < b.rel ? -1 : a.rel > b.rel ? 1 : 0);
+}
+function specifierOf(pkg) {
+  const escaped = pkg.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`["'\`]${escaped}(?:/[^"'\`]*)?["'\`]`);
+}
+function backendImporters(dir, pkg) {
+  const specifier = specifierOf(pkg);
+  return backendSources(dir).filter((file) => specifier.test(file.code)).map((file) => file.rel);
+}
+function relativeSpecifiers(code) {
+  const found = [];
+  const valueCode = code.replace(/(?<![\w$.])(?:import|export)\s+type\s+(?!from\b)[^;]*?\bfrom\s*(["'`])[^"'`\n]*\1/g, "");
+  for (const m of valueCode.matchAll(/(?:\bfrom|\bimport\s*\(?|\brequire\s*\()\s*(["'`])(\.{1,2}\/[^"'`\n]*)\1/g)) found.push(m[2]);
+  return found;
+}
+function resolveRelative(from, specifier) {
+  const base = resolve(dirname(from), specifier);
+  const twin = base.replace(/\.([cm]?)js(x?)$/, ".$1ts$2");
+  const exts = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+  const candidates = [base, twin, ...exts.map((e) => base + e), ...exts.map((e) => join(base, `index${e}`))];
+  for (const candidate of candidates) {
+    if (candidate.split(/[\\/]/).includes("node_modules")) continue;
+    try {
+      if (statSync(candidate).isFile() && SOURCE_FILE.test(candidate)) return candidate;
+    } catch {
+    }
+  }
+  return void 0;
+}
+function reachableSources(dir) {
+  const entry = join(backendDirIn(dir), "index.ts");
+  if (!existsSync(entry)) return void 0;
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  const queue = [entry];
+  while (queue.length > 0) {
+    const file = queue.shift();
+    if (seen.has(file)) continue;
+    seen.add(file);
+    let code;
+    try {
+      code = withoutComments(readFileSync(file, "utf8"));
+    } catch {
+      continue;
+    }
+    found.push({ rel: relForwardSlash(dir, file), code });
+    for (const specifier of relativeSpecifiers(code)) {
+      const next = resolveRelative(file, specifier);
+      if (next !== void 0) queue.push(next);
+    }
+  }
+  return found;
+}
+function backendRegistration(dir, pkg, register) {
+  const registrars = [];
+  const unknown = [];
+  const files = reachableSources(dir) ?? backendSources(dir);
+  for (const file of files) {
+    const state = registerState(file.code, pkg, register);
+    if (state === "yes") registrars.push(file.rel);
+    else if (state === "unknown") {
+      const wrappers = registerWrappers(file.code, pkg, register);
+      const called = wrappers.length > 0 && files.some((other) => other !== file && callsImportedAtTop(other.code, wrappers));
+      (called ? registrars : unknown).push(file.rel);
+    }
+  }
+  return { registrars, unknown };
+}
+async function uninstall(pkg, dir, rerun) {
+  const spin = spinner(`Uninstalling ${style.bold(pkg)}`);
+  let result;
+  try {
+    result = await removeDependency(dir, pkg, rerun);
+  } finally {
+    spin.stop();
+  }
+  const { manager } = result.site;
+  const verb = removeArgs(manager, pkg)[0];
+  if (result.status === 0 && !result.stillListed) return;
+  process.stderr.write(terminalText(result.output.trimEnd()) + "\n");
+  throw new Error(
+    (result.status === 0 ? `${manager} ${verb} ${pkg} exited 0, but this project's package.json still lists ${pkg}. ` : `${manager} ${verb} ${pkg} failed (exit ${result.status}). `) + `Nothing was reconciled: ${pkg} is still a dependency, so this project's settings and file lines for it are exactly as they were. Fix what ${manager} reported and re-run \`xanosdk marketplace remove ${pkg}\`.`
+  );
+}
+async function assertInstalledSdkPeer(pkg, dir, opts) {
+  const [{ sdkPeerSkew }, { readVersion }, { readInstalledManifest }] = await Promise.all([
+    import("./toolchain-modules-5EAZUONB.js"),
+    import("./cli.js"),
+    import("./module-manifest-JFGHU2TC.js")
+  ]);
+  const manifest = readInstalledManifest(dir, pkg);
+  if (manifest === null) return;
+  const undo = async () => {
+    if (!opts.undo) return false;
+    try {
+      await uninstall(pkg, dir);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const retired = retiredSdkNamed(manifest);
+  if (retired !== void 0) {
+    const version = typeof manifest["version"] === "string" ? `@${manifest["version"]}` : "";
+    const undone2 = await undo();
+    throw refusal(
+      `${pkg}${version} is built for the retired \`${retired}\`, not \`@xano/sdk\` \u2014 it cannot load in this project.`,
+      undone2 ? `It was uninstalled again, so this project is exactly as it was. Install the version built for this SDK with \`xanosdk marketplace install ${pkg}\`.` : `${pkg}${version} is still installed and still a dependency, so every command that loads the backend fails until it is replaced. Install the version built for this SDK over it with \`xanosdk marketplace install ${pkg}@latest\`.`
+    );
+  }
+  const sdkVersion = readVersion();
+  const range = sdkPeerSkew(manifest, sdkVersion);
+  if (range === null) return;
+  const undone = await undo();
+  throw refusal(
+    `${pkg} requires \`@xano/sdk\` ${range}, and this is ${sdkVersion} \u2014 its hooks were built against a contract this SDK does not have, so it would register and apply nothing.`,
+    undone ? `It was uninstalled again, so this project is exactly as it was. Upgrade with \`${addCommandFor(dir, "@xano/sdk@latest")}\` and re-run this command, or install a ${pkg} built for this SDK.` : `${pkg} is still installed and still a dependency, and every command that loads modules will refuse it until this is settled. Upgrade with \`${addCommandFor(dir, "@xano/sdk@latest")}\`, or run \`xanosdk marketplace remove ${pkg}\` to drop it and its settings together.`
+  );
+}
+var RETIRED_SDK_PACKAGES = ["@xanosdk/core", "@xanosdk/sdk"];
+function retiredSdkNamed(manifest) {
+  return RETIRED_SDK_PACKAGES.find(
+    (retired) => ["dependencies", "peerDependencies", "optionalDependencies"].some((field) => {
+      const deps = manifest[field];
+      return typeof deps === "object" && deps !== null && Object.prototype.hasOwnProperty.call(deps, retired);
+    })
+  );
+}
+async function install(pkg, dir, verb, rerun) {
+  const spin = spinner(`Installing ${style.bold(pkg)}`);
+  let result;
+  try {
+    result = await addDependency(dir, pkg, {
+      rerun,
+      onLink: (member) => spin.update(`Linking ${member} into the npm workspace`),
+      onRetry: () => spin.update(`Installing ${pkg} (retrying with --legacy-peer-deps)`)
+    });
+  } finally {
+    spin.stop();
+  }
+  if (result.status !== 0) {
+    if (result.peerConflict !== null) {
+      warn(
+        result.retried ? `${pkg} declares a peer range this project does not satisfy; --legacy-peer-deps did not resolve it either.` : `${pkg} declares a peer range this project does not satisfy, and the install ran out of time before --legacy-peer-deps could be tried.`,
+        "module.peer-unresolved"
+      );
+      process.stderr.write(terminalText(result.peerConflict.trimEnd()) + "\n");
+    }
+    process.stderr.write(terminalText(result.output.trimEnd()) + "\n");
+    throw new Error(`${addCommandFor(dir, pkg)} failed (exit ${result.status}).`);
+  }
+  if (result.recorded === void 0 || result.landed === void 0 && verb === "install") {
+    process.stderr.write(terminalText(result.output.trimEnd()) + "\n");
+    throw new Error(
+      `${addCommandFor(dir, pkg)} exited 0, but ` + (result.recorded === void 0 ? `this project's package.json does not list ${pkg}` : `${result.recorded} does not resolve from this project`) + ` \u2014 nothing was installed.`
+    );
+  }
+  if (result.peerConflict !== null) {
+    const refused = condenseNpmError(result.peerConflict);
+    warn(
+      `${pkg} declares a peer range this project does not satisfy \u2014 installed with --legacy-peer-deps.`,
+      "module.legacy-peer-deps",
+      ["npm refused the tree it would otherwise have installed:", ...refused !== "" ? [refused] : []]
+    );
+  }
+  return result;
+}
+function reportSync(sync, json) {
+  const configured = sync.modules.filter((m) => m.action === "configured");
+  if (configured.length > 0 && !canPrompt({ json })) {
+    detail(
+      json === true ? `--json: nothing was prompted, so each setting is this project's stored value or the module's declared default.` : `Not a terminal, so nothing was prompted \u2014 each setting is this project's stored value or the module's declared default.`
+    );
+  }
+  for (const mod of sync.modules) {
+    if (mod.action === "configured") detail(`Configured ${mod.pkg}.`);
+    if (mod.action === "removed") detail(`Dropped the settings for ${mod.pkg}, which is no longer a dependency.`);
+  }
+  for (const pkg of sync.unconfigured) {
+    warn(`${pkg} was left unconfigured, so it runs on its own defaults.`, "module.unconfigured");
+  }
+}
+async function reportNextStep(dir, spec) {
+  const pkg = packageNameOf(spec);
+  const kind = classifyInstalled(dir, pkg);
+  if (kind === "absent") return;
+  if (kind === "ordinary" && hasXanoSdkField(dir, pkg)) return;
+  if (kind === "toolchain") {
+    detail(
+      `Extends the CLI (nothing to register). Configured in this project's package.json "xanosdk" block.`
+    );
+    return;
+  }
+  const { inProject: inProject2, partitionRegistrations, readRegistration, renderImports, renderRegisterCall } = await import("./init-modules-RY7UHAOL.js");
+  const registration = await readRegistration(dir, pkg);
+  if (kind === "ordinary" && !("register" in registration)) return;
+  if (!("register" in registration)) {
+    const specifier = specifierOf(pkg);
+    const importers = (reachableSources(dir) ?? backendSources(dir)).filter((f) => specifier.test(f.code)).map((f) => f.rel);
+    detail(
+      importers.length > 0 ? `Already imported in ${importers.join(", ")} \u2014 nothing else to wire.` : `Import it in your backend (\`xano/index.ts\`) and register it onto your workspace.`
+    );
+    return;
+  }
+  const { registrars, unknown } = backendRegistration(dir, pkg, registration.register);
+  if (registrars.length > 0) {
+    detail(`Already registered in ${registrars.join(", ")} \u2014 nothing else to wire.`);
+    return;
+  }
+  const entry = join(backendDirIn(dir), "index.ts");
+  const entryRel = relForwardSlash(dir, entry);
+  if (unknown.length > 0) {
+    detail(
+      `Could not tell whether ${pkg} is registered: ${unknown.join(", ")} reaches it in a way this check cannot follow. Check ${entryRel} \u2014 it is wired when \`${registration.register}(\u2026)\` runs once on your workspace.`
+    );
+    return;
+  }
+  const manifest = readProjectManifest(dir);
+  const present = new Set(manifest === null ? [] : declaredDependencies(manifest));
+  const cli = `${inProject2(dir)}${installedCliAt(dir)}`;
+  const missing = [
+    ...new Set(
+      Object.values(registration.options).filter((ref) => "package" in ref && !present.has(ref.package)).map((ref) => ref.package)
+    )
+  ];
+  const { unwired } = partitionRegistrations([registration], present);
+  if (unwired.length > 0 && (missing.length === 0 || unwired[0].options === void 0)) {
+    detail(`Not registered yet \u2014 import it in your backend (\`xano/index.ts\`) and register it onto your workspace; ${spellProjectCli(unwired[0].reason, installedCliAt(dir)).replace(/`npx /g, `\`${inProject2(dir)}npx `)}.`);
+    return;
+  }
+  const first = missing.length === 0 ? "" : `  First add ${missing.join(", ")}, which it takes an option from: ${missing.map((p) => `\`${cli} marketplace install ${p}\``).join(", then ")}, wired as that prints.
+`;
+  const app = workspaceBinding(entry);
+  const call = renderRegisterCall(registration.register, registration.options, app);
+  const lines = [
+    ...renderImports([registration]),
+    registration.binding === null ? call : `const ${registration.binding} = ${call}`
+  ];
+  const refresh = hasRoutesScript(dir) ? `${cli} export ./${entryRel} --out /dev/null && npm run xano:routes` : `${cli} export ./${entryRel} --out /dev/null`;
+  detail(
+    `Not registered yet.
+${first}  Add to ${entryRel}:
+${lines.map((line) => `    ${line}`).join("\n")}
+  Then run \`${refresh}\` to bring xano.lock and the route manifest up to date.`
+  );
+}
+function workspaceBinding(entry) {
+  try {
+    const code = withoutComments(readFileSync(entry, "utf8"));
+    const bound = /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*workspace\s*\(/.exec(code);
+    if (bound !== null) return bound[1];
+  } catch {
+  }
+  return "app";
+}
+function hasRoutesScript(dir) {
+  const scripts = readProjectManifest(dir)?.["scripts"];
+  return typeof scripts === "object" && scripts !== null && typeof scripts["xano:routes"] === "string";
+}
+function refusePromptFlag(args, verb) {
+  if (!args.prompt) return;
+  throw new UsageError(
+    `\`xanosdk marketplace ${verb}\`: --prompt belongs to \`marketplace details <package>\`, which is the verb that has an agent prompt to print.`,
+    { helpFor: { command: "marketplace", subcommand: verb } }
+  );
+}
+function tagLine(tags) {
+  return tags.length > 0 ? tags.join(" \xB7 ") : void 0;
+}
+function renderRow(row) {
+  const s = stdoutStyle();
+  const name = row.npm_package ?? row.slug ?? "(unnamed)";
+  const title = row.title !== void 0 ? `  ${s.dim(safeText(row.title))}` : "";
+  const lines = [`  ${s.bold(s.cyan(safeText(name)))}${title}`];
+  if (row.tagline !== void 0) lines.push(`    ${safeText(row.tagline)}`);
+  const tags = tagLine(row.tags);
+  if (tags !== void 0) lines.push(`    ${s.dim(safeText(tags))}`);
+  if (row.docs_url !== void 0) lines.push(`    ${s.dim(safeText(row.docs_url))}`);
+  return lines.join("\n");
+}
+function writeRows(args, rows, empty, extra = {}) {
+  if (isMachineOutput(args)) {
+    writeJson({ ...extra, modules: rows });
+    return;
+  }
+  const s = stdoutStyle();
+  if (rows.length === 0) {
+    printHuman(`${empty}
+`);
+    return;
+  }
+  const count = `${rows.length} add-on${rows.length === 1 ? "" : "s"}`;
+  printHuman(
+    `
+${s.dim(count)}
+
+` + rows.map(renderRow).join("\n\n") + `
+
+${s.dim("xanosdk marketplace details <package>  for what a module installs")}
+`
+  );
+}
+async function runMarketplaceListCommand(args) {
+  refusePromptFlag(args, "list");
+  writeRows(args, await fetchCatalogue(), "No add-ons are published yet.");
+}
+async function runMarketplaceSearchCommand(args) {
+  refusePromptFlag(args, "search");
+  const query = args.positionals[0];
+  if (query === void 0 || query === "") {
+    throw missingArgument("string", { command: "marketplace", subcommand: "search" });
+  }
+  const q = args.positionals.join(" ");
+  writeRows(
+    args,
+    await searchCatalogue(q),
+    `Nothing matched "${q}". Run \`xanosdk marketplace list\` to see everything.`,
+    { query: q }
+  );
+}
+function renderModule(mod) {
+  const s = stdoutStyle();
+  const out = [];
+  const name = mod.npm_package ?? mod.slug ?? "(unnamed)";
+  out.push(`
+  ${s.bold(s.cyan(safeText(mod.title ?? name)))}`);
+  if (mod.tagline !== void 0) out.push(`  ${safeText(mod.tagline)}`);
+  if (mod.description !== void 0) {
+    out.push("");
+    out.push(s.dim(indentBlock(mod.description, "  ")));
+  }
+  out.push("");
+  const fields = [["Package", s.bold(name)]];
+  const tags = tagLine(mod.tags);
+  if (tags !== void 0) fields.push(["Tags", s.dim(tags)]);
+  if (mod.docs_url !== void 0) fields.push(["Docs", mod.docs_url]);
+  if (mod.repo_url !== void 0) fields.push(["Repo", mod.repo_url]);
+  out.push(formatFields(fields).trimEnd());
+  if (mod.includes.length > 0) {
+    out.push(`
+  ${s.bold("Installs")}`);
+    const width = Math.max(...mod.includes.map((i) => (i.kind ?? "").length));
+    for (const item of mod.includes) {
+      const kind = s.dim((item.kind ?? "").padEnd(width));
+      const summary = item.summary !== void 0 ? s.dim(` \u2014 ${item.summary}`) : "";
+      out.push(`    ${kind}  ${item.name ?? ""}${summary}`);
+    }
+  }
+  if (mod.requirements.length > 0) {
+    out.push(`
+  ${s.bold("You supply")}`);
+    for (const req of mod.requirements) out.push(`    \u2022 ${req}`);
+  }
+  if (mod.register_snippet !== void 0) {
+    out.push(`
+  ${s.bold("Register it")}`);
+    out.push(s.dim(indentBlock(mod.register_snippet, "    ")));
+  }
+  if (mod.npm_package !== void 0) {
+    out.push(`
+  ${s.bold(s.green(`xanosdk marketplace install ${mod.npm_package}`))}`);
+  }
+  if (mod.agent_prompt !== void 0) {
+    out.push(
+      `  ${s.dim(`xanosdk marketplace details ${name} --prompt  to hand the wiring to a coding agent`)}`
+    );
+  }
+  return out.join("\n") + "\n";
+}
+async function runMarketplaceDetailsCommand(args) {
+  const pkg = resolvePackage(args, "details");
+  let mod;
+  try {
+    mod = await fetchModule(pkg);
+  } catch (err) {
+    if (err instanceof ModuleNotFoundError) {
+      throw await notInMarketplaceError("xanosdk marketplace details", pkg);
+    }
+    throw err;
+  }
+  if (mod.deleted === true) {
+    warn(`${mod.npm_package ?? pkg} has been removed from the marketplace.`, "module.removed-from-marketplace");
+  }
+  if (args.prompt) {
+    if (mod.agent_prompt === void 0) {
+      throw new Error(
+        `${mod.npm_package ?? pkg} publishes no agent prompt. Run \`xanosdk marketplace details ${pkg}\` for its registration snippet instead.`
+      );
+    }
+    process.stdout.write(mod.agent_prompt + "\n");
+    return;
+  }
+  if (isMachineOutput(args)) {
+    writeJson(mod);
+    return;
+  }
+  printHuman(renderModule(mod));
+}
+export {
+  runMarketplaceDetailsCommand,
+  runMarketplaceInstallCommand,
+  runMarketplaceListCommand,
+  runMarketplaceReinstallCommand,
+  runMarketplaceRemoveCommand,
+  runMarketplaceSearchCommand
+};
+//# sourceMappingURL=marketplace-command-K5YL42NO.js.map