@scalar/cli 2.0.1 → 2.5.1

package/chunks/chunk-UGGNHILG.js

@@ -0,0 +1,38 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  registryUrl
+} from "./chunk-COBPBRQF.js";
+
+// src/domains/registry/helpers/fetch.ts
+async function fetchFromRegistry(path, accessToken) {
+  let response;
+  try {
+    response = await fetch(registryUrl(path), {
+      headers: {
+        "x-scalar-auth": accessToken
+      },
+      // Should always error on redirect
+      redirect: "error"
+    });
+  } catch (error) {
+    return {
+      error: true,
+      message: error instanceof Error && error.message.length > 0 ? error.message : "Registry request failed before a response was received."
+    };
+  }
+  if (!response.ok) {
+    const message = await response.text();
+    return {
+      error: true,
+      message: message.length ? message : `Registry request failed with status ${response.status}.`
+    };
+  }
+  return {
+    error: false,
+    data: await response.text()
+  };
+}
+
+export {
+  fetchFromRegistry
+};

package/chunks/chunk-VNYE4R7N.js

@@ -0,0 +1,499 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  customProjectIconSchema
+} from "./chunk-OQKDBLOZ.js";
+import {
+  brandedUid,
+  emailSchema,
+  entitySchema,
+  external_exports,
+  mintUid,
+  namespaceSchema,
+  nanoidSchema,
+  schemaModel,
+  slugSchema,
+  timestampSchema,
+  unixTimestamp
+} from "./chunk-IKT5F47M.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["BusinessMonthly"] = "business_monthly";
+  BillingPlan2["BusinessYearly"] = "business_yearly";
+  BillingPlan2["Enterprise"] = "enterprise";
+})(BillingPlan || (BillingPlan = {}));
+var billingPlanLabels = {
+  [BillingPlan.Free]: "Free",
+  [BillingPlan.Trial]: "Trial",
+  [BillingPlan.ProMonthly]: "Pro (Monthly)",
+  [BillingPlan.Premium]: "Pro (Monthly)",
+  [BillingPlan.ProYearly]: "Pro (Yearly)",
+  [BillingPlan.BusinessMonthly]: "Business (Monthly)",
+  [BillingPlan.BusinessYearly]: "Business (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["UnifiedMcp"] = "unifiedMcp";
+  FeatureFlag2["DocsAnalytics"] = "docsAnalytics";
+  FeatureFlag2["McpAnalytics"] = "mcpAnalytics";
+  FeatureFlag2["MicrosoftLogin"] = "microsoftLogin";
+  FeatureFlag2["EditorPreview"] = "editorPreview";
+  FeatureFlag2["RegistryGit"] = "registryGit";
+  FeatureFlag2["AutoBillSeats"] = "autoBillSeats";
+  FeatureFlag2["AutoBillSdks"] = "autoBillSdks";
+  FeatureFlag2["SdkOpenApiEditor"] = "sdkOpenApiEditor";
+  FeatureFlag2["DashboardChat"] = "dashboardChat";
+})(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.UnifiedMcp]: featureSchema,
+  [FeatureFlag.DocsAnalytics]: featureSchema,
+  [FeatureFlag.McpAnalytics]: featureSchema,
+  [FeatureFlag.MicrosoftLogin]: featureSchema,
+  [FeatureFlag.EditorPreview]: featureSchema,
+  [FeatureFlag.RegistryGit]: featureSchema,
+  [FeatureFlag.AutoBillSeats]: featureSchema,
+  [FeatureFlag.AutoBillSdks]: featureSchema,
+  [FeatureFlag.SdkOpenApiEditor]: featureSchema,
+  [FeatureFlag.DashboardChat]: 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,
+  /**
+   * The dashboard assistant is on for everyone; an explicit per-team false
+   * remains the kill switch, which also hides the docs editor's Ask AI entry
+   * points since the editor's chat is a plug-in of the assistant. Listed here
+   * so the server-side gate and the admin flag editor's "Default (On)" label
+   * agree with the dashboard's client default.
+   */
+  FeatureFlag.DashboardChat,
+  /**
+   * The MCP studio is on for everyone; an explicit per-team false remains the
+   * kill switch back to the legacy MCP pages. Listed here so the server-side
+   * gate and the admin flag editor's "Default (On)" label agree with the
+   * dashboard's client default.
+   */
+  FeatureFlag.UnifiedMcp,
+  /**
+   * The unified editor is on for everyone: the legacy dashboard surfaces are
+   * deleted, so the dashboard serves the studios regardless. Listed here so
+   * the server-side gate and the admin flag editor's "Default (On)" label
+   * agree with the dashboard's client default; an explicit per-team false
+   * remains the kill switch.
+   */
+  FeatureFlag.UnifiedDocs,
+  /**
+   * Editing an SDK's OpenAPI document is on for everyone; an explicit per-team
+   * false remains the kill switch, and the dashboard still gates the surface on
+   * the flag, so withdrawing it withdraws the panel. Listed here so the
+   * server-side gate and the admin flag editor's "Default (On)" label agree
+   * with the dashboard's client default.
+   */
+  FeatureFlag.SdkOpenApiEditor
+]);
+
+// ../../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,
+    BillingPlan.BusinessMonthly,
+    BillingPlan.BusinessYearly,
+    BillingPlan.Enterprise
+  ].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(),
+  pastDue: external_exports.boolean().optional(),
+  pricingModel: external_exports.enum(["flat_2026"]).nullish()
+})).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 sdkPriceBandLiterals = {
+  standard: "standard",
+  large: "large"
+};
+var sdkPriceBandSchema = external_exports.enum(sdkPriceBandLiterals);
+var requiredTierLiterals = {
+  pro: "pro",
+  business: "business",
+  enterprise: "enterprise"
+};
+var teamSdkPricing = external_exports.object({
+  sdks: external_exports.object({
+    uid: nanoidSchema,
+    /** Endpoints in the document this SDK builds against; null when unmeasured. */
+    endpointCount: external_exports.number().int().nullable(),
+    /** Targets this SDK currently bills. */
+    billedTargets: external_exports.number().int(),
+    band: sdkPriceBandSchema
+  }).array().default([]),
+  /**
+   * Managed APIs with the size of the version they serve, for quoting an SDK
+   * that does not exist yet.
+   */
+  apis: external_exports.object({
+    uid: nanoidSchema,
+    endpointCount: external_exports.number().int().nullable(),
+    band: sdkPriceBandSchema
+  }).array().default([]),
+  /** Billable targets per band, after the plan's included unit is comped. */
+  bands: external_exports.record(sdkPriceBandSchema, external_exports.number().int()),
+  /** The lowest tier the team's largest SDK requires. */
+  requiredTier: external_exports.enum(requiredTierLiterals)
+}).meta({ id: "team-sdk-pricing" });
+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 UnifiedDocsMigrationStatus;
+(function(UnifiedDocsMigrationStatus2) {
+  UnifiedDocsMigrationStatus2["Requested"] = "requested";
+  UnifiedDocsMigrationStatus2["InProgress"] = "in-progress";
+  UnifiedDocsMigrationStatus2["Completed"] = "completed";
+  UnifiedDocsMigrationStatus2["Failed"] = "failed";
+})(UnifiedDocsMigrationStatus || (UnifiedDocsMigrationStatus = {}));
+var unifiedDocsMigrationSchema = external_exports.object({
+  status: external_exports.enum(UnifiedDocsMigrationStatus),
+  /** When the current status was entered, not when the team first asked */
+  updatedAt: timestampSchema.default(unixTimestamp).meta({ default: "unixTimestamp()" }),
+  /**
+   * The user who pressed the button, or null when ops started the migration.
+   * Only used to attribute the request — permissions are checked at the route.
+   */
+  requestedBy: external_exports.string().nullable().default(null),
+  /** Populated on `Failed` so the dashboard can show why without a log dive */
+  error: external_exports.string().nullable().default(null),
+  projectsMigrated: external_exports.number().int().default(0),
+  projectsTotal: external_exports.number().int().default(0)
+});
+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({}),
+  /**
+   * Progress through the move off the legacy WYSIWYG editor. Absent on teams
+   * that have never been touched by the migration — including every team that
+   * signed up already on Unified Docs, which has nothing to migrate.
+   */
+  unifiedDocsMigration: unifiedDocsMigrationSchema.optional(),
+  /**
+   * 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"
+  },
+  access: {
+    groups: "accessGroups"
+  },
+  publishing: {
+    subpath: "subpathHosting"
+  }
+};
+var teamBillingFeatures = {
+  [billingFeatures.team.archival]: {
+    [BillingPlan.Enterprise]: true,
+    [BillingPlan.Premium]: true,
+    [BillingPlan.ProMonthly]: true,
+    [BillingPlan.ProYearly]: true,
+    [BillingPlan.BusinessMonthly]: true,
+    [BillingPlan.BusinessYearly]: true
+  },
+  // SSO/SAML starts on Business under the four-plan model.
+  [billingFeatures.authentication.sso]: {
+    [BillingPlan.BusinessMonthly]: true,
+    [BillingPlan.BusinessYearly]: true,
+    [BillingPlan.Enterprise]: true
+  },
+  // Access groups start on Pro; Trial is included so it keeps demoing the Pro
+  // experience (expiry already short-circuits in hasTeamBillingFeature).
+  [billingFeatures.access.groups]: {
+    [BillingPlan.Trial]: true,
+    [BillingPlan.Premium]: true,
+    [BillingPlan.ProMonthly]: true,
+    [BillingPlan.ProYearly]: true,
+    [BillingPlan.BusinessMonthly]: true,
+    [BillingPlan.BusinessYearly]: true,
+    [BillingPlan.Enterprise]: true
+  },
+  // Subpath hosting starts on Business.
+  [billingFeatures.publishing.subpath]: {
+    [BillingPlan.BusinessMonthly]: true,
+    [BillingPlan.BusinessYearly]: true,
+    [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,
+  userRefSchema,
+  billingPlanSchema,
+  teamBillingSummary,
+  teamSdkPricing,
+  pendingInviteSchema,
+  teamNameSchema,
+  teamImageSchema,
+  UnifiedDocsMigrationStatus,
+  teamSchema
+};

package/chunks/chunk-X5T526CE.js

@@ -0,0 +1,23 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+
+// src/domains/project/download-isolate/index.ts
+import os from "node:os";
+import path from "node:path";
+import { Command } from "commander";
+var ISOLATE_EXTRACTION_DIR = path.join(os.homedir(), ".scalar");
+var ISOLATE_DIR = path.join(ISOLATE_EXTRACTION_DIR, "isolate");
+var DownloadIsolateCommand = () => {
+  const cmd = new Command("download-isolate");
+  cmd.description("Download the docs preview server");
+  cmd.action(async () => {
+    const { downloadIsolate } = await import("./action-UZQJNYK4.js");
+    await downloadIsolate();
+  });
+  return cmd;
+};
+
+export {
+  ISOLATE_EXTRACTION_DIR,
+  ISOLATE_DIR,
+  DownloadIsolateCommand
+};