@scalar/cli 2.1.0 → 2.5.1

package/chunks/action-F3UX5E3M.js

@@ -0,0 +1,522 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  getPublishDeploymentUrl
+} from "./chunk-4NHMAG6F.js";
+import {
+  readAndParseConfig,
+  renderConfigError
+} from "./chunk-7AGLC7WV.js";
+import {
+  DEFAULT_ASSETS_DIR
+} from "./chunk-PBXZN65A.js";
+import {
+  resolveProject
+} from "./chunk-T7B6WNZC.js";
+import "./chunk-XCSR4RIT.js";
+import {
+  apiService
+} from "./chunk-AO3F5XWR.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 "./chunk-VNYE4R7N.js";
+import {
+  ConfigVersion,
+  isGithubBackedDocsProject,
+  publishRecordSchema
+} 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 {
+  slugSchema,
+  zod_default
+} from "./chunk-IKT5F47M.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/project/publish/action.ts
+import { dirname } from "node:path";
+
+// src/domains/project/publish/publish.ts
+import fs from "node:fs";
+import path from "node:path";
+import { Readable } from "node:stream";
+import ignore from "ignore";
+import tar from "tar-fs";
+var DEFAULT_IGNORED_FILES = ["node_modules", ".git"];
+var toPosix = (value) => value.split(path.sep).join("/");
+function isErrnoException(error) {
+  return error instanceof Error && "code" in error;
+}
+async function readGitIgnore(configDir) {
+  try {
+    const gitignore = await fs.promises.readFile(
+      path.resolve(configDir, ".gitignore"),
+      "utf8"
+    );
+    return gitignore.replace(/^\uFEFF/, "");
+  } catch (err) {
+    if (isErrnoException(err) && err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+async function createGitIgnorer(root) {
+  const directories = [root];
+  let repositoryRoot = root;
+  while (!fs.existsSync(path.join(repositoryRoot, ".git"))) {
+    const parent = path.dirname(repositoryRoot);
+    if (parent === repositoryRoot) {
+      repositoryRoot = root;
+      directories.splice(0, directories.length, root);
+      break;
+    }
+    repositoryRoot = parent;
+    directories.unshift(parent);
+  }
+  const matcher = ignore();
+  for (const directory of directories) {
+    const contents = await readGitIgnore(directory);
+    if (!contents) continue;
+    const prefix = toPosix(path.relative(repositoryRoot, directory)).replace(
+      /[\\*?[\]]/g,
+      "\\$&"
+    );
+    if (!prefix) {
+      matcher.add(contents);
+      continue;
+    }
+    for (const line of contents.split(/\r?\n/)) {
+      if (!line.trim() || line.startsWith("#")) continue;
+      const negative = line.startsWith("!");
+      const pattern = (negative ? line.slice(1) : line).replace(
+        /(?<!\\) +$/,
+        ""
+      );
+      if (!pattern || pattern === "/") continue;
+      const anchored = pattern.replace(/\/$/, "").includes("/");
+      const scopedPattern = /^\/?(?:\*\*\/)+$/.test(pattern) ? pattern.replace(/\*\*\/$/, "*/") : pattern;
+      matcher.add(
+        `${negative ? "!" : ""}/${prefix}/${anchored ? "" : "**/"}${scopedPattern.replace(/^\//, "")}`
+      );
+    }
+  }
+  return (name) => matcher.ignores(toPosix(path.relative(repositoryRoot, name)));
+}
+var REMOTE_REFERENCE = /^(https?:)?\/\//i;
+function isLocalReference(value) {
+  return typeof value === "string" && value.length > 0 && !REMOTE_REFERENCE.test(value) && !value.includes("://");
+}
+var FILE_BEARING_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "filepath",
+  "routes",
+  "children",
+  "page",
+  "path",
+  "cssFiles",
+  "theme",
+  "logo",
+  "icon",
+  "backgroundImage",
+  "assetsDir"
+]);
+function collectConfigReferences(config) {
+  const references = [];
+  const isLegacyConfig = config.version === ConfigVersion.V1;
+  const add = (value, key) => {
+    if (isLocalReference(value)) references.push({ value, key });
+  };
+  const visit = (node) => {
+    if (Array.isArray(node)) {
+      node.forEach(visit);
+      return;
+    }
+    if (!node || typeof node !== "object") return;
+    const record = node;
+    const keys = Object.keys(record);
+    for (const [key, value] of Object.entries(record)) {
+      if (!FILE_BEARING_CONFIG_KEYS.has(key)) {
+        visit(value);
+        continue;
+      }
+      switch (key) {
+        // Page/OpenAPI/footer/ruleset sources.
+        case "filepath":
+          add(value, key);
+          break;
+        // Navigation records allow a string shorthand: a `routes`/`children`
+        // value that is just the page's filepath instead of a page object.
+        case "routes":
+        case "children":
+          if (value && typeof value === "object" && !Array.isArray(value)) {
+            for (const entry of Object.values(value)) {
+              if (typeof entry === "string") {
+                add(entry, key);
+              } else {
+                visit(entry);
+              }
+            }
+          } else {
+            visit(value);
+          }
+          break;
+        // A folder group's root page can also use the string shorthand.
+        case "page":
+          if (typeof value === "string") {
+            add(value, key);
+          } else {
+            visit(value);
+          }
+          break;
+        // Head styles/scripts are `{ path, tagPosition? }`. A bare `path` on a
+        // v2 navigation entry is a URL route, not a file, so match on the
+        // shape — but in a legacy config every `path` is a local file.
+        case "path":
+          if (isLegacyConfig || keys.every((k) => k === "path" || k === "tagPosition"))
+            add(value, key);
+          break;
+        // Legacy theme CSS files are read from disk at build time.
+        case "cssFiles":
+          if (Array.isArray(value)) {
+            for (const entry of value) add(entry, key);
+          }
+          break;
+        // A `.css` value is a local file; anything else is a platform slug.
+        case "theme":
+          if (typeof value === "string" && value.endsWith(".css"))
+            add(value, key);
+          break;
+        // A logo is a single reference or `{ darkMode, lightMode }`.
+        case "logo":
+          if (typeof value === "string") {
+            add(value, key);
+          } else if (value && typeof value === "object") {
+            const logo = value;
+            add(logo.darkMode, key);
+            add(logo.lightMode, key);
+          }
+          break;
+        // An icon can be a slug, a URL, or a local file path.
+        case "icon":
+          add(value, key);
+          break;
+        // A page's cover image is resolved as a local asset by preprocess.
+        case "backgroundImage":
+          add(value, key);
+          break;
+        // The assets directory ships wholesale — preprocess reads every file
+        // under it and fails with ASSET_DIRECTORY_MISSING if it is absent.
+        case "assetsDir":
+          add(value, key);
+          break;
+      }
+    }
+  };
+  visit(config);
+  return references;
+}
+function collectConfigFilepaths(config) {
+  return collectConfigReferences(config).map((reference) => reference.value);
+}
+function getIncludedPaths(root, config) {
+  const references = /* @__PURE__ */ new Set();
+  const ancestors = /* @__PURE__ */ new Set();
+  const resolvedRoot = path.resolve(root);
+  const filepaths = collectConfigFilepaths(config);
+  if (!isLocalReference(config.assetsDir)) filepaths.push(DEFAULT_ASSETS_DIR);
+  for (const filepath of filepaths) {
+    const absolute = path.resolve(resolvedRoot, filepath);
+    if (absolute !== resolvedRoot && !absolute.startsWith(resolvedRoot + path.sep))
+      continue;
+    const relative = toPosix(path.relative(resolvedRoot, absolute));
+    if (relative === "") continue;
+    references.add(relative);
+    let parent = path.dirname(relative);
+    while (parent && parent !== ".") {
+      ancestors.add(parent);
+      parent = path.dirname(parent);
+    }
+  }
+  return { references, ancestors };
+}
+function findMissingReferences(root, config) {
+  const resolvedRoot = path.resolve(root);
+  const missing = [];
+  for (const { value: filepath, key } of collectConfigReferences(config)) {
+    if (key === "icon" && !path.extname(filepath)) continue;
+    const absolute = path.resolve(resolvedRoot, filepath);
+    if (absolute !== resolvedRoot && !absolute.startsWith(resolvedRoot + path.sep))
+      continue;
+    if (!fs.existsSync(absolute)) missing.push(filepath);
+  }
+  return missing;
+}
+async function createProjectTar(configDir, config) {
+  const root = path.resolve(configDir);
+  const isGitIgnored = await createGitIgnorer(root);
+  const defaultIgnorer = ignore({ allowRelativePaths: true }).add(
+    DEFAULT_IGNORED_FILES
+  );
+  const { references, ancestors } = getIncludedPaths(root, config);
+  const isIncluded = (relativeName) => {
+    if (ancestors.has(relativeName)) return true;
+    for (const reference of references) {
+      if (relativeName === reference || relativeName.startsWith(`${reference}/`))
+        return true;
+    }
+    return false;
+  };
+  return Readable.from(
+    tar.pack(root, {
+      // tar-fs hands the ignore callback absolute paths, but gitignore rules
+      // only match relative POSIX ones — so relativize and normalize first.
+      // Matching the relativized path also lets a bare `node_modules` rule swallow
+      // every file whenever the packed root itself sits under a `node_modules`
+      // directory, as it does in the deployed pnpm isolate.
+      ignore: (name) => {
+        const relativeName = toPosix(path.relative(root, name));
+        if (relativeName === "") return false;
+        if (defaultIgnorer.ignores(relativeName)) return true;
+        if (isIncluded(relativeName)) return false;
+        return isGitIgnored(name);
+      },
+      dereference: true
+    })
+  );
+}
+async function publishGithub({
+  slug,
+  preview,
+  apiClient
+}) {
+  const publishGithubResult = await apiClient.publish.publishGithub({
+    slug,
+    preview
+  });
+  if (publishGithubResult.error) {
+    return {
+      success: false,
+      error: publishGithubResult.message
+    };
+  }
+  return {
+    success: true,
+    publishUid: publishGithubResult.data.publishUid
+  };
+}
+async function publishProject({
+  configDir,
+  configPath,
+  config,
+  slug,
+  mode
+}) {
+  try {
+    const root = path.join(configDir, config.root ?? "./");
+    const missingReferences = findMissingReferences(root, config);
+    if (missingReferences.length > 0) {
+      output.warn().title("Some files referenced by your config were not found").message(
+        `The build may fail because these paths do not exist:
+${missingReferences.map((reference) => `  - ${reference}`).join("\n")}`
+      ).print();
+    }
+    const relativeConfigPath = path.relative(root, configPath);
+    const apiClient = await apiService();
+    const projectTar = await createProjectTar(root, config);
+    const result = await apiClient.publish.publishCli({
+      tarStream: Readable.toWeb(projectTar),
+      slug,
+      configPath: relativeConfigPath,
+      mode
+    });
+    if (result.error)
+      return {
+        success: false,
+        error: result.originalError ?? result.message
+      };
+    return { success: true, publishUid: result.data.publishUid };
+  } catch (e) {
+    return { success: false, error: e };
+  }
+}
+async function publishUnifiedDocsProjectFromGithub({
+  slug,
+  preview,
+  apiClient
+}) {
+  const result = await apiClient.publish.publishDocsProject({
+    slug,
+    preview
+  });
+  if (result.error) {
+    return {
+      success: false,
+      error: result.message
+    };
+  }
+  return {
+    success: true,
+    publishUid: result.data.publishUid
+  };
+}
+
+// src/helpers/utils.ts
+var sleep = (ms) => {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+};
+
+// src/domains/project/publish/action.ts
+async function publishAction(args) {
+  const argsParseResult = zod_default.object({
+    slug: slugSchema,
+    config: zod_default.string().optional(),
+    preview: zod_default.coerce.boolean().default(false),
+    github: zod_default.coerce.boolean().default(false)
+  }).safeParse(args);
+  if (argsParseResult.error)
+    return output.error().title("Invalid Arguments").message(argsParseResult.error.issues[0].message).exit("error");
+  const {
+    config: configPathOption,
+    slug,
+    preview,
+    github
+  } = argsParseResult.data;
+  const apiClient = await apiService();
+  const auth = await getAuthData();
+  auth.addEventListener((state) => Object.assign(auth, state));
+  if (!slug) {
+    return output.error().title("Invalid argument").message("Slug is required. Try passing --slug flag.").exit("error");
+  }
+  if (github) {
+    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");
+    }
+    if (resolved.kind === "github") {
+      if (!resolved.project.repository) {
+        return output.error().title("Your project is not linked to a GitHub repository").message(
+          "For a sync publish, please configure your GitHub connection through the dashboard."
+        ).exit("error");
+      }
+      if (resolved.project.repository.expired) {
+        return output.error().title("Your GitHub repository access is expired.").message(
+          "Please reconnect your project through the Scalar Dashboard to publish via sync."
+        ).exit("error");
+      }
+      const publishResult3 = await publishGithub({ apiClient, slug, preview });
+      if (!publishResult3.success) {
+        return output.error().title("Could not publish sync project.").message(publishResult3.error).exit("error");
+      }
+      return await waitForPublish({
+        teamUid: auth.teamUid,
+        publishUid: publishResult3.publishUid
+      });
+    }
+    if (!isGithubBackedDocsProject(resolved.project)) {
+      return output.error().title("Your project is not linked to a GitHub repository").message(
+        "For a sync publish, please configure your GitHub connection through the dashboard."
+      ).exit("error");
+    }
+    if (resolved.project.repository.expired) {
+      return output.error().title("Your GitHub repository access is expired.").message(
+        "Please reconnect your project through the Scalar Dashboard to publish via sync."
+      ).exit("error");
+    }
+    const publishResult2 = await publishUnifiedDocsProjectFromGithub({
+      apiClient,
+      slug,
+      preview
+    });
+    if (!publishResult2.success) {
+      return output.error().title("Could not publish sync project.").message(publishResult2.error).exit("error");
+    }
+    return await waitForPublish({
+      teamUid: auth.teamUid,
+      publishUid: publishResult2.publishUid
+    });
+  }
+  const configResult = readAndParseConfig(configPathOption ?? "");
+  if (!configResult.success) {
+    renderConfigError(configResult.error);
+  }
+  const { config, filePath: configPath } = configResult;
+  const publishResult = await publishProject({
+    config,
+    slug,
+    configDir: dirname(configPath),
+    configPath,
+    ...preview && { mode: "preview" }
+  });
+  if (!publishResult.success) {
+    return output.error().title("Something went wrong while deploying the project").message(
+      publishResult.error instanceof Error ? publishResult.error.message : publishResult.error
+    ).exit("error");
+  }
+  return await waitForPublish({
+    teamUid: auth.teamUid,
+    publishUid: publishResult.publishUid
+  });
+}
+async function waitForPublish({
+  teamUid,
+  publishUid
+}) {
+  const dbClient = await getDatabaseClient();
+  const logger = output.info({ animate: true }).loader("Deployment in progress");
+  while (true) {
+    const deployStatus = await getDeployStatus({
+      client: dbClient,
+      publishUid,
+      teamUid
+    });
+    if (deployStatus.error === true) {
+      return output.error().title(
+        "Something went wrong while getting information about the deployment"
+      ).exit("error");
+    }
+    logger.update("loader", 0, { content: deployStatus.data.message });
+    if (deployStatus.data.status === "deployed") {
+      const deploymentUrl = getPublishDeploymentUrl(deployStatus.data);
+      if (deploymentUrl) {
+        output.info().line(
+          `${deployStatus.data.preview ? "Preview URL" : "Deployment URL"}: ${deploymentUrl}`
+        ).print();
+      }
+      logger.exit("success");
+      return;
+    }
+    if (deployStatus.data.status === "error") {
+      logger.exit("error");
+    }
+    await sleep(3e3);
+  }
+}
+async function getDeployStatus({
+  client,
+  publishUid,
+  teamUid
+}) {
+  return client.getOne({
+    collectionPath: `team/${teamUid}/publish`,
+    schema: publishRecordSchema,
+    query: { uid: publishUid }
+  });
+}
+export {
+  publishAction
+};

package/chunks/{action-GB6DM53B.js → action-FDB7NEOK.js}

@@ -3,18 +3,25 @@ import {
   measureTime
 } from "./chunk-KHDYYVYF.js";
 import {
-  getFileOrUrl
-} from "./chunk-23I5PKZZ.js";
+  getFileOrUrl,
+  isAsyncApiDocument,
+  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-IX7LJ3AD.js";
+} from "./chunk-4ORL4MST.js";
 import {
   output
-} from "./chunk-X4QLDBB5.js";
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import "./chunk-IKT5F47M.js";
 import {
   __toESM
 } from "./chunk-3MZYUBJ6.js";
@@ -24,9 +31,8 @@ var import_yaml = __toESM(require_dist(), 1);
 import fs from "node:fs/promises";
 import { confirm } from "@clack/prompts";
 import as from "ansis";
-import { normalize } from "@scalar/json-magic/helpers/normalize";
+import { upgrade as upgradeAsyncApi } from "@scalar/asyncapi-upgrader";
 import { upgrade } from "@scalar/openapi-upgrader";
-var isDocument = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 async function upgradeAction(input, { output: outputFilePath }) {
   if (!input) {
     return output.error().title("Missing input").message("Please provide a file path or URL to upgrade").exit("error");
@@ -47,22 +53,27 @@ async function upgradeAction(input, { output: outputFilePath }) {
     }
   }
   const outputFileName = outputFilePath ?? input;
-  const document = normalize(await getFileOrUrl(input));
+  const content = await getFileOrUrl(input);
+  const document = safeNormalize(content);
   if (!isDocument(document)) {
     return output.error().title("Invalid input").message(
-      "Could not read an OpenAPI document from the input. Please provide a valid JSON or YAML file."
+      "Could not read a document from the input. Please provide a valid JSON or YAML file."
     ).exit("error");
   }
+  const isAsyncApi = isAsyncApiDocument(document);
   const { result: upgraded, executionTimeMs } = await measureTime(
-    () => upgrade(document, "3.1")
+    () => isAsyncApi ? upgradeAsyncApi(document) : upgrade(document, "3.1")
   );
   const isYaml = isYamlFileName(outputFileName);
   await fs.writeFile(
     outputFileName,
     isYaml ? import_yaml.default.stringify(upgraded) : JSON.stringify(upgraded, null, 2)
   );
+  const specification = isAsyncApi ? "AsyncAPI" : "OpenAPI";
+  const version = upgraded[isAsyncApi ? "asyncapi" : "openapi"];
+  const versionSuffix = typeof version === "string" ? ` to version ${version}` : "";
   output.info().message(
-    `${as.green(`\u2728 OpenAPI Schema upgraded to version ${upgraded.openapi}`)} in ${as.white(`${as.bold(`${executionTimeMs.toFixed(2)}`)} ms`)}`
+    `${as.green(`\u2728 ${specification} Schema upgraded${versionSuffix}`)} in ${as.white(`${as.bold(`${executionTimeMs.toFixed(2)}`)} ms`)}`
   ).print();
 }
 export {