@scalar/cli 2.0.1 → 2.1.0

package/chunks/chunk-4DGQIAJX.js

@@ -0,0 +1,359 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  brandedUid,
+  customProjectIconSchema,
+  emailSchema,
+  entitySchema,
+  mintUid,
+  namespaceSchema,
+  nanoidSchema,
+  schemaModel,
+  slugSchema
+} from "./chunk-ISGLWBXZ.js";
+import {
+  external_exports
+} from "./chunk-H2WRMLYY.js";
+
+// ../../packages/entities/dist/team/access.js
+var ExternalAccessMethod;
+(function(ExternalAccessMethod2) {
+  ExternalAccessMethod2["Email"] = "email";
+  ExternalAccessMethod2["SSO"] = "sso";
+  ExternalAccessMethod2["Google"] = "google";
+  ExternalAccessMethod2["Microsoft"] = "microsoft";
+})(ExternalAccessMethod || (ExternalAccessMethod = {}));
+var emailInheritingExternalAccessMethods = [
+  ExternalAccessMethod.Google
+];
+var externalAccessMethodByProvider = {
+  google: ExternalAccessMethod.Google,
+  microsoft: ExternalAccessMethod.Microsoft
+};
+var externalAccessMethodsSchema = external_exports.object({
+  [ExternalAccessMethod.Email]: external_exports.boolean().default(true),
+  [ExternalAccessMethod.SSO]: external_exports.boolean().default(false),
+  /** No default: an unset social method inherits the email setting */
+  [ExternalAccessMethod.Google]: external_exports.boolean().optional(),
+  [ExternalAccessMethod.Microsoft]: external_exports.boolean().optional()
+}).meta({ id: "external-access-methods" });
+var externalAccessMethodLabels = {
+  [ExternalAccessMethod.Email]: "Email Magic Link",
+  [ExternalAccessMethod.SSO]: "Single Sign-On",
+  [ExternalAccessMethod.Google]: "Google OAuth",
+  [ExternalAccessMethod.Microsoft]: "Microsoft OAuth"
+};
+var externalAccessSchema = external_exports.object({
+  /** Available authentication methods for external access */
+  methods: externalAccessMethodsSchema.default(schemaModel({}, externalAccessMethodsSchema))
+}).meta({ id: "external-access" });
+
+// ../../packages/entities/dist/team/billing-plan.js
+var BillingPlan;
+(function(BillingPlan2) {
+  BillingPlan2["Trial"] = "trial";
+  BillingPlan2["Free"] = "free";
+  BillingPlan2["ProMonthly"] = "pro_monthly";
+  BillingPlan2["ProYearly"] = "pro_yearly";
+  BillingPlan2["Premium"] = "premium";
+  BillingPlan2["Enterprise"] = "enterprise";
+})(BillingPlan || (BillingPlan = {}));
+var billingPlanLabels = {
+  [BillingPlan.Free]: "Free",
+  [BillingPlan.Trial]: "Trial",
+  [BillingPlan.ProMonthly]: "Monthly",
+  [BillingPlan.Premium]: "Monthly",
+  [BillingPlan.ProYearly]: "Yearly",
+  [BillingPlan.Enterprise]: "Enterprise"
+};
+
+// ../../packages/entities/dist/team/feature-flags.js
+var FeatureFlag;
+(function(FeatureFlag2) {
+  FeatureFlag2["Rules"] = "rules";
+  FeatureFlag2["Registry"] = "registry";
+  FeatureFlag2["Schemas"] = "schemas";
+  FeatureFlag2["SDK"] = "sdk";
+  FeatureFlag2["CLI"] = "cli";
+  FeatureFlag2["Agent"] = "agent";
+  FeatureFlag2["MCP"] = "mcp";
+  FeatureFlag2["Workspaces"] = "workspaces";
+  FeatureFlag2["Export"] = "export";
+  FeatureFlag2["DocsMCP"] = "docsMcp";
+  FeatureFlag2["DisableApiSSR"] = "disableApiSSR";
+  FeatureFlag2["UnifiedDocs"] = "unifiedDocs";
+  FeatureFlag2["DocsAnalytics"] = "docsAnalytics";
+  FeatureFlag2["McpAnalytics"] = "mcpAnalytics";
+  FeatureFlag2["MicrosoftLogin"] = "microsoftLogin";
+  FeatureFlag2["EditorPreview"] = "editorPreview";
+  FeatureFlag2["RegistryGit"] = "registryGit";
+  FeatureFlag2["AutoBillSeats"] = "autoBillSeats";
+  FeatureFlag2["AutoBillSdks"] = "autoBillSdks";
+})(FeatureFlag || (FeatureFlag = {}));
+var featureSchema = external_exports.boolean().optional().meta({ id: "feature" });
+var featureUpdateSchema = external_exports.boolean().nullable().optional();
+var featureFlagSchema = external_exports.object({
+  [FeatureFlag.Rules]: featureSchema,
+  [FeatureFlag.Registry]: featureSchema,
+  [FeatureFlag.Schemas]: featureSchema,
+  [FeatureFlag.SDK]: featureSchema,
+  [FeatureFlag.CLI]: featureSchema,
+  [FeatureFlag.Agent]: featureSchema,
+  [FeatureFlag.Workspaces]: featureSchema,
+  [FeatureFlag.MCP]: featureSchema,
+  [FeatureFlag.Export]: featureSchema,
+  [FeatureFlag.DocsMCP]: featureSchema,
+  [FeatureFlag.DisableApiSSR]: featureSchema,
+  [FeatureFlag.UnifiedDocs]: featureSchema,
+  [FeatureFlag.DocsAnalytics]: featureSchema,
+  [FeatureFlag.McpAnalytics]: featureSchema,
+  [FeatureFlag.MicrosoftLogin]: featureSchema,
+  [FeatureFlag.EditorPreview]: featureSchema,
+  [FeatureFlag.RegistryGit]: featureSchema,
+  [FeatureFlag.AutoBillSeats]: featureSchema,
+  [FeatureFlag.AutoBillSdks]: featureSchema
+}).meta({ id: "feature-flag" });
+var featureFlagUpdateSchema = external_exports.object(Object.fromEntries(Object.values(FeatureFlag).map((featureFlag) => [
+  featureFlag,
+  featureUpdateSchema
+]))).meta({ id: "feature-flag-update" });
+var autoBillingFlags = {
+  seats: FeatureFlag.AutoBillSeats,
+  sdks: FeatureFlag.AutoBillSdks
+};
+var DEFAULT_ON_FLAGS = /* @__PURE__ */ new Set([
+  ...Object.values(autoBillingFlags),
+  /**
+   * MCP analytics is on for everyone; the flag remains only as a per-team kill
+   * switch. Ingest has always run for every team regardless of the flag, so
+   * this grants read access to records that already exist rather than starting
+   * any new collection.
+   */
+  FeatureFlag.McpAnalytics
+]);
+
+// ../../packages/entities/dist/team/schema.js
+var TeamUserRole;
+(function(TeamUserRole2) {
+  TeamUserRole2["Owner"] = "owner";
+  TeamUserRole2["Admin"] = "admin";
+  TeamUserRole2["Editor"] = "editor";
+  TeamUserRole2["Viewer"] = "viewer";
+})(TeamUserRole || (TeamUserRole = {}));
+var roleLabels = {
+  [TeamUserRole.Admin]: "Admin",
+  [TeamUserRole.Editor]: "Editor",
+  [TeamUserRole.Owner]: "Owner",
+  [TeamUserRole.Viewer]: "Viewer"
+};
+var roleSchema = external_exports.enum(TeamUserRole).meta({ id: "role" });
+var userRefSchema = external_exports.object({
+  uid: brandedUid(),
+  role: roleSchema,
+  displayName: external_exports.string(),
+  imageUri: external_exports.string().optional(),
+  activeProjectUid: external_exports.string().default(""),
+  nonBillable: external_exports.boolean().default(false).optional()
+}).meta({ id: "user-ref" });
+var billingPlanSchema = external_exports.enum(BillingPlan).meta({ id: "billing-plan" });
+var billingInfoSchema = external_exports.preprocess((arg) => {
+  if (typeof arg?.hasTrial === "boolean" && ![
+    BillingPlan.Premium,
+    BillingPlan.ProMonthly,
+    BillingPlan.ProYearly
+  ].includes(arg?.plan)) {
+    arg.plan = "trial";
+  }
+  return arg;
+}, external_exports.object({
+  billingId: nanoidSchema.optional(),
+  email: emailSchema,
+  plan: billingPlanSchema,
+  expires: external_exports.number().optional(),
+  sdkTrialReminderSentAt: external_exports.number().optional(),
+  trialEndedReminderSentAt: external_exports.number().optional(),
+  trialExtendedAt: external_exports.number().optional(),
+  includedCreditsOverride: external_exports.number().optional()
+})).meta({ id: "billing-info" });
+var invoiceStatusSchema = external_exports.enum(["open", "paid", "draft", "void", "uncollectible"]).meta({ id: "invoice-status" });
+var billingInvoiceSchema = external_exports.object({
+  id: external_exports.string(),
+  /** Total invoice payment amount */
+  total: external_exports.number(),
+  /** Invoice status - we should only display open and paid to users  */
+  status: invoiceStatusSchema.nullable(),
+  /** Invoice payment date */
+  paymentDate: external_exports.number(),
+  /** Currency for payment */
+  currency: external_exports.string(),
+  /** PDF download link */
+  downloadUrl: external_exports.string().nullable().optional()
+}).meta({ id: "billing-invoice" });
+var cardSchema = external_exports.object({
+  last4: external_exports.string().length(4),
+  expMonth: external_exports.number(),
+  expYear: external_exports.number()
+}).meta({ id: "card" });
+var teamBillingSummary = external_exports.object({
+  /** All invoices for a team */
+  invoices: billingInvoiceSchema.array().default([]),
+  /** Stripe customer billing address */
+  address: external_exports.string().nullable(),
+  card: cardSchema.nullable(),
+  /** Basic Scalar billing info from team record */
+  billingInfo: billingInfoSchema
+}).meta({ id: "team-billing-summary" });
+var pendingInviteSchema = external_exports.object({
+  uid: nanoidSchema,
+  role: roleSchema.default(TeamUserRole.Editor),
+  email: emailSchema,
+  expires: external_exports.number().optional()
+}).meta({ id: "pending-invite" });
+var teamNameSchema = external_exports.string().trim().overwrite((s) => s.length ? s : "Untitled Team").meta({ id: "team-name" });
+var teamImageSchema = external_exports.string().optional().meta({ id: "team-image" });
+var TeamOnboardingState;
+(function(TeamOnboardingState2) {
+  TeamOnboardingState2["Setup"] = "setup";
+  TeamOnboardingState2["Complete"] = "complete";
+})(TeamOnboardingState || (TeamOnboardingState = {}));
+var TeamAuthenticationMethod;
+(function(TeamAuthenticationMethod2) {
+  TeamAuthenticationMethod2["Password"] = "password";
+  TeamAuthenticationMethod2["Google"] = "google";
+  TeamAuthenticationMethod2["GitHub"] = "github";
+  TeamAuthenticationMethod2["SSO"] = "sso";
+})(TeamAuthenticationMethod || (TeamAuthenticationMethod = {}));
+var teamAuthenticationMethodLabels = {
+  [TeamAuthenticationMethod.Google]: "Google OAuth",
+  [TeamAuthenticationMethod.GitHub]: "GitHub OAuth",
+  [TeamAuthenticationMethod.Password]: "Email & Password",
+  [TeamAuthenticationMethod.SSO]: "Single Sign-On"
+};
+var teamAuthenticationMethodsSchema = external_exports.object({
+  [TeamAuthenticationMethod.Password]: external_exports.boolean().default(true),
+  [TeamAuthenticationMethod.Google]: external_exports.boolean().default(true),
+  [TeamAuthenticationMethod.GitHub]: external_exports.boolean().default(true),
+  [TeamAuthenticationMethod.SSO]: external_exports.boolean().default(true)
+}).meta({ id: "team-authentication-methods" });
+var teamAuthenticationSchema = external_exports.object({
+  /** General team level enabled authentication methods */
+  methods: teamAuthenticationMethodsSchema.default(schemaModel({}, teamAuthenticationMethodsSchema)),
+  /**
+   * Allowlist of domains for login.
+   *
+   * If empty, all domains are allowed.
+   */
+  domains: external_exports.string().array().default([]),
+  /**
+   * User level authentication methods.
+   *
+   * Overrides general team methods that were
+   * enabled/disabled.
+   */
+  userControls: external_exports.record(nanoidSchema, teamAuthenticationMethodsSchema).default({})
+}).meta({ id: "team-authentication" });
+var teamSchema = entitySchema.extend({
+  /** Own uid, branded so it cannot be confused with another entity's uid */
+  uid: brandedUid().default(mintUid).meta({ default: "nanoid()" }),
+  name: teamNameSchema,
+  slug: slugSchema,
+  archived: external_exports.boolean().optional().default(false),
+  imageUri: teamImageSchema,
+  theme: external_exports.string().default("default"),
+  onboarding: external_exports.enum(TeamOnboardingState).default(TeamOnboardingState.Complete),
+  billingInfo: billingInfoSchema,
+  namespaces: namespaceSchema.array().refine((ns) => !ns.includes("share"), {
+    message: '"share" is a reserved namespace and cannot be used'
+  }).default([]),
+  users: userRefSchema.array(),
+  icons: customProjectIconSchema.array().default([]),
+  pendingInvites: pendingInviteSchema.array().default([]),
+  /** Team auth configuration */
+  authentication: teamAuthenticationSchema.default(schemaModel({}, teamAuthenticationSchema)),
+  externalAccess: externalAccessSchema.default(schemaModel({}, externalAccessSchema)),
+  features: featureFlagSchema.default({}),
+  /**
+   * Teams can be manually verified when they need to upload documents
+   * containing prohibited text or links. This is manually set by request.
+   */
+  verified: external_exports.boolean().default(false).optional()
+}).meta({ id: "team" });
+
+// ../../packages/entities/dist/team/helpers.js
+var billingFeatures = {
+  team: {
+    archival: "teamArchival"
+  },
+  authentication: {
+    sso: "sso"
+  }
+};
+var teamBillingFeatures = {
+  [billingFeatures.team.archival]: {
+    [BillingPlan.Enterprise]: true,
+    [BillingPlan.Premium]: true,
+    [BillingPlan.ProMonthly]: true,
+    [BillingPlan.ProYearly]: true
+  },
+  [billingFeatures.authentication.sso]: {
+    [BillingPlan.Enterprise]: true
+  }
+};
+var permissions = {
+  team: {
+    delete: "deleteTeam",
+    manage: "manageTeam",
+    manageOwners: "manageOwners"
+  },
+  docs: {
+    create: "createDocs",
+    edit: "editDocs",
+    delete: "deleteDocs"
+  }
+};
+var teamPermissions = {
+  [permissions.team.manageOwners]: {
+    [TeamUserRole.Owner]: true,
+    [TeamUserRole.Admin]: false,
+    [TeamUserRole.Editor]: false,
+    [TeamUserRole.Viewer]: false
+  },
+  [permissions.team.manage]: {
+    [TeamUserRole.Owner]: true,
+    [TeamUserRole.Admin]: true,
+    [TeamUserRole.Editor]: false,
+    [TeamUserRole.Viewer]: false
+  },
+  [permissions.team.delete]: {
+    [TeamUserRole.Owner]: true,
+    [TeamUserRole.Admin]: false,
+    [TeamUserRole.Editor]: false,
+    [TeamUserRole.Viewer]: false
+  },
+  [permissions.docs.create]: {
+    [TeamUserRole.Owner]: true,
+    [TeamUserRole.Admin]: true,
+    [TeamUserRole.Editor]: true,
+    [TeamUserRole.Viewer]: false
+  },
+  [permissions.docs.edit]: {
+    [TeamUserRole.Owner]: true,
+    [TeamUserRole.Admin]: true,
+    [TeamUserRole.Editor]: true,
+    [TeamUserRole.Viewer]: false
+  },
+  [permissions.docs.delete]: {
+    [TeamUserRole.Owner]: true,
+    [TeamUserRole.Admin]: true,
+    [TeamUserRole.Editor]: true,
+    [TeamUserRole.Viewer]: false
+  }
+};
+
+export {
+  roleSchema,
+  billingPlanSchema,
+  teamBillingSummary,
+  teamNameSchema,
+  teamImageSchema,
+  teamSchema
+};

package/chunks/chunk-4QS7SJTG.js

@@ -0,0 +1,138 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  baseRegistrySchema
+} from "./chunk-VTYTPSXO.js";
+import {
+  methodSchema
+} from "./chunk-TLFMATXR.js";
+import {
+  brandedUid,
+  compareVersionsDesc,
+  docVersionSchema,
+  mintUid,
+  nanoidSchema
+} from "./chunk-ISGLWBXZ.js";
+import {
+  external_exports
+} from "./chunk-H2WRMLYY.js";
+
+// ../../packages/entities/dist/rule/default-data.js
+var scalarRuleset = `extends: spectral:oas
+rules: {}`;
+
+// ../../packages/entities/dist/rule/schema.js
+var blockPublishOnSchema = external_exports.enum([
+  "error",
+  "warning",
+  "info",
+  "hint",
+  "none"
+]);
+var ruleSchema = baseRegistrySchema.extend({
+  blockPublishOn: blockPublishOnSchema.default("none")
+}).meta({ id: "rule" });
+
+// ../../packages/entities/dist/managed-doc/managed-doc.js
+var RegistryAsset;
+(function(RegistryAsset2) {
+  RegistryAsset2["Apis"] = "apis";
+  RegistryAsset2["Rules"] = "rules";
+  RegistryAsset2["Sdks"] = "sdks";
+  RegistryAsset2["Schemas"] = "schemas";
+  RegistryAsset2["Workspaces"] = "workspaces";
+})(RegistryAsset || (RegistryAsset = {}));
+var ApiEmbedStatus;
+(function(ApiEmbedStatus2) {
+  ApiEmbedStatus2["Complete"] = "complete";
+  ApiEmbedStatus2["Failed"] = "failed";
+})(ApiEmbedStatus || (ApiEmbedStatus = {}));
+var managedDocTool = external_exports.object({
+  path: external_exports.string(),
+  method: methodSchema,
+  enabledTools: external_exports.enum(["execute-request", "get-mini-openapi-spec"]).array()
+});
+var managedDocVersionSchema = external_exports.object({
+  uid: nanoidSchema,
+  /** Millisecond base timestamp of versions  */
+  createdAt: external_exports.number(),
+  version: docVersionSchema,
+  /** OpenAPI version normalized on upload */
+  upgraded: external_exports.boolean().default(false),
+  /** Vector embeddings processed, agent is enabled */
+  embedStatus: external_exports.enum(ApiEmbedStatus).nullable().default(null),
+  tags: external_exports.string().array().default([]),
+  tools: managedDocTool.array().optional(),
+  /** SHA-256 hex digest of the YAML content stored in the registry bucket */
+  yamlSha: external_exports.string().optional(),
+  /** SHA-256 hex digest of the JSON content stored in the registry bucket */
+  jsonSha: external_exports.string().optional(),
+  /** Random opaque token regenerated whenever the version's content changes */
+  versionSha: external_exports.string().optional()
+}).meta({ id: "managed-doc-version" });
+var managedDocSchema = baseRegistrySchema.extend({
+  /** Own uid, branded so it cannot be confused with another entity's uid */
+  uid: brandedUid().default(mintUid).meta({ default: "nanoid()" }),
+  /** The current version served to consumers by default */
+  version: docVersionSchema,
+  /**
+   * Certain types of collections will be write restricted for properties
+   * that would mutate the original specification (such as adding endpoints)
+   */
+  isExternal: external_exports.boolean().default(true),
+  /** Repository information if we are managing a github spec */
+  repository: external_exports.object({
+    linkedBy: external_exports.string(),
+    id: external_exports.number(),
+    name: external_exports.string().min(2),
+    path: external_exports.string().default(""),
+    branch: external_exports.string().default("")
+  }).optional(),
+  /** URL to the source spec if we are managing a hosted spec */
+  sourceUrl: external_exports.url().optional(),
+  /** Theme assigned to API, supports custom theme slugs */
+  theme: external_exports.string().default(""),
+  /**
+   * UID to the collaborative YJS doc
+   *
+   * This content will be replaced on submitted updates and able to be edited in real-time
+   * When a user is ready to commit their changes they can bump the version with the changed content
+   */
+  editableUid: external_exports.string(),
+  ruleset: external_exports.string().default(scalarRuleset),
+  /**
+   * An ordered version history record
+   *
+   * When a sync update is requested we find any versions with timestamps
+   * later than the local base and determine the mutation records
+   *
+   * Mutations records will then need to be diffed and conflicts handled locally
+   * before pushing to the database
+   */
+  versions: managedDocVersionSchema.array(),
+  /** Enable Agent Scalar */
+  agentEnabled: external_exports.boolean().default(true),
+  /**
+   * Scalar verified status
+   *
+   * This will be moved in the future to a separate
+   * collection for registry DNS checks.
+   */
+  verified: external_exports.boolean().default(false)
+}).meta({ id: "managed-doc" });
+
+// ../../packages/entities/dist/managed-doc/helpers.js
+function getLegacyWysiwygVersion(versions) {
+  if (versions.includes("latest")) {
+    return "latest";
+  }
+  const latestVersion = [...versions].sort((a, b) => compareVersionsDesc(a, b))[0];
+  return latestVersion ?? "latest";
+}
+
+export {
+  ruleSchema,
+  getLegacyWysiwygVersion,
+  RegistryAsset,
+  managedDocVersionSchema,
+  managedDocSchema
+};