@scalar/cli 2.0.1 → 2.5.1

package/chunks/action-XMNX5ZYT.js

@@ -0,0 +1,197 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  getPublishDeploymentUrl
+} from "./chunk-4NHMAG6F.js";
+import {
+  getProjectDeployments
+} from "./chunk-PT5TI77I.js";
+import {
+  resolveProject
+} from "./chunk-T7B6WNZC.js";
+import {
+  formatAbsoluteTime
+} from "./chunk-AEFPCC4U.js";
+import "./chunk-XCSR4RIT.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
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import {
+  external_exports,
+  slugSchema
+} from "./chunk-IKT5F47M.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/project/rollback/action.ts
+import { confirm } from "@clack/prompts";
+
+// src/domains/project/rollback/select-rollback-target.ts
+function selectRollbackTarget({
+  deployments,
+  activeUid,
+  to
+}) {
+  const deployed = deployments.filter((record) => record.status === "deployed");
+  if (to) {
+    const target = deployed.find((record) => record.uid === to);
+    if (!target) {
+      const existing = deployments.find((record) => record.uid === to);
+      if (existing) {
+        return {
+          success: false,
+          error: {
+            code: "target-not-deployable",
+            uid: to,
+            status: existing.status
+          }
+        };
+      }
+      return { success: false, error: { code: "target-not-found", uid: to } };
+    }
+    if (target.uid === activeUid) {
+      return { success: false, error: { code: "already-live", uid: to } };
+    }
+    return { success: true, target };
+  }
+  if (deployed.length === 0) {
+    return { success: false, error: { code: "no-history" } };
+  }
+  if (!activeUid) {
+    return { success: false, error: { code: "no-live-deployment" } };
+  }
+  const liveIndex = deployed.findIndex((record) => record.uid === activeUid);
+  if (liveIndex === -1) {
+    return { success: false, error: { code: "no-live-deployment" } };
+  }
+  const previous = deployed[liveIndex + 1];
+  if (!previous) {
+    return { success: false, error: { code: "no-previous" } };
+  }
+  return { success: true, target: previous };
+}
+
+// src/domains/project/rollback/action.ts
+var rollbackArgsSchema = external_exports.object({
+  slug: slugSchema.optional(),
+  to: external_exports.string().trim().min(1, "A build id is required for --to").optional(),
+  yes: external_exports.coerce.boolean().default(false)
+});
+async function rollbackAction(args) {
+  const argsParseResult = rollbackArgsSchema.safeParse(args);
+  if (argsParseResult.error) {
+    return output.error().title("Invalid Arguments").message(argsParseResult.error.issues[0].message).exit("error");
+  }
+  const { slug, to, yes } = 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");
+  }
+  const targetResult = selectRollbackTarget({
+    deployments: deploymentsResult.deployments,
+    activeUid,
+    to
+  });
+  if (!targetResult.success) {
+    if (targetResult.error.code === "already-live") {
+      output.info().title("Already live").message(
+        `Build "${targetResult.error.uid}" is already the live deployment.`
+      ).print();
+      return;
+    }
+    return renderRollbackError(targetResult.error, slug);
+  }
+  const { target } = targetResult;
+  const deployedLabel = formatAbsoluteTime(
+    (target.deployedAt ?? target.createdAt) * 1e3
+  );
+  if (!yes) {
+    const shouldContinue = await confirm({
+      message: `Roll back the live deployment of "${slug}" to build ${target.uid} (${deployedLabel})?`,
+      initialValue: false
+    });
+    if (shouldContinue !== true) {
+      output.info().title("Rollback cancelled.").print();
+      return;
+    }
+  }
+  const logger = output.info({ animate: true }).loader(`Rolling back to build ${target.uid} (${deployedLabel})`);
+  const redeployResult = await apiClient.publish.redeploy(target.uid);
+  if (redeployResult.error) {
+    logger.update("loader", 0, {
+      content: `Rollback to build ${target.uid} failed`
+    });
+    logger.finish();
+    return output.error().title("Rollback failed").message(redeployResult.message).exit("error");
+  }
+  logger.update("loader", 0, {
+    content: `Rolled back to build ${target.uid} (${deployedLabel})`
+  });
+  logger.finish();
+  const deploymentUrl = getPublishDeploymentUrl(target);
+  if (deploymentUrl) {
+    output.info().line(`Deployment URL: ${deploymentUrl}`).print();
+  }
+}
+function renderRollbackError(error, slug) {
+  switch (error.code) {
+    case "no-history":
+      return output.error().title("Nothing to roll back to").message(
+        `Project "${slug}" has no previous deployed builds. Publish a build first.`
+      ).exit("error");
+    case "no-previous":
+      return output.error().title("Nothing to roll back to").message(
+        `Project "${slug}" is already on its oldest deployed build, so there is no earlier build to roll back to. Run "scalar project deployments list --slug ${slug}" to see all builds, then pass --to <buildId> to deploy a specific one.`
+      ).exit("error");
+    case "no-live-deployment":
+      return output.error().title("No live deployment").message(
+        `Project "${slug}" has no build currently live, so there is no default to roll back to. Pass --to <buildId> to pick a specific build. Run "scalar project deployments list --slug ${slug}" to see available builds.`
+      ).exit("error");
+    case "target-not-found":
+      return output.error().title("Build not found").message(
+        `No deployed build with id "${error.uid}" was found. Run "scalar project deployments list --slug ${slug}" to see available builds.`
+      ).exit("error");
+    case "target-not-deployable":
+      return output.error().title("Build cannot be made live").message(
+        `Build "${error.uid}" has status "${error.status}", so it never finished deploying and cannot be rolled back to. Only builds with status "deployed" can be made live.`
+      ).exit("error");
+  }
+}
+export {
+  rollbackAction,
+  rollbackArgsSchema
+};

package/chunks/agent-HCQRMHQ5.js

@@ -0,0 +1,132 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  DASHBOARD_CHAT_CONTEXT_MAX_CHARS,
+  DASHBOARD_CHAT_MAX_MESSAGES,
+  DASHBOARD_EDITOR_CONTEXT_KEY,
+  DASHBOARD_EDITOR_TOOL_NAMES,
+  DASHBOARD_SDK_CONTEXT_KEY,
+  DASHBOARD_SDK_TOOL_NAMES,
+  agentApi,
+  agentApiErrorSchema,
+  analyticsGranularitySchema,
+  analyticsRangeSchema,
+  analyticsRoutes,
+  bumpKindSchema,
+  bumpStrategySchema,
+  dashboardChatBodySchema,
+  dashboardChatSettingsSchema,
+  dashboardRoutes,
+  docsChatContextSchema,
+  docsProjectAgentInfoSchema,
+  docsRoutes,
+  editorChatBodySchema,
+  editorRoutes,
+  installationParamSchema,
+  installationSummarySchema,
+  installationToolSchema,
+  internalRoutes,
+  mcpAnalyticsParamsSchema,
+  mcpCategoryTotalsSchema,
+  mcpConsumerKindSchema,
+  mcpConsumerStatSchema,
+  mcpConsumersResultSchema,
+  mcpDocsPageToolDetailSchema,
+  mcpErrorEntrySchema,
+  mcpErrorsResultSchema,
+  mcpExportDatasetSchema,
+  mcpInstallationRoutes,
+  mcpLatencyByToolEntrySchema,
+  mcpLatencyResultSchema,
+  mcpOperationToolDetailSchema,
+  mcpOverviewResultSchema,
+  mcpOverviewTotalsSchema,
+  mcpServerRoutes,
+  mcpServerWithInstallationsSchema,
+  mcpTimeseriesPointSchema,
+  mcpToolCategorySchema,
+  mcpToolKindSchema,
+  mcpToolStatSchema,
+  mcpToolsResultSchema,
+  mcpVersionRoutes,
+  mcpVersionToolsSchema,
+  openapiRoutes,
+  pubsubPushMessageSchema,
+  pubsubRoutes,
+  pullRequestDescriptionBodySchema,
+  registryDocumentSchema,
+  registryRoutes,
+  registrySearchResultSchema,
+  registryVersionOperationSchema,
+  semverParamSchema,
+  teamUsageResponseSchema,
+  usageRecordSchema,
+  usageRoutes
+} from "./chunk-HPL3ZZ2P.js";
+import "./chunk-VNYE4R7N.js";
+import "./chunk-OQKDBLOZ.js";
+import "./chunk-GSGZHE26.js";
+import "./chunk-IKT5F47M.js";
+import "./chunk-3MZYUBJ6.js";
+export {
+  DASHBOARD_CHAT_CONTEXT_MAX_CHARS,
+  DASHBOARD_CHAT_MAX_MESSAGES,
+  DASHBOARD_EDITOR_CONTEXT_KEY,
+  DASHBOARD_EDITOR_TOOL_NAMES,
+  DASHBOARD_SDK_CONTEXT_KEY,
+  DASHBOARD_SDK_TOOL_NAMES,
+  agentApi,
+  agentApiErrorSchema,
+  analyticsGranularitySchema,
+  analyticsRangeSchema,
+  analyticsRoutes,
+  bumpKindSchema,
+  bumpStrategySchema,
+  dashboardChatBodySchema,
+  dashboardChatSettingsSchema,
+  dashboardRoutes,
+  docsChatContextSchema,
+  docsProjectAgentInfoSchema,
+  docsRoutes,
+  editorChatBodySchema,
+  editorRoutes,
+  installationParamSchema,
+  installationSummarySchema,
+  installationToolSchema,
+  internalRoutes,
+  mcpAnalyticsParamsSchema,
+  mcpCategoryTotalsSchema,
+  mcpConsumerKindSchema,
+  mcpConsumerStatSchema,
+  mcpConsumersResultSchema,
+  mcpDocsPageToolDetailSchema,
+  mcpErrorEntrySchema,
+  mcpErrorsResultSchema,
+  mcpExportDatasetSchema,
+  mcpInstallationRoutes,
+  mcpLatencyByToolEntrySchema,
+  mcpLatencyResultSchema,
+  mcpOperationToolDetailSchema,
+  mcpOverviewResultSchema,
+  mcpOverviewTotalsSchema,
+  mcpServerRoutes,
+  mcpServerWithInstallationsSchema,
+  mcpTimeseriesPointSchema,
+  mcpToolCategorySchema,
+  mcpToolKindSchema,
+  mcpToolStatSchema,
+  mcpToolsResultSchema,
+  mcpVersionRoutes,
+  mcpVersionToolsSchema,
+  openapiRoutes,
+  pubsubPushMessageSchema,
+  pubsubRoutes,
+  pullRequestDescriptionBodySchema,
+  registryDocumentSchema,
+  registryRoutes,
+  registrySearchResultSchema,
+  registryVersionOperationSchema,
+  semverParamSchema,
+  teamUsageResponseSchema,
+  usageRecordSchema,
+  usageRoutes
+};

package/chunks/asyncapi-QM76O55R.js

@@ -0,0 +1,105 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  isAsyncApiDocument,
+  isDocument
+} 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/mock/asyncapi.ts
+import { serve } from "@hono/node-server";
+import { upgrade } from "@scalar/asyncapi-upgrader";
+import { validate } from "@scalar/asyncapi-validator";
+import { bundle } from "@scalar/json-magic/bundle";
+import { fetchUrls, readFiles } from "@scalar/json-magic/bundle/plugins/node";
+import { createAsyncApiMockServer } from "@scalar/mock-server";
+var loadAsyncApiMockDocument = async (input) => {
+  const document = await bundle(input, {
+    plugins: [readFiles(), fetchUrls()],
+    treeShake: false
+  });
+  if (!isDocument(document) || !isAsyncApiDocument(document)) {
+    throw new Error("Expected an AsyncAPI document");
+  }
+  const result = validate(document);
+  if (!result.valid) {
+    throw new Error("Invalid AsyncAPI document");
+  }
+  return upgrade(document);
+};
+var mockAsyncApi = async (input, options) => {
+  const document = await loadAsyncApiMockDocument(input).catch(
+    (error) => {
+      output.error().title(error.message).exit("error");
+    }
+  );
+  if (!document) return;
+  const connections = /* @__PURE__ */ new Set();
+  const start = async (nextDocument) => {
+    const { app, injectWebSocket } = await createAsyncApiMockServer({
+      document: nextDocument,
+      logger: (line) => output.info().line(line).print(),
+      onMessage: ({ channel, direction }) => {
+        output.info().line(`${direction} ${channel}`).print();
+      }
+    });
+    const server2 = serve(
+      { fetch: app.fetch, port: options.port ?? 3e3 },
+      ({ port }) => {
+        output.info().line(`AsyncAPI Mock Server listening on http://localhost:${port}`).print();
+      }
+    );
+    server2.on("connection", (socket) => {
+      connections.add(socket);
+      socket.once("close", () => connections.delete(socket));
+    });
+    injectWebSocket(server2);
+    return server2;
+  };
+  let server = await start(document);
+  let current = JSON.stringify(document);
+  let reloading = false;
+  const watcher = options.watch && !options.once ? await watchFile(input, async () => {
+    if (reloading) return;
+    reloading = true;
+    try {
+      const nextDocument = await loadAsyncApiMockDocument(input);
+      const serialized = JSON.stringify(nextDocument);
+      if (serialized === current) return;
+      await new Promise((resolve, reject) => {
+        server.close((error) => error ? reject(error) : resolve());
+        for (const socket of connections) socket.destroy();
+      });
+      server = await start(nextDocument);
+      current = serialized;
+    } catch (error) {
+      output.warn().title(String(error)).print();
+    } finally {
+      reloading = false;
+    }
+  }) : void 0;
+  if (options.once) {
+    setTimeout(() => {
+      void watcher?.unsubscribe();
+      server.close();
+      for (const socket of connections) socket.destroy();
+    }, 2e3);
+  }
+};
+export {
+  loadAsyncApiMockDocument,
+  mockAsyncApi
+};

package/chunks/build.action-P7FCIMYU.js

@@ -0,0 +1,108 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+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 {
+  sdkSchema
+} from "./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 "./chunk-CISTON3A.js";
+import "./chunk-Q7DOQHZN.js";
+import "./chunk-4ORL4MST.js";
+import {
+  output
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import {
+  docVersionSchema,
+  external_exports,
+  namespaceSchema,
+  slugSchema
+} from "./chunk-IKT5F47M.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/sdk/build.action.ts
+import { select } from "@clack/prompts";
+async function buildAction(opts) {
+  const { error, data } = external_exports.object({
+    slug: slugSchema.optional(),
+    namespace: namespaceSchema.optional(),
+    version: docVersionSchema.optional()
+  }).safeParse(opts);
+  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 client = await apiService();
+  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 SDK. Please specify a namespace or contact support."
+    ).exit("error");
+  }
+  const sdks = await db.getMany({
+    collectionPath: BaseCollections.Sdks(team.data.uid),
+    query: {
+      namespace
+    },
+    schema: sdkSchema.array()
+  });
+  if (sdks.error) return output.error().title(sdks.message).exit("error");
+  const sdkUid = sdks.data.find((sdk) => sdk.slug === data.slug)?.uid || await select({
+    message: "Please select an SDK to update",
+    options: sdks.data.map((sdk) => ({
+      value: sdk.uid,
+      label: sdk.slug
+    }))
+  });
+  const matchingSdk = sdks.data.find((sdk) => sdk.uid === sdkUid);
+  if (!matchingSdk) {
+    return output.error().title("No SDK found").message("Please provide a valid SDK slug").exit("error");
+  }
+  const version = matchingSdk.versions.find((v) => v.version === data.version)?.version || await select({
+    message: "Please select an SDK version to build",
+    options: matchingSdk.versions.map((version2) => ({
+      value: version2.version,
+      label: `v${version2.version}`
+    }))
+  });
+  const logger = output.info().loader("Creating SDK Build");
+  const response = await client.sdks.build(sdkUid, version);
+  if (response.error) {
+    return output.error().title("Something went wrong").message(response.message).exit("error");
+  }
+  logger.update("loader", 0, {
+    content: `SDK build kicked off for version v${version}`
+  }).exit("success");
+}
+export {
+  buildAction
+};

package/chunks/chunk-24WAOKGG.js

@@ -0,0 +1,105 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  detectManagedDocType
+} from "./chunk-CISTON3A.js";
+import {
+  isUrl
+} from "./chunk-4ORL4MST.js";
+import {
+  output
+} from "./chunk-T5HJUAWB.js";
+
+// src/domains/document/helpers/banner.ts
+import as from "ansis";
+var printSpecificationBanner = (result) => {
+  const { version, schema } = result;
+  if (!schema?.info?.title || !version) {
+    return;
+  }
+  const pathsCount = Object.keys(schema.paths ?? {}).length;
+  const operationsCount = Object.values(schema.paths ?? {}).reduce(
+    (acc, path) => acc + Object.keys(path).length,
+    0
+  );
+  output.info().title(
+    `${as.white.bold(schema?.info?.title)} ${as.grey(`(OpenAPI v${version})`)}`
+  ).title(as.grey(`${pathsCount} paths, ${operationsCount} operations`)).print();
+};
+
+// src/domains/document/helpers/safe-normalize.ts
+import { normalize } from "@scalar/json-magic/helpers/normalize";
+var safeNormalize = (value) => {
+  try {
+    return normalize(value);
+  } catch {
+    return void 0;
+  }
+};
+
+// src/domains/document/helpers/document-type.ts
+var isAsyncApiDocument = (document) => detectManagedDocType(document) === "asyncapi";
+var isAsyncApiContent = (content) => content.includes("asyncapi") && isAsyncApiDocument(safeNormalize(content));
+
+// src/domains/document/helpers/imports.ts
+import fs from "node:fs";
+import as2 from "ansis";
+import { load, validate } from "@scalar/openapi-parser";
+var getFileOrUrl = async (input) => {
+  if (isUrl(input)) {
+    const response = await fetch(input);
+    if (!response.ok) {
+      return output.error().title("Failed to fetch from URL.").exit("error");
+    }
+    return await response.text();
+  }
+  if (!fs.existsSync(input)) {
+    return output.error().title("Could not read file.").exit("error");
+  }
+  return fs.readFileSync(input, "utf-8");
+};
+var loadOpenApiFile = async (input) => {
+  return loadOpenApiDocument(await getFileOrUrl(input));
+};
+var loadOpenApiDocument = async (specification) => {
+  try {
+    const { filesystem } = await load(specification);
+    const result = await validate(filesystem);
+    if (!result.valid) {
+      output.warn().title("File does not match the OpenAPI specification.").print();
+      result.errors?.forEach((error) => {
+        output.warn().title(`${error.message} (${error.path})`).print();
+      });
+      return result;
+    }
+    return result;
+  } catch (error) {
+    output.error().title(error ? as2.red(error.toString()) : "Unknown error.").print();
+    const message = typeof error === "object" && error !== null && "message" in error ? String(error.message) : "Unknown error";
+    return {
+      valid: false,
+      version: void 0,
+      specification: void 0,
+      schema: void 0,
+      errors: [
+        {
+          message,
+          path: []
+        }
+      ]
+    };
+  }
+};
+
+// src/domains/document/helpers/is-document.ts
+var isDocument = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+
+export {
+  printSpecificationBanner,
+  safeNormalize,
+  isAsyncApiDocument,
+  isAsyncApiContent,
+  getFileOrUrl,
+  loadOpenApiFile,
+  loadOpenApiDocument,
+  isDocument
+};