@scalar/cli 2.0.1 → 2.5.1

package/chunks/chunk-KHDYYVYF.js

@@ -0,0 +1,16 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+
+// src/helpers/time.ts
+async function measureTime(fn) {
+  const start = performance.now();
+  const result = await fn();
+  const end = performance.now();
+  return {
+    result,
+    executionTimeMs: end - start
+  };
+}
+
+export {
+  measureTime
+};

package/chunks/chunk-LFU5ZUAP.js

@@ -0,0 +1,350 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  displayError
+} from "./chunk-3ZJYGGAA.js";
+import {
+  ISOLATE_DIR,
+  ISOLATE_EXTRACTION_DIR
+} from "./chunk-X5T526CE.js";
+import {
+  config
+} from "./chunk-4ZDQXWBT.js";
+import {
+  output
+} from "./chunk-T5HJUAWB.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 IsolateDownloadError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "IsolateDownloadError";
+  }
+};
+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 download from ${url} did not contain a valid docs preview server.`
+    );
+  }
+}
+var DISK_WRITE_ERROR_CODES = /* @__PURE__ */ new Set([
+  "ENOSPC",
+  // No space left on device
+  "EACCES",
+  // Permission denied
+  "EPERM",
+  // Operation not permitted
+  "EBUSY",
+  // Resource busy or locked
+  "EROFS",
+  // Read-only filesystem
+  "EDQUOT",
+  // Disk quota exceeded
+  "EMFILE",
+  // Too many open files
+  "ENFILE"
+  // File table overflow
+]);
+var DISK_WRITE_ERROR_MESSAGES = [
+  "no space left on device",
+  // ENOSPC / bsdtar
+  "not enough space",
+  // Windows disk-full phrasing
+  "disk quota exceeded",
+  // EDQUOT
+  "permission denied",
+  // EACCES
+  "access is denied",
+  // Windows permission phrasing
+  "operation not permitted",
+  // EPERM
+  "read-only file system"
+  // EROFS
+];
+function isDiskWriteError(error) {
+  if (!(error instanceof Error)) return false;
+  const code = error.code;
+  if (typeof code === "string" && DISK_WRITE_ERROR_CODES.has(code)) {
+    return true;
+  }
+  const details = `${error.message} ${error.stderr ?? ""}`.toLowerCase();
+  return DISK_WRITE_ERROR_MESSAGES.some((phrase) => details.includes(phrase));
+}
+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) {
+      if (isDiskWriteError(error)) throw error;
+      failures.push(
+        `  - ${url}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  throw new IsolateDownloadError(
+    `Failed to download the docs preview server. Attempted:
+${failures.join("\n")}
+Your existing preview server (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 docs preview server and could not restore the previous one. Your previous preview server 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 the docs preview server. 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) {
+    const isDownloadFailure = error instanceof IsolateDownloadError;
+    logger.update("loader", 0, {
+      content: isDownloadFailure ? "Download failed." : "Installation failed.",
+      status: "error"
+    });
+    logger.finish();
+    return output.error().title(
+      isDownloadFailure ? "Could not download the docs preview server" : "Could not install the docs preview server"
+    ).message(
+      [
+        displayError(error),
+        error instanceof Error && error.cause ? displayError(error.cause) : ""
+      ].filter(Boolean).join("\n\n")
+    ).exit("error");
+  }
+  logger.update("loader", 0, { content: "Download complete." });
+  logger.finish();
+}
+
+export {
+  IsolateDownloadError,
+  isDiskWriteError,
+  updateIsolate,
+  downloadIsolate
+};