@scalar/cli 2.0.1 → 2.1.0

package/chunks/chunk-T7B6WNZC.js

@@ -0,0 +1,18 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+
+// src/domains/project/resolve-project.ts
+async function resolveProject(slug, apiClient) {
+  const githubResult = await apiClient.github.getProject(slug);
+  if (!githubResult.error) {
+    return { kind: "github", project: githubResult.data };
+  }
+  const docsResult = await apiClient.docsProject.getProject(slug);
+  if (!docsResult.error) {
+    return { kind: "docs", project: docsResult.data };
+  }
+  return { kind: "not-found" };
+}
+
+export {
+  resolveProject
+};

package/chunks/chunk-T7MDADON.js

@@ -0,0 +1,17 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  config
+} from "./chunk-OAXFCOJV.js";
+
+// src/domains/registry/helpers/links.ts
+function registryUrl(path) {
+  return `${config.projects.registry}/${path}`;
+}
+function dashboardUrl(asset, uid) {
+  return `${config.projects.dashboard}/registry/${asset}/${uid}`;
+}
+
+export {
+  registryUrl,
+  dashboardUrl
+};

package/chunks/chunk-TLFMATXR.js

@@ -0,0 +1,344 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  docVersionSchema,
+  namespaceSchema,
+  nanoidSchema,
+  slugSchema
+} from "./chunk-ISGLWBXZ.js";
+import {
+  external_exports,
+  zod_default
+} from "./chunk-H2WRMLYY.js";
+
+// ../../packages/entities/dist/agent/embed.js
+var embedStatuses = ["pending", "success", "failed"];
+
+// ../../packages/entities/dist/agent/docs.js
+var docsProjectTypes = ["sync", "wysiwyg", "docs"];
+var agentDocsProjectSchema = zod_default.object({
+  id: zod_default.string(),
+  uid: zod_default.string(),
+  name: zod_default.string(),
+  teamUid: zod_default.string(),
+  isPrivate: zod_default.boolean(),
+  type: zod_default.enum(docsProjectTypes),
+  activePublishId: zod_default.string().nullable(),
+  mcpServerId: zod_default.string().nullable(),
+  mcpInstallationId: zod_default.string().nullable(),
+  agentEnabled: zod_default.boolean(),
+  createdAt: zod_default.string(),
+  updatedAt: zod_default.string()
+}).meta({ id: "agent-docs-project" });
+var docsPublishSchema = zod_default.object({
+  id: zod_default.string(),
+  uid: zod_default.string(),
+  projectId: zod_default.string(),
+  domain: zod_default.string(),
+  embedStatus: zod_default.enum(embedStatuses),
+  createdAt: zod_default.string(),
+  updatedAt: zod_default.string()
+}).meta({ id: "docs-publish" });
+var docsPageSchema = zod_default.object({
+  id: zod_default.string(),
+  publishId: zod_default.string(),
+  title: zod_default.string(),
+  description: zod_default.string().nullable(),
+  to: zod_default.string(),
+  filepath: zod_default.string(),
+  contentHash: zod_default.string().nullable(),
+  searchToolEnabled: zod_default.boolean(),
+  executeRequestToolEnabled: zod_default.boolean(),
+  createdAt: zod_default.string()
+}).meta({ id: "docs-page" });
+var docsPageEmbeddingSchema = zod_default.object({
+  id: zod_default.string(),
+  pageId: zod_default.string(),
+  raw: zod_default.instanceof(Uint8Array),
+  embedding: zod_default.number().array(),
+  metadata: zod_default.record(zod_default.string(), zod_default.unknown()).nullable(),
+  createdAt: zod_default.string()
+}).meta({ id: "docs-embedding" });
+
+// ../../packages/entities/dist/agent/key.js
+var agentKeySchema = zod_default.object({
+  id: zod_default.string(),
+  teamUid: zod_default.string(),
+  name: zod_default.string().max(50).default("My Agent Key"),
+  description: zod_default.string().max(200).default(""),
+  revoked: zod_default.boolean(),
+  expiresAt: zod_default.string(),
+  createdAt: zod_default.string(),
+  updatedAt: zod_default.string()
+}).meta({ id: "agent-key" });
+var agentTokenPayloadSchema = zod_default.object({
+  uid: zod_default.string(),
+  teamUid: nanoidSchema.optional(),
+  documentUids: nanoidSchema.array().optional(),
+  /** Ephemeral key minted for a registry API reference preview page. */
+  registryPreview: zod_default.boolean().optional(),
+  exp: zod_default.number().int()
+}).meta({ id: "agent-token-payload" });
+var SCALAR_AGENT_KEY_HEADER = "x-scalar-agent-key";
+
+// ../../packages/entities/dist/agent/mcp.js
+var mcpServerVersionChangeSources = [
+  "created",
+  "migration",
+  "user",
+  "docs-publish",
+  "track-latest",
+  "track-current",
+  "linked-resource-change"
+];
+var mcpServerVersionStatuses = ["draft", "approved"];
+var mcpDocumentTrackModes = [
+  "pinned",
+  "track-latest",
+  "track-current"
+];
+var mcpDocsProjectTrackModes = [
+  "pinned",
+  "track-active-publish"
+];
+var mcpServerToolModes = ["generic", "curated", "both"];
+var mcpServerSchema = external_exports.object({
+  id: external_exports.string(),
+  teamUid: external_exports.string(),
+  name: external_exports.string(),
+  slug: slugSchema,
+  createdAt: external_exports.string(),
+  updatedAt: external_exports.string()
+}).meta({ id: "mcp-server" });
+var mcpServerVersionSchema = external_exports.object({
+  id: external_exports.string(),
+  mcpServerId: external_exports.string(),
+  semver: external_exports.string(),
+  parentVersionId: external_exports.string().nullable(),
+  changeSource: external_exports.enum(mcpServerVersionChangeSources),
+  changeNote: external_exports.string().nullable(),
+  newToolsSuggestionDismissed: external_exports.boolean(),
+  createdByUserId: external_exports.string().nullable(),
+  status: external_exports.enum(mcpServerVersionStatuses),
+  // Nullish input, null output: a dashboard bundle must keep parsing
+  // agent responses that predate these columns, whichever side deploys
+  // first — a missing key parses to null instead of failing.
+  approvalRequestedByUserId: external_exports.string().nullish().default(null),
+  approvalRequestedAt: external_exports.string().nullish().default(null),
+  approvedByUserId: external_exports.string().nullable(),
+  approvedAt: external_exports.string().nullable(),
+  createdAt: external_exports.string()
+}).meta({ id: "mcp-server-version" });
+var mcpServerOperationToolSchema = external_exports.object({
+  id: external_exports.string(),
+  mcpServerId: external_exports.string(),
+  mcpServerVersionId: external_exports.string(),
+  operationId: external_exports.string(),
+  searchToolEnabled: external_exports.boolean(),
+  executeRequestToolEnabled: external_exports.boolean(),
+  curatedToolEnabled: external_exports.boolean(),
+  name: external_exports.string().nullable(),
+  description: external_exports.string().nullable(),
+  createdAt: external_exports.string(),
+  updatedAt: external_exports.string()
+}).meta({
+  id: "mcp-server-operation-tool"
+});
+var mcpServerDocsPageToolSchema = external_exports.object({
+  id: external_exports.string(),
+  mcpServerId: external_exports.string(),
+  mcpServerVersionId: external_exports.string(),
+  docsPageId: external_exports.string(),
+  searchToolEnabled: external_exports.boolean(),
+  executeRequestToolEnabled: external_exports.boolean(),
+  createdAt: external_exports.string(),
+  updatedAt: external_exports.string()
+}).meta({
+  id: "mcp-server-docs-page-tool"
+});
+var mcpServerDocumentVersionSchema = external_exports.object({
+  id: external_exports.string(),
+  mcpServerId: external_exports.string(),
+  mcpServerVersionId: external_exports.string(),
+  versionId: external_exports.string(),
+  trackMode: external_exports.enum(mcpDocumentTrackModes),
+  toolMode: external_exports.enum(mcpServerToolModes),
+  createdAt: external_exports.string()
+}).meta({
+  id: "mcp-server-document-version"
+});
+var mcpServerDocsPublishSchema = external_exports.object({
+  id: external_exports.string(),
+  mcpServerId: external_exports.string(),
+  mcpServerVersionId: external_exports.string(),
+  docsPublishId: external_exports.string(),
+  trackMode: external_exports.enum(mcpDocsProjectTrackModes),
+  createdAt: external_exports.string()
+}).meta({
+  id: "mcp-server-docs-publish"
+});
+var mcpAuthModes = ["global", "passthrough"];
+var PASSTHROUGH_NAME_REGEX = /^[A-Za-z0-9!#$%&'*+\-.^_`|~]+$/;
+var PASSTHROUGH_MAX_ENTRIES = 20;
+var PASSTHROUGH_NAME_MAX_LENGTH = 128;
+var PASSTHROUGH_HEADER_DENYLIST = [
+  "host",
+  "content-length",
+  "content-type",
+  "accept",
+  "accept-encoding",
+  "expect",
+  "connection",
+  "transfer-encoding",
+  "te",
+  "upgrade",
+  "trailer",
+  "keep-alive",
+  "proxy-authorization",
+  "proxy-authenticate",
+  "proxy-connection",
+  "mcp-session-id",
+  "mcp-protocol-version",
+  "x-scalar-agent-key",
+  "x-scalar-docs-agent-token",
+  "x-scalar-sdk-provider",
+  "forwarded",
+  "x-forwarded-for",
+  "x-forwarded-host",
+  "x-forwarded-proto"
+];
+var passthroughAuthEntrySchema = external_exports.object({
+  in: external_exports.enum(["header", "query"]),
+  name: external_exports.string().min(1, "Name is required").max(PASSTHROUGH_NAME_MAX_LENGTH, "Name is too long").regex(PASSTHROUGH_NAME_REGEX, "Invalid character in name")
+});
+var passthroughAuthListSchema = external_exports.array(passthroughAuthEntrySchema).max(PASSTHROUGH_MAX_ENTRIES).superRefine((entries, ctx) => {
+  const seen = /* @__PURE__ */ new Set();
+  entries.forEach((entry, index) => {
+    const key = `${entry.in}:${entry.name.toLowerCase()}`;
+    if (seen.has(key))
+      ctx.addIssue({
+        code: "custom",
+        message: `"${entry.name}" is already in the list`,
+        path: [index, "name"]
+      });
+    seen.add(key);
+    if (entry.in === "header" && PASSTHROUGH_HEADER_DENYLIST.includes(entry.name.toLowerCase()))
+      ctx.addIssue({
+        code: "custom",
+        message: `The ${entry.name} header cannot be forwarded`,
+        path: [index, "name"]
+      });
+  });
+});
+var mcpVersionAuthSchema = external_exports.object({
+  mode: external_exports.enum(mcpAuthModes).default("global"),
+  passthrough: passthroughAuthListSchema.default([])
+});
+var mcpAuthConfigSchema = external_exports.record(external_exports.string(), mcpVersionAuthSchema);
+var mcpInstallationSchema = external_exports.object({
+  id: external_exports.string(),
+  mcpServerId: external_exports.string(),
+  name: external_exports.string(),
+  slug: slugSchema,
+  documentAuth: external_exports.record(external_exports.string(), external_exports.unknown()),
+  isPrivate: external_exports.boolean(),
+  accessGroups: external_exports.array(external_exports.string()).default([]),
+  loginPortalUid: external_exports.string().nullable().default(null),
+  authConfig: mcpAuthConfigSchema.default({}),
+  mcpVersion: external_exports.string().nullable().default(null)
+}).meta({ id: "mcp-installation" });
+
+// ../../packages/entities/dist/agent/monthly-usage.js
+var monthlyUsageSchema = zod_default.object({
+  identifier: zod_default.string(),
+  month: zod_default.date(),
+  type: zod_default.enum([
+    "public-user",
+    "web-team-user",
+    "agent-key",
+    "docs-project",
+    "mcp-installation",
+    "registry-preview"
+  ]),
+  teamUid: zod_default.string().nullable(),
+  inputTokens: zod_default.number(),
+  outputTokens: zod_default.number(),
+  messages: zod_default.number(),
+  toolCalls: zod_default.number(),
+  // bigint column: the pg driver returns int8 as a string, so coerce on read.
+  microCredits: zod_default.coerce.number()
+}).meta({ id: "monthly-usage" });
+
+// ../../node_modules/.pnpm/@scalar+helpers@0.9.2/node_modules/@scalar/helpers/dist/http/http-methods.js
+var HTTP_METHODS = ["delete", "get", "head", "options", "patch", "post", "put", "trace"];
+var httpMethods = Object.freeze(new Set(HTTP_METHODS));
+
+// ../../packages/entities/dist/agent/operation.js
+var methodSchema = zod_default.enum(HTTP_METHODS).meta({ id: "method" });
+var operationSchema = zod_default.object({
+  id: zod_default.uuid(),
+  path: zod_default.string(),
+  method: methodSchema,
+  versionId: zod_default.uuid(),
+  embedding: zod_default.number().array(),
+  searchToolEnabled: zod_default.boolean(),
+  executeRequestToolEnabled: zod_default.boolean(),
+  operationId: zod_default.string().nullable(),
+  summary: zod_default.string().nullable(),
+  description: zod_default.string().nullable()
+}).meta({ id: "operation" });
+
+// ../../packages/entities/dist/agent/document.js
+var documentSchema = zod_default.object({
+  id: zod_default.uuid(),
+  uid: nanoidSchema,
+  slug: slugSchema,
+  teamUid: nanoidSchema.nullable(),
+  namespace: namespaceSchema,
+  isPrivate: zod_default.boolean(),
+  title: zod_default.string(),
+  description: zod_default.string(),
+  logoUrl: zod_default.url().nullable(),
+  searchEnabled: zod_default.boolean(),
+  currentVersion: docVersionSchema,
+  latestVersion: docVersionSchema,
+  curated: zod_default.boolean(),
+  createdAt: zod_default.date(),
+  updatedAt: zod_default.date()
+}).meta({ id: "document" });
+
+// ../../packages/entities/dist/agent/key-documents.js
+var keyDocumentSchema = zod_default.object({
+  keyId: zod_default.uuid(),
+  documentId: zod_default.uuid()
+}).meta({ id: "key-documents" });
+
+// ../../packages/entities/dist/agent/version.js
+var versionSchema = zod_default.object({
+  id: zod_default.uuid(),
+  uid: nanoidSchema,
+  semver: docVersionSchema,
+  documentId: zod_default.uuid(),
+  raw: zod_default.instanceof(Uint8Array),
+  embedStatus: zod_default.enum(embedStatuses),
+  createdAt: zod_default.date(),
+  updatedAt: zod_default.date()
+}).meta({ id: "version" });
+
+export {
+  embedStatuses,
+  docsProjectTypes,
+  agentDocsProjectSchema,
+  agentKeySchema,
+  SCALAR_AGENT_KEY_HEADER,
+  mcpDocumentTrackModes,
+  mcpDocsProjectTrackModes,
+  mcpServerToolModes,
+  mcpServerSchema,
+  mcpServerVersionSchema,
+  mcpServerOperationToolSchema,
+  mcpServerDocsPageToolSchema,
+  mcpAuthConfigSchema,
+  mcpInstallationSchema,
+  monthlyUsageSchema,
+  methodSchema
+};

package/chunks/chunk-TQ5XC2E3.js

@@ -0,0 +1,284 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  ISOLATE_DIR,
+  ISOLATE_EXTRACTION_DIR
+} from "./chunk-KWOL7A6J.js";
+import {
+  config
+} from "./chunk-OAXFCOJV.js";
+import {
+  output
+} from "./chunk-X4QLDBB5.js";
+
+// src/domains/project/download-isolate/action.ts
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { promisify } from "node:util";
+import zlib from "node:zlib";
+import { nanoid } from "nanoid";
+import tar from "tar-fs";
+
+// src/domains/project/download-isolate/helpers.ts
+var PLATFORM_TARBALL_TARGETS = /* @__PURE__ */ new Set([
+  "darwin-arm64",
+  "darwin-x64",
+  "linux-arm64",
+  "linux-x64",
+  "win32-arm64",
+  "win32-x64"
+]);
+function getIsolateDownloadUrls(options) {
+  const baseUrl = `${options.cdnUrl}/isolates/${options.version}-isolate`;
+  const universalUrl = `${baseUrl}.tar.gz`;
+  const target = `${options.platform}-${options.arch}`;
+  if (!PLATFORM_TARBALL_TARGETS.has(target)) return [universalUrl];
+  return [`${baseUrl}-${target}.tar.gz`, universalUrl];
+}
+
+// src/domains/project/download-isolate/action.ts
+var execFileAsync = promisify(execFile);
+var DOWNLOAD_TIMEOUT_MS = 10 * 60 * 1e3;
+var EXTRACTION_ALLOWANCE_MS = 5 * 60 * 1e3;
+async function getExistingIsolateVersion() {
+  try {
+    const packageJsonString = await fs.readFile(
+      path.join(ISOLATE_DIR, "package.json"),
+      "utf8"
+    );
+    const packageJson = JSON.parse(packageJsonString);
+    return packageJson.version;
+  } catch {
+    return void 0;
+  }
+}
+async function downloadWindowsIsolate(isolateUrl, destinationDir, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const timeoutSeconds = Math.ceil(timeoutMs / 1e3);
+    const psScript = `
+$ErrorActionPreference = "Stop"
+
+$targetDir = "${destinationDir}"
+$tempFile = Join-Path $env:TEMP "scalar-isolate-download.tar.gz"
+
+# Ensure target directory exists
+New-Item -ItemType Directory -Force -Path $targetDir | Out-Null
+
+# Download tarball. -TimeoutSec bounds the request so a stalled connection
+# aborts instead of hanging indefinitely.
+$ProgressPreference = 'SilentlyContinue'
+Invoke-WebRequest -Uri "${isolateUrl}" -OutFile $tempFile -TimeoutSec ${timeoutSeconds}
+
+# Extract (uses built-in tar on Windows)
+tar -xzf $tempFile -C $targetDir
+
+# Cleanup
+Remove-Item $tempFile
+`;
+    execFile(
+      "powershell.exe",
+      [
+        "-NoProfile",
+        "-NonInteractive",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-Command",
+        psScript
+      ],
+      // Hard backstop: kill PowerShell if the whole run (download + extraction)
+      // overruns. `-TimeoutSec` only bounds the download, so the process budget
+      // adds an extraction allowance on top — a download that finishes near its
+      // own limit still has time to unpack, mirroring the unbounded extraction
+      // on Unix where the fetch timeout does not cover `tar`.
+      { windowsHide: true, timeout: timeoutMs + EXTRACTION_ALLOWANCE_MS },
+      (error, stdout, stderr) => {
+        if (error) {
+          error.stderr = stderr;
+          return reject(error);
+        }
+        resolve(stdout);
+      }
+    );
+  });
+}
+async function downloadAndExtract(url, destinationDir, options) {
+  if (process.platform === "win32") {
+    await downloadWindowsIsolate(url, destinationDir, options.timeoutMs);
+    return;
+  }
+  const response = await options.fetchImpl(url, {
+    signal: AbortSignal.timeout(options.timeoutMs)
+  });
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status} ${response.statusText}`.trim());
+  }
+  if (!response.body) {
+    throw new Error("Response had no body");
+  }
+  await pipeline(
+    Readable.fromWeb(response.body),
+    zlib.createGunzip(),
+    tar.extract(destinationDir)
+  );
+}
+async function assertIsolateLayout(destinationDir, url) {
+  try {
+    await fs.access(path.join(destinationDir, "isolate", "package.json"));
+  } catch {
+    throw new Error(
+      `The isolate tarball downloaded from ${url} did not contain an isolate directory.`
+    );
+  }
+}
+async function downloadFirstAvailable(urls, destinationDir, options) {
+  const failures = [];
+  for (const url of urls) {
+    try {
+      await fs.rm(destinationDir, { recursive: true, force: true });
+      await downloadAndExtract(url, destinationDir, options);
+      await assertIsolateLayout(destinationDir, url);
+      return url;
+    } catch (error) {
+      failures.push(
+        `  - ${url}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  throw new Error(
+    `Failed to download the docs isolate. Attempted:
+${failures.join("\n")}
+Your existing isolate (if any) was left untouched. Check your network connection and try again.`
+  );
+}
+async function removeQuarantineAttributes(isolateDir) {
+  if (process.platform !== "darwin") return;
+  try {
+    await execFileAsync("xattr", ["-dr", "com.apple.quarantine", isolateDir]);
+  } catch {
+  }
+}
+async function swapIsolateDirectory(newIsolateDir, isolateDir) {
+  const backupDir = `${isolateDir}.old-${nanoid()}`;
+  let hasBackup = false;
+  try {
+    await fs.rename(isolateDir, backupDir);
+    hasBackup = true;
+  } catch (error) {
+    const isMissing = error instanceof Error && error.code === "ENOENT";
+    if (!isMissing) throw error;
+  }
+  try {
+    await fs.rename(newIsolateDir, isolateDir);
+  } catch (error) {
+    if (hasBackup) {
+      try {
+        await fs.rename(backupDir, isolateDir);
+      } catch {
+        throw new Error(
+          `Failed to install the new isolate and could not restore the previous one. Your previous isolate is preserved at ${backupDir} \u2014 rename it back to ${isolateDir} to recover.`,
+          { cause: error }
+        );
+      }
+    }
+    throw error;
+  }
+  if (hasBackup) {
+    await fs.rm(backupDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function removeDirectoriesWithPrefixes(extractionDir, prefixes, minAgeMs = 0) {
+  try {
+    const entries = await fs.readdir(extractionDir);
+    const now = Date.now();
+    const matches = entries.filter(
+      (entry) => prefixes.some((prefix) => entry.startsWith(prefix))
+    );
+    await Promise.all(
+      matches.map(async (entry) => {
+        const entryPath = path.join(extractionDir, entry);
+        if (minAgeMs > 0) {
+          try {
+            const { mtimeMs } = await fs.stat(entryPath);
+            if (now - mtimeMs < minAgeMs) return;
+          } catch {
+            return;
+          }
+        }
+        await fs.rm(entryPath, { recursive: true, force: true });
+      })
+    );
+  } catch {
+  }
+}
+var STALE_WORKING_DIR_AGE_MS = 10 * 60 * 1e3;
+async function cleanupStaleWorkingDirectories(extractionDir) {
+  const prefixes = ["isolate.tmp-"];
+  try {
+    const hasLiveIsolate = (await fs.readdir(extractionDir)).includes("isolate");
+    if (hasLiveIsolate) prefixes.push("isolate.old-");
+  } catch {
+  }
+  await removeDirectoriesWithPrefixes(
+    extractionDir,
+    prefixes,
+    STALE_WORKING_DIR_AGE_MS
+  );
+}
+async function updateIsolate(options) {
+  const {
+    urls,
+    extractionDir,
+    fetchImpl = fetch,
+    timeoutMs = DOWNLOAD_TIMEOUT_MS
+  } = options;
+  const isolateDir = path.join(extractionDir, "isolate");
+  await fs.mkdir(extractionDir, { recursive: true });
+  await cleanupStaleWorkingDirectories(extractionDir);
+  const temporaryDir = path.join(extractionDir, `isolate.tmp-${nanoid()}`);
+  try {
+    const usedUrl = await downloadFirstAvailable(urls, temporaryDir, {
+      fetchImpl,
+      timeoutMs
+    });
+    const downloadedIsolateDir = path.join(temporaryDir, "isolate");
+    await removeQuarantineAttributes(downloadedIsolateDir);
+    await swapIsolateDirectory(downloadedIsolateDir, isolateDir);
+    await removeDirectoriesWithPrefixes(
+      extractionDir,
+      ["isolate.old-"],
+      STALE_WORKING_DIR_AGE_MS
+    );
+    return usedUrl;
+  } finally {
+    await fs.rm(temporaryDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function downloadIsolate() {
+  const existingIsolateVersion = await getExistingIsolateVersion();
+  if (config.ssgDocsIsolateVersion === existingIsolateVersion) return;
+  const logger = output.info({ animate: true }).loader("Downloading docs isolate. This may take a minute...");
+  const urls = getIsolateDownloadUrls({
+    cdnUrl: config.cdnUrl,
+    version: config.ssgDocsIsolateVersion,
+    platform: process.platform,
+    arch: process.arch
+  });
+  try {
+    await updateIsolate({ urls, extractionDir: ISOLATE_EXTRACTION_DIR });
+  } catch (error) {
+    logger.update("loader", 0, { content: "Download failed." });
+    logger.finish();
+    throw error;
+  }
+  logger.update("loader", 0, { content: "Download complete." });
+  logger.finish();
+}
+
+export {
+  updateIsolate,
+  downloadIsolate
+};