@scalar/cli 2.0.1 → 2.5.1

package/chunks/action-JZLZ7ZAD.js

@@ -0,0 +1,110 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  getProjectDeployments
+} from "./chunk-PT5TI77I.js";
+import {
+  resolveProject
+} from "./chunk-T7B6WNZC.js";
+import {
+  formatAbsoluteTime
+} from "./chunk-AEFPCC4U.js";
+import {
+  apiService
+} from "./chunk-AO3F5XWR.js";
+import "./chunk-F467BYYR.js";
+import "./chunk-Z2KMGFE6.js";
+import "./chunk-HCPN3KNF.js";
+import "./chunk-B2MHTD3R.js";
+import "./chunk-3L6DLIXJ.js";
+import "./chunk-P7H7GY5A.js";
+import "./chunk-HPL3ZZ2P.js";
+import {
+  getAuthData
+} from "./chunk-M37TP6U2.js";
+import "./chunk-4ZDQXWBT.js";
+import "./chunk-VNYE4R7N.js";
+import "./chunk-OQKDBLOZ.js";
+import "./chunk-K74E42RV.js";
+import "./chunk-CISTON3A.js";
+import "./chunk-Q7DOQHZN.js";
+import "./chunk-4ORL4MST.js";
+import {
+  output,
+  printTable
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import {
+  external_exports,
+  slugSchema
+} from "./chunk-IKT5F47M.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/project/deployments/list/action.ts
+import as from "ansis";
+function colorStatus(status) {
+  switch (status) {
+    case "deployed":
+      return as.green(status);
+    case "error":
+    case "cancelled":
+      return as.red(status);
+    case "pending":
+    case "building":
+      return as.yellow(status);
+    default:
+      return as.dim(status);
+  }
+}
+async function listAction(args) {
+  const argsParseResult = external_exports.object({ slug: slugSchema.optional() }).safeParse(args);
+  if (argsParseResult.error) {
+    return output.error().title("Invalid Arguments").message(argsParseResult.error.issues[0].message).exit("error");
+  }
+  const { slug } = argsParseResult.data;
+  if (!slug) {
+    return output.error().title("Invalid argument").message("Slug is required. Try passing --slug flag.").exit("error");
+  }
+  const apiClient = await apiService();
+  const auth = await getAuthData();
+  auth.addEventListener((state) => Object.assign(auth, state));
+  const resolved = await resolveProject(slug, apiClient);
+  if (resolved.kind === "not-found") {
+    return output.error().title("Project not found").message(`No project with slug "${slug}" was found for your team.`).exit("error");
+  }
+  const { project } = resolved;
+  const activeUid = project.activeDeployment?.uid ?? null;
+  const deploymentsResult = await getProjectDeployments({
+    teamUid: auth.teamUid,
+    projectUid: project.uid
+  });
+  if (!deploymentsResult.success) {
+    return output.error().title("Could not load deployment history").message(deploymentsResult.error).exit("error");
+  }
+  if (deploymentsResult.deployments.length === 0) {
+    output.info().title(`No deployments found for project "${slug}".`).print();
+    return;
+  }
+  printTable(
+    [
+      { name: "current", title: " ", alignment: "center" },
+      { name: "id", title: "Build ID", alignment: "left" },
+      { name: "status", title: "Status", alignment: "left" },
+      { name: "deployed", title: "Deployed", alignment: "left" },
+      { name: "commit", title: "Commit", alignment: "left" }
+    ],
+    deploymentsResult.deployments.map((record) => {
+      const isLive = record.uid === activeUid;
+      const deployedAt = record.deployedAt ?? (record.status === "deployed" ? record.createdAt : null);
+      return {
+        current: isLive ? as.green("\u279C") : " ",
+        id: isLive ? as.green(record.uid) : record.uid,
+        status: colorStatus(record.status),
+        deployed: deployedAt ? formatAbsoluteTime(deployedAt * 1e3) : as.dim("\u2014"),
+        commit: record.commitSha ? record.commitSha.slice(0, 7) : as.dim("\u2014")
+      };
+    })
+  );
+}
+export {
+  listAction
+};

package/chunks/action-LA6KVAXQ.js

@@ -0,0 +1,374 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  getFileOrUrl,
+  isAsyncApiContent
+} from "./chunk-24WAOKGG.js";
+import {
+  err,
+  ok
+} from "./chunk-P7H7GY5A.js";
+import {
+  require_dist
+} from "./chunk-K74E42RV.js";
+import "./chunk-CISTON3A.js";
+import "./chunk-Q7DOQHZN.js";
+import "./chunk-4ORL4MST.js";
+import {
+  output
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import "./chunk-IKT5F47M.js";
+import {
+  __toESM
+} from "./chunk-3MZYUBJ6.js";
+
+// src/domains/document/lint/action.ts
+import as from "ansis";
+
+// ../../packages/api-document-lint/dist/constants.js
+var DEFAULT_RULESET = `extends: spectral:oas
+rules: {}`;
+var ASYNCAPI_RULESET = `extends: spectral:asyncapi
+rules: {}`;
+
+// ../../packages/api-document-lint/dist/default-ruleset.js
+function isAsyncApiContent2(content) {
+  const head = content.slice(0, 500);
+  if (head.includes('"asyncapi"')) {
+    return true;
+  }
+  return head.split("\n").some((line) => /^asyncapi\s*:/.test(line.trimStart()));
+}
+function defaultRulesetFor(content) {
+  return isAsyncApiContent2(content) ? ASYNCAPI_RULESET : DEFAULT_RULESET;
+}
+
+// ../../packages/api-document-lint/dist/run-spectral.js
+import spectralCore from "@stoplight/spectral-core";
+import { bundleAndLoadRuleset } from "@stoplight/spectral-ruleset-bundler/with-loader";
+import "@stoplight/spectral-rulesets";
+var { Spectral } = spectralCore;
+async function runSpectral(input) {
+  const rulesetSource = input.ruleset && input.ruleset.trim().length > 0 ? input.ruleset : defaultRulesetFor(input.document);
+  const ruleset = await loadRuleset(rulesetSource);
+  if (!ruleset.ok) {
+    return ruleset;
+  }
+  const spectral = new Spectral();
+  spectral.setRuleset(ruleset.data);
+  const diagnostics = await spectral.run(input.document).catch((error) => error instanceof Error ? error : new Error(String(error)));
+  if (diagnostics instanceof Error) {
+    return err(`Spectral failed to lint the document \u2014 ${diagnostics.message}`);
+  }
+  return ok(diagnostics);
+}
+async function loadRuleset(source) {
+  const ruleset = await bundleAndLoadRuleset("/.spectral.yaml", {
+    fs: {
+      promises: {
+        // @ts-expect-error The loader only ever reads our single virtual file.
+        async readFile() {
+          return source;
+        }
+      }
+    },
+    format: "esm"
+  }).catch((error) => error instanceof Error ? error : new Error(String(error)));
+  if (ruleset instanceof Error) {
+    return err(`Failed to load ruleset \u2014 ${ruleset.message}`);
+  }
+  return ok(ruleset);
+}
+
+// ../../packages/api-document-lint/dist/run-vacuum.js
+import { execFile } from "node:child_process";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join as join2 } from "node:path";
+import { promisify } from "node:util";
+
+// ../../packages/api-document-lint/dist/normalize-diagnostics.js
+var EMPTY_RANGE = {
+  start: { line: 0, character: 0 },
+  end: { line: 0, character: 0 }
+};
+function normalizeDiagnostics(raw) {
+  if (!Array.isArray(raw)) {
+    return [];
+  }
+  return raw.filter(isObject).map((item) => {
+    const source = item.source;
+    return {
+      code: isCode(item.code) ? item.code : "",
+      message: typeof item.message === "string" ? item.message : "",
+      severity: normalizeSeverity(item.severity),
+      path: Array.isArray(item.path) ? item.path.filter(isSegment) : [],
+      range: normalizeRange(item.range),
+      ...typeof source === "string" ? { source } : {}
+    };
+  });
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function isCode(value) {
+  return typeof value === "string" || typeof value === "number";
+}
+function isSegment(value) {
+  return typeof value === "string" || typeof value === "number";
+}
+function normalizeRange(range) {
+  if (!isObject(range)) {
+    return EMPTY_RANGE;
+  }
+  return {
+    start: normalizePosition(range.start),
+    end: normalizePosition(range.end)
+  };
+}
+function normalizePosition(position) {
+  if (!isObject(position)) {
+    return { line: 0, character: 0 };
+  }
+  return {
+    line: toCoordinate(position.line),
+    character: toCoordinate(position.character)
+  };
+}
+function toCoordinate(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : 0;
+}
+function normalizeSeverity(severity) {
+  return severity === 1 || severity === 2 || severity === 3 ? severity : 0;
+}
+
+// ../../packages/api-document-lint/dist/resolve-binary.js
+import { statSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+var binaryName = process.platform === "win32" ? "vacuum.exe" : "vacuum";
+function resolveVacuumBinary(override) {
+  const explicit = override ?? process.env.VACUUM_BINARY;
+  if (explicit) {
+    return isFile(explicit) ? ok(explicit) : err(`vacuum binary not found at ${explicit}`);
+  }
+  const packaged = resolvePackagedBinary();
+  if (packaged) {
+    return ok(packaged);
+  }
+  return ok("vacuum");
+}
+function resolvePackagedBinary() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    const packageJsonPath = require2.resolve("@quobix/vacuum/package.json");
+    const candidate = join(dirname(packageJsonPath), "bin", binaryName);
+    return isFile(candidate) ? candidate : null;
+  } catch {
+    return null;
+  }
+}
+function isFile(path) {
+  try {
+    return statSync(path, { throwIfNoEntry: false })?.isFile() ?? false;
+  } catch {
+    return false;
+  }
+}
+
+// ../../packages/api-document-lint/dist/run-vacuum.js
+var execFileAsync = promisify(execFile);
+var MAX_BUFFER = 64 * 1024 * 1024;
+var TIMEOUT_MS = 6e4;
+async function runVacuum(input, options = {}) {
+  if (input.document.trim().length === 0) {
+    return ok([]);
+  }
+  const binary = resolveVacuumBinary(options.binaryPath);
+  if (!binary.ok) {
+    return binary;
+  }
+  const directory = await mkdtemp(join2(tmpdir(), "scalar-lint-")).catch(() => null);
+  if (directory === null) {
+    return err("vacuum lint failed \u2014 could not create a temporary directory");
+  }
+  const documentPath = join2(directory, "document.yaml");
+  const reportPath = join2(directory, "report.json");
+  try {
+    const wroteDocument = await writeFile(documentPath, input.document, "utf8").then(() => true).catch(() => false);
+    if (!wroteDocument) {
+      return err("vacuum lint failed \u2014 could not write the document to a temporary file");
+    }
+    const args = [
+      "spectral-report",
+      "--no-style",
+      "--no-update-check",
+      "--skip-check",
+      // Match Spectral's working-directory base for document strings.
+      "--base",
+      process.cwd()
+    ];
+    if (input.ruleset && input.ruleset.trim().length > 0) {
+      const rulesetPath = join2(directory, "ruleset.yaml");
+      const wroteRuleset = await writeFile(rulesetPath, input.ruleset, "utf8").then(() => true).catch(() => false);
+      if (!wroteRuleset) {
+        return err("vacuum lint failed \u2014 could not write the ruleset to a temporary file");
+      }
+      args.push("--ruleset", rulesetPath);
+    }
+    args.push(documentPath, reportPath);
+    const failure = await execFileAsync(binary.data, args, {
+      maxBuffer: MAX_BUFFER,
+      timeout: TIMEOUT_MS
+    }).then(() => null).catch((error) => error);
+    const report = await readFile(reportPath, "utf8").catch(() => null);
+    if (report === null) {
+      if (failure === null) {
+        return err("vacuum ran but its report could not be read");
+      }
+      return err(`vacuum failed to lint the document \u2014 ${describeFailure(failure)}`);
+    }
+    const parsed = parseReport(report);
+    if (!parsed.ok) {
+      return parsed;
+    }
+    return ok(normalizeDiagnostics(parsed.data));
+  } finally {
+    await rm(directory, { recursive: true, force: true }).catch(() => void 0);
+  }
+}
+function describeFailure(failure) {
+  if (failure && typeof failure === "object") {
+    const stderr = failure.stderr;
+    if (typeof stderr === "string" && stderr.trim().length > 0) {
+      return stderr.trim();
+    }
+    if (failure instanceof Error) {
+      return failure.message;
+    }
+  }
+  return "no report was written";
+}
+function parseReport(report) {
+  try {
+    const parsed = JSON.parse(report);
+    if (!Array.isArray(parsed)) {
+      return err("vacuum produced a report in an unexpected shape");
+    }
+    return ok(parsed);
+  } catch {
+    return err("vacuum produced an unreadable report");
+  }
+}
+
+// ../../packages/api-document-lint/dist/select-engine.js
+var import_yaml = __toESM(require_dist(), 1);
+function selectEngine(ruleset) {
+  if (!ruleset || ruleset.trim().length === 0) {
+    return "vacuum";
+  }
+  const parsed = parseRuleset(ruleset);
+  if (parsed === null) {
+    return "spectral";
+  }
+  if (hasCustomFunctions(parsed) || hasRuleCustomizations(parsed) || extendsUninspectableRuleset(parsed) || overridesRequireSpectral(parsed)) {
+    return "spectral";
+  }
+  return "vacuum";
+}
+function overridesRequireSpectral(ruleset) {
+  const overrides = ruleset.overrides;
+  if (!Array.isArray(overrides)) {
+    return false;
+  }
+  return overrides.some((entry) => isRecord(entry) && (hasCustomFunctions(entry) || hasRuleCustomizations(entry) || extendsUninspectableRuleset(entry)));
+}
+function hasRuleCustomizations(ruleset) {
+  return ruleset.rules !== void 0 && (!isRecord(ruleset.rules) || Object.keys(ruleset.rules).length > 0);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseRuleset(ruleset) {
+  try {
+    const value = (0, import_yaml.parse)(ruleset);
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      return value;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function hasCustomFunctions(ruleset) {
+  const functions = ruleset.functions;
+  if (Array.isArray(functions) && functions.length > 0) {
+    return true;
+  }
+  return typeof ruleset.functionsDir === "string" && ruleset.functionsDir.length > 0;
+}
+function extendsUninspectableRuleset(ruleset) {
+  const extended = ruleset.extends;
+  if (extended === void 0) {
+    return false;
+  }
+  const entries = Array.isArray(extended) ? extended : [extended];
+  return entries.some((entry) => !isBuiltInRuleset(entry));
+}
+function isBuiltInRuleset(entry) {
+  const source = Array.isArray(entry) ? entry[0] : entry;
+  return source === "spectral:oas" || source === "spectral:asyncapi";
+}
+
+// ../../packages/api-document-lint/dist/lint.js
+async function lint(input, options = {}) {
+  const ruleset = input.ruleset && input.ruleset.trim().length > 0 ? input.ruleset : defaultRulesetFor(input.document);
+  const resolved = { document: input.document, ruleset };
+  const engine = selectEngine(ruleset);
+  const diagnostics = engine === "vacuum" ? await runVacuum(resolved, options) : await runSpectral(resolved);
+  if (!diagnostics.ok) {
+    return diagnostics;
+  }
+  return ok({ diagnostics: diagnostics.data, engine });
+}
+
+// src/domains/document/lint/helpers.ts
+var severityToLabel = (severity) => {
+  return {
+    0: "Error",
+    1: "Warning",
+    2: "Information",
+    3: "Hint"
+  }[severity];
+};
+
+// src/domains/document/lint/action.ts
+async function lintAction(inputArgument, { rule: ruleArgument }) {
+  if (!inputArgument) {
+    return output.error().title("Invalid argument").message("Please provide a file path").exit("error");
+  }
+  const specification = await getFileOrUrl(inputArgument);
+  const ruleset = ruleArgument ? await getFileOrUrl(ruleArgument) : isAsyncApiContent(specification) ? ASYNCAPI_RULESET : DEFAULT_RULESET;
+  const result = await lint({ document: specification, ruleset });
+  if (!result.ok) {
+    return output.error().title("Failed to lint the document").message(result.error).exit("error");
+  }
+  const diagnostics = result.data.diagnostics;
+  const hasErrors = diagnostics.some((diagnostic) => diagnostic.severity === 0);
+  if (!hasErrors) {
+    output.info().message(as.green("\u2714 No issues found!")).print();
+  } else {
+    output.warn().line(as.red("\u2716 Issues found:")).print();
+  }
+  for (const diagnostic of diagnostics) {
+    output.info().line(`${as.yellow("Rule:")} ${as.bold(String(diagnostic.code))}`).line(`${as.yellow("Message:")} ${diagnostic.message}`).line(`${as.yellow("Severity:")} ${severityToLabel(diagnostic.severity)}`).line(
+      `${as.yellow("Location:")} ${diagnostic.range.start.line}:${diagnostic.range.start.character} - ${diagnostic.range.end.line}:${diagnostic.range.end.character}`
+    ).line(as.gray("---")).print();
+  }
+  if (hasErrors) {
+    output.error().exit("error");
+  }
+}
+export {
+  lintAction
+};

package/chunks/action-M7RQKBSB.js

@@ -0,0 +1,169 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  getFileOrUrl,
+  isAsyncApiDocument,
+  isDocument,
+  loadOpenApiDocument,
+  printSpecificationBanner,
+  safeNormalize
+} from "./chunk-24WAOKGG.js";
+import {
+  watchFile
+} from "./chunk-M37TP6U2.js";
+import "./chunk-4ZDQXWBT.js";
+import "./chunk-VNYE4R7N.js";
+import "./chunk-OQKDBLOZ.js";
+import "./chunk-CISTON3A.js";
+import "./chunk-Q7DOQHZN.js";
+import "./chunk-4ORL4MST.js";
+import {
+  output
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import "./chunk-IKT5F47M.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/document/serve/action.ts
+import { serve } from "@hono/node-server";
+import as from "ansis";
+import { Hono } from "hono";
+import { stream } from "hono/streaming";
+
+// src/domains/document/serve/load-document.ts
+import { validate } from "@scalar/asyncapi-validator";
+var loadServeDocument = async (input) => {
+  const content = await getFileOrUrl(input);
+  const document = safeNormalize(content);
+  if (!isDocument(document) || !isAsyncApiDocument(document)) {
+    return loadOpenApiDocument(content);
+  }
+  const result = validate(document);
+  if (!result.valid) {
+    output.warn().title("File does not match the AsyncAPI specification.").print();
+    for (const error of result.errors ?? []) {
+      output.warn().title(error.message ?? "Invalid AsyncAPI document").print();
+    }
+  }
+  return {
+    valid: result.valid,
+    version: result.version,
+    specification: document,
+    schema: void 0
+  };
+};
+
+// src/domains/document/serve/action.ts
+async function serveAction(inputArgument, { watch, once, port }) {
+  if (!inputArgument) {
+    return output.error().title("Invalid argument").message("Please provide a file path").exit("error");
+  }
+  const result = await loadServeDocument(inputArgument);
+  if (result.specification === void 0) {
+    return;
+  }
+  let { specification } = result;
+  printServeBanner(result);
+  if (!isAsyncApiDocument(specification) && Object.keys(specification.paths ?? {}).length === 0) {
+    output.warn().title("Could not find any paths in the OpenAPI file.").print();
+  }
+  const app = new Hono();
+  app.get("/", (c) => {
+    return c.html(getHtmlDocument(specification, watch));
+  });
+  app.use("/__watcher", async (c, next) => {
+    c.header("Content-Type", "text/event-stream");
+    c.header("Cache-Control", "no-cache");
+    c.header("Connection", "keep-alive");
+    await next();
+  });
+  app.get("/__watcher", (c) => {
+    return stream(c, async (s) => {
+      if (watch) {
+        const subscription = await watchFile(inputArgument, async () => {
+          const newResult = await loadServeDocument(inputArgument);
+          if (newResult.specification && JSON.stringify(specification) !== JSON.stringify(newResult.specification)) {
+            output.info().title(
+              as.grey(
+                `${isAsyncApiDocument(newResult.specification) ? "AsyncAPI" : "OpenAPI"} file modified`
+              )
+            ).print();
+            printServeBanner(newResult);
+            specification = newResult.specification;
+            s.write("data: file modified\n\n");
+          }
+        });
+        if (subscription) {
+          s.onAbort(() => subscription.unsubscribe());
+        }
+      }
+      while (true) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
+    });
+  });
+  const server = serve(
+    {
+      fetch: app.fetch,
+      port: port ?? 3e3
+    },
+    (info) => {
+      output.info().line(
+        `${as.green.bold("\u279C API Reference Server")} ${as.white(
+          "listening on"
+        )} ${as.cyan(`http://localhost:${info.port}`)}`
+      ).print();
+    }
+  );
+  if (once) {
+    setTimeout(() => {
+      server.close();
+    }, 2e3);
+  }
+}
+var getHtmlDocument = (specification, watch = false) => {
+  return `<!doctype html>
+    <html>
+      <head>
+        <title>Scalar API Reference</title>
+        <meta charset="utf-8" />
+        <meta
+          name="viewport"
+          content="width=device-width, initial-scale=1" />
+        <style>
+          body {
+            margin: 0;
+          }
+        </style>
+        ${watch ? `
+              <script>
+                const evtSource = new EventSource('__watcher');
+                evtSource.onmessage = (event) => {
+                  console.log(\`message: \${event.data}\`);
+                  window.location.reload();
+                };
+              </script>
+            ` : ""}
+      </head>
+      <body>
+        <script
+          id="api-reference"
+          type="application/json"
+          data-proxy-url="https://proxy.scalar.com">${JSON.stringify(specification)}</script>
+        <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"></script>
+      </body>
+    </html>`;
+};
+var printServeBanner = (result) => {
+  if (isAsyncApiDocument(result.specification)) {
+    output.info().title(`AsyncAPI${result.version ? ` v${result.version}` : ""}`).print();
+    return;
+  }
+  printSpecificationBanner({
+    version: result.version,
+    schema: result.valid ? result.schema : void 0
+  });
+};
+export {
+  getHtmlDocument,
+  serveAction
+};