@scalar/cli 2.0.1 → 2.1.0

package/chunks/action-MENXFJH3.js

@@ -0,0 +1,204 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  openBrowser
+} from "./chunk-JFIXNSPP.js";
+import {
+  accessTokenPayloadSchema,
+  decode,
+  generateAccessByPersonalToken,
+  setAuthData,
+  tokenResponseSchema
+} from "./chunk-5BISXQX4.js";
+import {
+  config
+} from "./chunk-OAXFCOJV.js";
+import "./chunk-4DGQIAJX.js";
+import "./chunk-ISGLWBXZ.js";
+import {
+  external_exports
+} from "./chunk-H2WRMLYY.js";
+import "./chunk-IX7LJ3AD.js";
+import {
+  output
+} from "./chunk-X4QLDBB5.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/auth/login/action.ts
+import as2 from "ansis";
+
+// ../../packages/mongobase-client/dist/auth/node/exchange-callback-server.js
+import getPort from "get-port";
+var generateTokenCallbackEndpoint = async (exchangeUrl) => {
+  const http = await import("node:http");
+  const port = await getPort();
+  const server = http.createServer();
+  server.listen({ port, host: "127.0.0.1" });
+  const getTokens = async () => {
+    const resultPromise = new Promise((resolve) => {
+      server.on("request", async (req, res) => {
+        const corsOrigin = `http://127.0.0.1:${port}`;
+        const errorResponse = (message, code) => {
+          res.writeHead(code, {
+            "Content-Type": "application/json",
+            "Access-Control-Allow-Origin": corsOrigin
+          });
+          res.end(JSON.stringify({
+            success: false,
+            error: true,
+            message
+          }));
+          server.close();
+          return resolve({ data: null, error: true });
+        };
+        if (req.method !== "POST") {
+          return errorResponse("Method not allowed", 405);
+        }
+        const url = new URL(`http://localhost:${port}${req.url}`);
+        const exchangeToken = url.searchParams.get("exchangeToken");
+        if (!exchangeToken) {
+          return errorResponse("Missing exchange token", 400);
+        }
+        try {
+          const tokens = await exchangeTokenForAccess(exchangeUrl, exchangeToken);
+          if (tokens) {
+            res.writeHead(200, {
+              "Content-Type": "application/json",
+              "Access-Control-Allow-Origin": corsOrigin
+            });
+            res.end(JSON.stringify({
+              success: true,
+              error: false,
+              message: "Token exchanged. "
+            }));
+            server.close();
+            return resolve({ data: tokens, error: false });
+          }
+          return errorResponse("Failed to exchange token", 400);
+        } catch (err) {
+          console.error(err);
+          return errorResponse("Internal server error", 500);
+        }
+      });
+    });
+    const timeoutPromise = new Promise((resolve) => {
+      setTimeout(() => {
+        server.close();
+        resolve({ data: null, error: true });
+      }, 3 * 60 * 1e3);
+    });
+    return Promise.race([resultPromise, timeoutPromise]);
+  };
+  return {
+    port,
+    cancel: () => server.close(),
+    getTokens
+  };
+};
+var exchangeTokenForAccess = async (serverUrl, exchangeToken) => {
+  const result = await fetch(serverUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      exchangeToken
+    })
+  });
+  if (result.ok) {
+    return tokenResponseSchema.parse(await result.json());
+  }
+  return null;
+};
+
+// src/domains/auth/login/helpers/messages.ts
+import as from "ansis";
+function loggedInMessage(userIdentifier) {
+  if (process.env.CI || !userIdentifier)
+    return "Successfully authenticated to Scalar CLI";
+  return `Successfully authenticated to Scalar CLI as ${as.cyan(userIdentifier)}`;
+}
+
+// src/domains/auth/login/helpers/email-pass-auth.ts
+var tokenResponseSchema2 = external_exports.object({
+  accessToken: external_exports.string(),
+  refreshToken: external_exports.string()
+});
+var emailPasswordAuth = async ({
+  email,
+  password
+}) => {
+  const result = await fetch(`${config.services.api}/core/login/email`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    credentials: "include",
+    body: JSON.stringify({
+      email,
+      password
+    })
+  });
+  if (!result.ok) {
+    const data = await result.json();
+    throw new Error(data.message ?? "Could not login with email");
+  }
+  return tokenResponseSchema2.parse(await result.json());
+};
+
+// src/domains/auth/login/action.ts
+async function loginAction({
+  email,
+  password,
+  token: _token
+}) {
+  const token = process.env.SCALAR_API_KEY || _token;
+  if (token) {
+    try {
+      const { accessToken } = await generateAccessByPersonalToken({
+        personalToken: token
+      });
+      const { email: userEmail } = decode(accessToken, accessTokenPayloadSchema);
+      output.info().message(loggedInMessage(userEmail)).print();
+    } catch (err) {
+      return output.error().title("Invalid token").message(err.message ?? "Please provide a valid personal token").exit("error");
+    }
+    return;
+  }
+  if (email || password) {
+    if (!email || !password) {
+      return output.error().title("Please provide both email and password combination").message().exit("error");
+    }
+    try {
+      const { accessToken, refreshToken } = await emailPasswordAuth({
+        email,
+        password
+      });
+      await setAuthData({ accessToken, refreshToken });
+      output.info().message(loggedInMessage(email)).print();
+    } catch (err) {
+      output.error().title(err.message).print();
+    }
+    return;
+  }
+  const { port, getTokens } = await generateTokenCallbackEndpoint(
+    `${config.services.api}/core/login/exchange`
+  );
+  const loginUrl = `${config.projects.dashboard}/login?externalRedirect=local&port=${port}`;
+  output.info().message(`Please follow the link to login: ${as2.cyan(loginUrl)}`).print();
+  openBrowser(loginUrl);
+  try {
+    const tokenResult = await getTokens();
+    if (tokenResult.error) throw Error("Unable to exchange token");
+    await setAuthData(tokenResult.data);
+    const { email: userEmail } = decode(
+      tokenResult.data.accessToken,
+      accessTokenPayloadSchema
+    );
+    return output.info().message(loggedInMessage(userEmail)).exit("success");
+  } catch {
+    return output.error().title("Something went wrong. Please try again.").exit("error");
+  }
+}
+export {
+  loginAction
+};

package/chunks/action-P7LN6FGY.js

@@ -0,0 +1,13 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  downloadIsolate,
+  updateIsolate
+} from "./chunk-TQ5XC2E3.js";
+import "./chunk-KWOL7A6J.js";
+import "./chunk-OAXFCOJV.js";
+import "./chunk-X4QLDBB5.js";
+import "./chunk-3MZYUBJ6.js";
+export {
+  downloadIsolate,
+  updateIsolate
+};

package/chunks/action-PVDDRIM6.js

@@ -0,0 +1,130 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  loadOpenApiFile,
+  printSpecificationBanner
+} from "./chunk-23I5PKZZ.js";
+import {
+  watchFile
+} from "./chunk-5BISXQX4.js";
+import "./chunk-OAXFCOJV.js";
+import "./chunk-4DGQIAJX.js";
+import "./chunk-ISGLWBXZ.js";
+import "./chunk-H2WRMLYY.js";
+import "./chunk-IX7LJ3AD.js";
+import {
+  output
+} from "./chunk-X4QLDBB5.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";
+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 loadOpenApiFile(inputArgument);
+  if (!result.valid) {
+    return;
+  }
+  let { specification } = result;
+  printSpecificationBanner({
+    version: result.version,
+    schema: result.schema
+  });
+  if (specification?.paths === void 0 || 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 loadOpenApiFile(inputArgument);
+          const specificationHasChanged = newResult?.specification && JSON.stringify(specification) !== JSON.stringify(newResult.specification);
+          if (specificationHasChanged && newResult.valid) {
+            output.info().title(as.grey("OpenAPI file modified")).print();
+            printSpecificationBanner({
+              version: newResult.version,
+              schema: newResult.schema
+            });
+            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>`;
+};
+export {
+  getHtmlDocument,
+  serveAction
+};

package/chunks/action-Q5UJ32D6.js

@@ -0,0 +1,46 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  output
+} from "./chunk-X4QLDBB5.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/document/void/action.ts
+import { serve } from "@hono/node-server";
+import as from "ansis";
+import { createVoidServer } from "@scalar/void-server";
+async function voidAction({
+  once,
+  port
+}) {
+  const server = await bootServer({
+    port
+  });
+  if (once) {
+    setTimeout(() => {
+      server.close();
+    }, 2e3);
+  }
+}
+var bootServer = async ({
+  port
+}) => {
+  const app = await createVoidServer();
+  return serve(
+    {
+      fetch: app.fetch,
+      port: port ?? 3e3
+    },
+    (info) => {
+      output.info().line(
+        `${as.green.bold("\u279C Void Server")} ${as.white(
+          "listening on"
+        )} ${as.cyan(`http://localhost:${info.port}`)}
+`
+      ).print();
+    }
+  );
+};
+export {
+  bootServer,
+  voidAction
+};

package/chunks/action-R6ZZO26F.js

@@ -0,0 +1,299 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  getPublishDeploymentUrl
+} from "./chunk-ZTVWAKNJ.js";
+import {
+  readAndParseConfig,
+  renderConfigError
+} from "./chunk-P2VH7DOC.js";
+import {
+  resolveProject
+} from "./chunk-T7B6WNZC.js";
+import "./chunk-47Y4L5IT.js";
+import "./chunk-DOVIWNKQ.js";
+import {
+  apiService
+} from "./chunk-SXYALPYK.js";
+import {
+  getDatabaseClient
+} from "./chunk-SHSHFGA7.js";
+import "./chunk-UPUTMFD4.js";
+import "./chunk-B6QZJWCQ.js";
+import "./chunk-5BPPGTUU.js";
+import "./chunk-P646T2WH.js";
+import "./chunk-4QS7SJTG.js";
+import "./chunk-VTYTPSXO.js";
+import {
+  getAuthData
+} from "./chunk-5BISXQX4.js";
+import "./chunk-OAXFCOJV.js";
+import "./chunk-TLFMATXR.js";
+import "./chunk-4DGQIAJX.js";
+import {
+  isGithubBackedDocsProject,
+  publishRecordSchema,
+  slugSchema
+} from "./chunk-ISGLWBXZ.js";
+import {
+  zod_default
+} from "./chunk-H2WRMLYY.js";
+import "./chunk-K74E42RV.js";
+import "./chunk-IX7LJ3AD.js";
+import {
+  output
+} from "./chunk-X4QLDBB5.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"];
+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;
+  } catch (err) {
+    if (isErrnoException(err) && err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+async function createProjectTar(configDir) {
+  const ignorer = ignore({ allowRelativePaths: true });
+  const gitignore = await readGitIgnore(configDir);
+  if (gitignore) ignorer.add(gitignore);
+  ignorer.add(DEFAULT_IGNORED_FILES);
+  return Readable.from(
+    tar.pack(configDir, {
+      ignore: (name) => ignorer.ignores(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 relativeConfigPath = path.relative(root, configPath);
+    const apiClient = await apiService();
+    const projectTar = await createProjectTar(root);
+    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
+};