@scalar/cli 2.0.1 → 2.5.1

package/chunks/action-SH4UUXPL.js

@@ -0,0 +1,60 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  getFileOrUrl,
+  isDocument,
+  safeNormalize
+} from "./chunk-24WAOKGG.js";
+import {
+  require_dist
+} from "./chunk-K74E42RV.js";
+import "./chunk-CISTON3A.js";
+import "./chunk-Q7DOQHZN.js";
+import {
+  isUrl,
+  isYamlFileName
+} from "./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/format/action.ts
+var import_yaml = __toESM(require_dist(), 1);
+import fs from "node:fs";
+import as from "ansis";
+async function formatAction(inputArgument, { output: outputPath }) {
+  const startTime = performance.now();
+  if (!inputArgument) {
+    return output.error().title("Invalid argument").message("Please provide a file path").exit("error");
+  }
+  const content = await getFileOrUrl(inputArgument);
+  const document = safeNormalize(content);
+  if (!isDocument(document)) {
+    return output.error().title("Invalid input").message(
+      "Could not read a document from the input. Please provide a valid JSON or YAML file."
+    ).exit("error");
+  }
+  const newContent = isYamlFileName(outputPath || inputArgument) ? (0, import_yaml.stringify)(document) : JSON.stringify(document, null, 2);
+  if (outputPath) {
+    fs.writeFileSync(outputPath, newContent, "utf8");
+  } else if (!isUrl(inputArgument)) {
+    fs.writeFileSync(inputArgument, newContent, "utf8");
+  } else {
+    return output.error().title("Invalid argument").message().message(
+      "Output file is required for URLs. Try passing --output file flag."
+    ).exit("error");
+  }
+  const endTime = performance.now();
+  output.info().line(
+    `${as.green("File formatted")} ${as.grey(
+      `in ${as.white(`${as.bold(`${Math.round(endTime - startTime)}`)} ms`)}`
+    )}`
+  ).print();
+}
+export {
+  formatAction
+};

package/chunks/action-SNLCIBQC.js

@@ -0,0 +1,84 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  getFileOrUrl,
+  isAsyncApiContent
+} from "./chunk-24WAOKGG.js";
+import {
+  config
+} from "./chunk-4ZDQXWBT.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/share/action.ts
+import as from "ansis";
+async function shareAction(fileArgument, { token }) {
+  if (!fileArgument) {
+    return output.error().title("Invalid argument").message("Please provide a file path").exit("error");
+  }
+  const content = await getFileOrUrl(fileArgument);
+  const specification = isAsyncApiContent(content) ? "AsyncAPI" : "OpenAPI";
+  const sandboxUrl = new URL(config.projects.sandbox);
+  const url = new URL("/api/share", sandboxUrl);
+  url.pathname = "/api/share";
+  if (token) {
+    url.searchParams.append("token", token);
+  }
+  return fetch(url.toString(), {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      content
+    })
+  }).then(async (response) => {
+    if (!response.ok)
+      throw new Error(`Sandbox returned HTTP ${response.status}`);
+    return response.json();
+  }).then((data) => {
+    if (data === null || typeof data !== "object" || Array.isArray(data)) {
+      throw new Error("Invalid sandbox response");
+    }
+    if (data.error || typeof data.id !== "string" || typeof data.token !== "string") {
+      throw new Error(data.message || "Invalid sandbox response");
+    }
+    const { id, token: newToken } = data;
+    const link = (pathname) => new URL(pathname, sandboxUrl).toString();
+    output.info().line(as.green.bold(`Your ${specification} file is public.`)).line().table(
+      [
+        [
+          `${as.green("\u279C")} ${as.white.bold("API Reference:")}`,
+          as.cyan(link(`/p/${id}`))
+        ],
+        [
+          `${as.grey("\u279C")} ${as.grey.bold("Editor:")}`,
+          as.cyan(link(`/e/${id}`))
+        ],
+        [],
+        [
+          `${as.grey("\u279C")} ${as.grey.bold(`${specification} JSON:`)}`,
+          as.cyan(link(`/files/${id}/openapi.json`))
+        ],
+        [
+          `${as.grey("\u279C")} ${as.grey.bold(`${specification} YAML:`)}`,
+          as.cyan(link(`/files/${id}/openapi.yaml`))
+        ]
+      ],
+      { padding: 1 }
+    ).line().line("Use the token to update the existing sandbox:").line().line(
+      `${as.grey("$")} ${as.white.bold("scalar document share --token=")}${as.cyan.bold(`${newToken}`)} `
+    ).line().print();
+  }).catch((error) => {
+    output.error().title("Failed to share the file.").message(`Details: ${error}`).exit("error");
+  });
+}
+export {
+  shareAction
+};

package/chunks/action-SQG3JAII.js

@@ -0,0 +1,150 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  downloadIsolate
+} from "./chunk-LFU5ZUAP.js";
+import "./chunk-3ZJYGGAA.js";
+import {
+  readAndParseConfig,
+  renderConfigError
+} from "./chunk-7AGLC7WV.js";
+import {
+  CONFIG_FILE_DEFAULT,
+  findConfig
+} from "./chunk-PBXZN65A.js";
+import {
+  ISOLATE_DIR
+} from "./chunk-X5T526CE.js";
+import {
+  getAuthData
+} from "./chunk-M37TP6U2.js";
+import {
+  config
+} from "./chunk-4ZDQXWBT.js";
+import "./chunk-VNYE4R7N.js";
+import {
+  ConfigVersion
+} from "./chunk-OQKDBLOZ.js";
+import "./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 "./chunk-3MZYUBJ6.js";
+
+// src/domains/project/preview/action.ts
+import { text } from "@clack/prompts";
+import as from "ansis";
+
+// src/domains/project/preview/v2.ts
+import { spawn } from "node:child_process";
+import path from "node:path";
+async function runIsolate(isolateOptions) {
+  const executable = process.env.SCALAR_CLI_DISTRIBUTION === "portable" ? path.join(
+    path.dirname(process.execPath),
+    "runtime",
+    process.platform === "win32" ? "node.exe" : "node"
+  ) : process.execPath;
+  const child = spawn(executable, ["dist/isolate-entry.js"], {
+    cwd: ISOLATE_DIR,
+    env: {
+      ...process.env,
+      PATH: `${path.dirname(executable)}${path.delimiter}${process.env.PATH ?? ""}`
+    }
+  });
+  child.stdin.write(JSON.stringify(isolateOptions));
+  child.stdin.end();
+  child.stdout.pipe(process.stdout);
+  child.stderr.pipe(process.stderr);
+  child.on("error", (error) => {
+    console.error(`Could not start docs preview: ${error.message}`);
+    process.exitCode = 1;
+  });
+  child.on("close", (code, signal) => {
+    console.log(
+      `Process exited with code ${code}${signal ? ` (signal ${signal})` : ""}.`
+    );
+    process.exitCode = code ?? 1;
+  });
+}
+async function getAccessToken() {
+  try {
+    const { accessToken } = await getAuthData({ noExit: true });
+    return accessToken;
+  } catch {
+    output.info().message(
+      "You're not signed in. Private Scalar content will not be fetched."
+    ).print();
+    return "";
+  }
+}
+async function previewV2Project({
+  logLevel,
+  configPath,
+  port,
+  config: config2,
+  host
+}) {
+  const root = path.resolve(path.dirname(configPath), config2.root ?? "./");
+  const relativeConfigPath = path.relative(root, configPath);
+  const accessToken = await getAccessToken();
+  await downloadIsolate();
+  output.info().message("Starting preview...").print();
+  await runIsolate({
+    configPath: relativeConfigPath,
+    projectDir: root,
+    logLevel,
+    domain: "localhost",
+    mode: "preview",
+    previewServerPort: port,
+    registryBaseUrl: config.projects.registry,
+    baseUrl: config.services.api,
+    token: accessToken,
+    host
+  });
+}
+
+// src/domains/project/preview/action.ts
+async function previewAction(__configPath, options) {
+  const _port = Number.parseInt(options.port || "7970", 10);
+  if (Number.isNaN(_port)) {
+    return output.error().title("Invalid port").message("Please provide a valid port number").exit("error");
+  }
+  if (_port < 0 || _port > 65535) {
+    return output.error().title("Invalid port").message("Port number must be between 0 and 65535").exit("error");
+  }
+  const configPath = __configPath || findConfig() || await text({
+    message: "Where is your configuration file located?",
+    defaultValue: CONFIG_FILE_DEFAULT,
+    placeholder: CONFIG_FILE_DEFAULT
+  });
+  const parseConfigResult = readAndParseConfig(configPath);
+  if (!parseConfigResult.success) {
+    renderConfigError(parseConfigResult.error);
+  }
+  if (parseConfigResult.success) {
+    output.info().line(
+      `${as.green("[SUCCESS]")} ${as.green("Configuration is valid:")} ${as.green(parseConfigResult.filePath)}`
+    ).print();
+  }
+  const { config: config2 } = parseConfigResult;
+  if (config2.version === ConfigVersion.V1) {
+    return output.error().title("V1 Preview is no longer supported.").message("Please upgrade your project with `scalar project upgrade`").exit("error");
+  }
+  if (config2.version === ConfigVersion.V2) {
+    await previewV2Project({
+      logLevel: options.logLevel,
+      configPath,
+      config: config2,
+      port: _port,
+      host: options.host
+    });
+    return;
+  }
+}
+export {
+  previewAction
+};

package/chunks/action-UZQJNYK4.js

@@ -0,0 +1,18 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  IsolateDownloadError,
+  downloadIsolate,
+  isDiskWriteError,
+  updateIsolate
+} from "./chunk-LFU5ZUAP.js";
+import "./chunk-3ZJYGGAA.js";
+import "./chunk-X5T526CE.js";
+import "./chunk-4ZDQXWBT.js";
+import "./chunk-T5HJUAWB.js";
+import "./chunk-3MZYUBJ6.js";
+export {
+  IsolateDownloadError,
+  downloadIsolate,
+  isDiskWriteError,
+  updateIsolate
+};

package/chunks/action-VC4DCVST.js

@@ -0,0 +1,68 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  apiService
+} from "./chunk-AO3F5XWR.js";
+import "./chunk-HCPN3KNF.js";
+import "./chunk-B2MHTD3R.js";
+import "./chunk-3L6DLIXJ.js";
+import "./chunk-P7H7GY5A.js";
+import "./chunk-HPL3ZZ2P.js";
+import "./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
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import "./chunk-IKT5F47M.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/project/create/action.ts
+import { text } from "@clack/prompts";
+import as from "ansis";
+async function createAction({
+  name,
+  slug
+}) {
+  const apiClient = await apiService();
+  let nameValue = name;
+  let slugValue = slug;
+  if (!nameValue) {
+    nameValue = await text({
+      message: "What is the name of your project?",
+      validate(value) {
+        if (value.trim().length === 0) {
+          return "You did not provide a project name. Please provide a name!";
+        }
+        return;
+      }
+    });
+  }
+  if (!slugValue) {
+    slugValue = await text({
+      message: "What is the slug of your project? (Optional)",
+      defaultValue: void 0
+    });
+  }
+  const logger = output.info().loader("Creating the project");
+  const response = await apiClient.github.createProject({
+    name: nameValue,
+    slug: slugValue
+  });
+  if (response.error) {
+    return output.error().title("Something went wrong").message(response.message).exit("error");
+  }
+  logger.update("loader", 0, { content: "Project created successfully!" });
+  logger.message(
+    `Project uid: ${as.cyan(response.data.uid)}
+Project slug: ${as.cyan(response.data.slug)}`
+  ).exit("success");
+}
+export {
+  createAction
+};

package/chunks/action-VTVFY2MP.js

@@ -0,0 +1,181 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  dashboardUrl,
+  registryUrl
+} from "./chunk-COBPBRQF.js";
+import {
+  registry
+} from "./chunk-XCSR4RIT.js";
+import {
+  getFileOrUrl,
+  isDocument,
+  safeNormalize
+} from "./chunk-24WAOKGG.js";
+import {
+  DEFAULT_FETCH_CONCURRENCY
+} from "./chunk-K4DTP5TV.js";
+import {
+  apiService
+} from "./chunk-AO3F5XWR.js";
+import {
+  BaseCollections
+} from "./chunk-F467BYYR.js";
+import {
+  getDatabaseClient
+} from "./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 {
+  teamSchema
+} from "./chunk-VNYE4R7N.js";
+import "./chunk-OQKDBLOZ.js";
+import "./chunk-K74E42RV.js";
+import {
+  RegistryAsset
+} from "./chunk-CISTON3A.js";
+import "./chunk-Q7DOQHZN.js";
+import {
+  isUrl
+} from "./chunk-4ORL4MST.js";
+import {
+  output
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import {
+  docVersionSchema,
+  external_exports,
+  namespaceSchema,
+  slugSchema,
+  toAsciiSlug
+} from "./chunk-IKT5F47M.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/registry/publish/action.ts
+import { text } from "@clack/prompts";
+import as from "ansis";
+import { bundle } from "@scalar/json-magic/bundle";
+import { fetchUrls, readFiles } from "@scalar/json-magic/bundle/plugins/node";
+async function publishAction(file, args) {
+  const { error, data } = external_exports.object({
+    slug: slugSchema.optional(),
+    file: external_exports.string().min(1, "Please provide a valid file path or URL for your document.").optional(),
+    namespace: namespaceSchema.optional(),
+    version: docVersionSchema.optional(),
+    private: external_exports.coerce.boolean(),
+    current: external_exports.coerce.boolean(),
+    force: external_exports.coerce.boolean(),
+    bundle: external_exports.coerce.boolean().optional(),
+    fetchLimit: external_exports.coerce.number().optional(),
+    urlMap: external_exports.coerce.boolean().default(false),
+    treeShake: external_exports.coerce.boolean().default(false)
+  }).safeParse({
+    file,
+    slug: args.slug,
+    namespace: args.namespace,
+    version: args.version,
+    private: args.private,
+    current: args.current,
+    force: args.force
+  });
+  if (error)
+    return output.error().title("Invalid input").message(error.issues[0].message).exit("error");
+  const auth = await getAuthData();
+  auth.addEventListener((state) => Object.assign(auth, state));
+  const db = await getDatabaseClient();
+  const team = await db.getOne({
+    collectionPath: BaseCollections.Teams,
+    query: {
+      uid: auth.teamUid
+    },
+    schema: teamSchema
+  });
+  if (team.error)
+    return output.error().title("An error occurred when fetching your team.").message(team.message).exit("error");
+  const namespace = data.namespace || team.data.namespaces.at(0);
+  if (!namespace) {
+    return output.error().title("Missing namespace").message(
+      "Could not find a valid namespace for your API. Please specify a namespace or contact support."
+    ).exit("error");
+  }
+  const client = await apiService();
+  const namespaceApisRes = await client.managedDocs.getApiDocs(namespace);
+  if (namespaceApisRes.error)
+    return output.error().title(namespaceApisRes.message).exit("error");
+  const apiFile = data.file || (await text({
+    message: "Please enter a file path or URL for your document",
+    placeholder: "./api.yaml",
+    validate(value) {
+      if (value.length === 0) return "File path or URL is required!";
+    }
+  })).toString();
+  const content = await getFileOrUrl(apiFile);
+  const parsed = safeNormalize(content);
+  if (!isDocument(parsed)) {
+    return output.error().title("Invalid file").message(
+      isUrl(apiFile) ? "Could not fetch or parse the document from the URL." : "Could not read or parse the document file."
+    ).exit("error");
+  }
+  const bundlingPlugins = [readFiles()];
+  if (data.bundle) {
+    bundlingPlugins.push(
+      fetchUrls({
+        limit: data.fetchLimit ?? DEFAULT_FETCH_CONCURRENCY
+      })
+    );
+  }
+  const bundledDocument = await bundle(parsed, {
+    plugins: bundlingPlugins,
+    treeShake: data.treeShake,
+    urlMap: data.urlMap
+  });
+  const specification = bundledDocument;
+  const apiSlug = data.slug || toAsciiSlug(specification.info?.title ?? "");
+  const parsedVersion = docVersionSchema.safeParse(
+    data.version || specification.info?.version
+  );
+  const version = parsedVersion.data || (await text({
+    message: "What is the version of your document (e.g. 0.1.0)?",
+    validate(value) {
+      if (value.length === 0) return "Version is required.";
+      if (docVersionSchema.safeParse(value)?.error)
+        return "Version must be a non-empty string";
+    }
+  })).toString();
+  const logger = output.info().line().loader(`Publishing ${apiSlug} to Scalar registry...`);
+  const matchingApi = namespaceApisRes.data.find((api2) => api2.slug === apiSlug);
+  const document = JSON.stringify(bundledDocument);
+  const publishRes = matchingApi ? await client.managedDocs.addVersion(namespace, apiSlug, {
+    document,
+    version,
+    force: data.force,
+    isCurrent: data.current
+  }) : await client.managedDocs.create(namespace, {
+    title: specification.info?.title || "My API",
+    description: specification.info?.description,
+    version,
+    slug: apiSlug,
+    isPrivate: data.private,
+    document
+  });
+  if (publishRes.error)
+    return output.error().title(publishRes.message).exit("error");
+  logger.update("loader", 0, {
+    content: `Successfully published v${version} for ${apiSlug}.`
+  }).line().print();
+  const api = registry(namespace).apis(apiSlug);
+  const apiUrl = dashboardUrl(
+    RegistryAsset.Apis,
+    matchingApi?.uid ?? publishRes.data.uid
+  );
+  output.info().line(`${as.green("\u279C")} ${as.white.bold("View in dashboard:")}`).line(as.cyan(apiUrl)).line().line(`${as.green("\u279C")} ${as.white.bold("Registry Preview:")}`).line(as.cyan(registryUrl(api.url({ version })))).line().line(`${as.green("\u279C")} ${as.white.bold("Registry YAML:")}`).line(as.cyan(registryUrl(api.url({ version, format: "yaml" })))).line().line(`${as.green("\u279C")} ${as.white.bold("Registry JSON:")}`).line(as.cyan(registryUrl(api.url({ version, format: "json" })))).print();
+}
+export {
+  publishAction
+};

package/chunks/action-WFWYGY7O.js

@@ -0,0 +1,67 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  apiService
+} from "./chunk-AO3F5XWR.js";
+import "./chunk-HCPN3KNF.js";
+import "./chunk-B2MHTD3R.js";
+import "./chunk-3L6DLIXJ.js";
+import "./chunk-P7H7GY5A.js";
+import "./chunk-HPL3ZZ2P.js";
+import "./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
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import "./chunk-IKT5F47M.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/registry/update/action.ts
+import { text } from "@clack/prompts";
+import as from "ansis";
+async function updateAction(namespace, slug, { title, description }) {
+  const client = await apiService();
+  if (!namespace) {
+    return output.error().title("Invalid input").message("Please provide namespace of the document").exit("error");
+  }
+  if (!slug) {
+    return output.error().title("Invalid input").message("Please provide slug of the document").exit("error");
+  }
+  let titleValue = title;
+  let descriptionValue = description;
+  const shouldPrompt = ![title, description].some((it) => it !== void 0);
+  if (!titleValue && shouldPrompt) {
+    titleValue = await text({
+      message: `What is the new title of your document? ${as.grey("(Optional)")}`
+    });
+  }
+  if (!descriptionValue && shouldPrompt) {
+    descriptionValue = await text({
+      message: `What is the new description of your document?  ${as.grey("(Optional)")}`
+    });
+  }
+  if (!titleValue && !descriptionValue) {
+    return output.error().title("Invalid input").message("Please provide any field to update").exit("error");
+  }
+  const logger = output.info().line().loader("Updating the api document");
+  const updateDocument = await client.managedDocs.update(namespace, slug, {
+    title: titleValue,
+    description: descriptionValue,
+    isPrivate: false
+  });
+  if (updateDocument.error) {
+    return output.error().title(updateDocument.message).exit("error");
+  }
+  logger.update("loader", 0, {
+    content: "Successfully updated document metadata."
+  }).print();
+}
+export {
+  updateAction
+};