@thinkingai/ae-cli 6.1.8 → 6.1.9

package/dist/{chunk-JTKMDN4A.js → chunk-KTYR3U6D.js}

@@ -14,6 +14,11 @@ import {
   logger
 } from "./chunk-LYVNONC4.js";
 
+// src/core/version-sync.ts
+import { spawnSync } from "child_process";
+import fs from "fs";
+import path from "path";
+
 // src/core/update-check.ts
 function shouldSkipUpdateCheck(argv = process.argv) {
   if (process.env.AE_CLI_NO_UPDATE_CHECK === "1") return true;
@@ -233,20 +238,352 @@ function formatCompatNotice(verdict) {
   ].join("\n");
 }
 
+// src/core/version-sync.ts
+var COMMAND_TIMEOUT_MS = 12e4;
+var AUTO_ATTEMPT_INTERVAL_MS = 60 * 60 * 1e3;
+var MAX_AUTO_ATTEMPTS_PER_DAY = 3;
+var LOCK_STALE_MS = 10 * 60 * 1e3;
+var SYNC_STATE_FILE = "version-sync.json";
+var SYNC_LOCK_FILE = "version-sync.lock";
+function syncStatePath() {
+  return path.join(getConfigDir(), SYNC_STATE_FILE);
+}
+function syncLockPath() {
+  return path.join(getConfigDir(), SYNC_LOCK_FILE);
+}
+function readSyncStore() {
+  try {
+    const raw = JSON.parse(fs.readFileSync(syncStatePath(), "utf8"));
+    if (raw && typeof raw === "object" && raw.hosts && typeof raw.hosts === "object") {
+      return raw;
+    }
+  } catch {
+  }
+  return { hosts: {} };
+}
+function writeSyncStore(store) {
+  try {
+    fs.mkdirSync(getConfigDir(), { recursive: true });
+    fs.writeFileSync(syncStatePath(), JSON.stringify(store, null, 2));
+  } catch {
+  }
+}
+function localDay(now) {
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function freshAttemptEntry(target, now) {
+  return {
+    target,
+    attemptDay: localDay(now),
+    attemptsToday: 0
+  };
+}
+function evaluateAutoAttempt(existing, target, now = /* @__PURE__ */ new Date()) {
+  const today = localDay(now);
+  const entry = !existing || existing.target !== target || existing.attemptDay !== today ? freshAttemptEntry(target, now) : { ...existing };
+  if (entry.attemptsToday >= MAX_AUTO_ATTEMPTS_PER_DAY) {
+    return { allowed: false, reason: "daily_limit", entry };
+  }
+  if (entry.lastAttemptAt) {
+    const elapsed = now.getTime() - new Date(entry.lastAttemptAt).getTime();
+    if (Number.isFinite(elapsed) && elapsed < AUTO_ATTEMPT_INTERVAL_MS) {
+      return { allowed: false, reason: "hourly_limit", entry };
+    }
+  }
+  return { allowed: true, entry };
+}
+function reserveAutoAttempt(host, target, now = /* @__PURE__ */ new Date()) {
+  const store = readSyncStore();
+  const key = normalizeUrl(host);
+  const decision = evaluateAutoAttempt(store.hosts[key], target, now);
+  if (!decision.allowed) return decision;
+  decision.entry.attemptsToday += 1;
+  decision.entry.lastAttemptAt = now.toISOString();
+  store.hosts[key] = decision.entry;
+  writeSyncStore(store);
+  return decision;
+}
+function getPendingSkillsTarget(host) {
+  const entry = readSyncStore().hosts[normalizeUrl(host)];
+  return entry?.pendingSkills ? entry.target : void 0;
+}
+function recordVersionSyncResult(host, target, result) {
+  const store = readSyncStore();
+  const key = normalizeUrl(host);
+  const existing = store.hosts[key] ?? freshAttemptEntry(target, /* @__PURE__ */ new Date());
+  const entry = existing.target === target ? existing : freshAttemptEntry(target, /* @__PURE__ */ new Date());
+  if (result.ok) {
+    entry.pendingSkills = false;
+    delete entry.lastFailureStage;
+  } else {
+    entry.pendingSkills = result.skillsPending;
+    entry.lastFailureStage = result.stage;
+  }
+  store.hosts[key] = entry;
+  writeSyncStore(store);
+}
+function isAutoSyncTargetEligible(version) {
+  const normalized = normalizeCliVersion(version);
+  const parts = normalized.split("-")[0].split(".").map((part) => Number.parseInt(part, 10));
+  if (parts.length < 3 || parts.some((part) => !Number.isFinite(part))) return false;
+  const [major, minor, patch] = parts;
+  if (major > 6) return true;
+  if (major !== 6) return false;
+  if (minor > 1) return true;
+  if (minor === 1) return patch >= 5;
+  if (minor === 0) return patch >= 33;
+  return false;
+}
+function isPublicAeCliPackage(packageName) {
+  return packageName === OPEN_SOURCE_AE_CLI_PACKAGE;
+}
+function resolveNodeTool(tool, execPath = process.execPath, platform = process.platform) {
+  const fileName = platform === "win32" ? `${tool}.cmd` : tool;
+  const sibling = path.join(path.dirname(execPath), fileName);
+  return fs.existsSync(sibling) ? sibling : fileName;
+}
+function buildVersionInstallPlan(targetRaw, globalRoot = "<npm-root>") {
+  const target = normalizeCliVersion(targetRaw);
+  const localSkills = path.join(globalRoot, "@thinkingai", "ae-cli", "skills");
+  return {
+    target,
+    commands: [
+      `npm install -g ${OPEN_SOURCE_AE_CLI_PACKAGE}@${target}`,
+      `npx -y skills add ${localSkills} -g -y`,
+      `npx -y skills add ${AE_CLI_SKILLS_REPO}#v${target} -g -y`
+    ],
+    skillsSources: ["installed-package", "github-fallback"]
+  };
+}
+function defaultRunner(command, args, timeoutMs) {
+  const result = spawnSync(command, args, {
+    encoding: "utf8",
+    maxBuffer: 2 * 1024 * 1024,
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: timeoutMs,
+    windowsHide: true
+  });
+  return {
+    status: result.status,
+    stdout: result.stdout || "",
+    stderr: result.stderr || "",
+    error: result.error,
+    signal: result.signal
+  };
+}
+function resultMessage(result) {
+  if (result.error?.message) return result.error.message;
+  const detail = (result.stderr || result.stdout).trim().split(/\r?\n/).filter(Boolean).slice(-3).join(" ");
+  if (detail) return detail;
+  if (result.signal) return `Command terminated by ${result.signal}`;
+  return `Command exited with status ${result.status ?? "unknown"}`;
+}
+function classifyFailure(result) {
+  const text = `${result.error?.message || ""}
+${result.stderr}
+${result.stdout}`;
+  if (result.error && result.error.code === "ETIMEDOUT") return "timeout";
+  if (/timed?\s*out|ETIMEDOUT/i.test(text)) return "timeout";
+  if (/EACCES|EPERM|permission denied|access is denied/i.test(text)) return "permission";
+  if (/EAI_AGAIN|ENOTFOUND|ECONNRESET|ECONNREFUSED|network|unable to access|could not resolve|certificate|SSL/i.test(text)) {
+    return "network";
+  }
+  if (/E404|404 Not Found|no matching version|couldn't find remote ref|not found/i.test(text)) {
+    return "package_missing";
+  }
+  return "unknown";
+}
+function friendlyVersionSyncFailure(result) {
+  if (result.cause === "busy") {
+    return "Another ae-cli process is synchronizing the global installation.";
+  }
+  if (result.cause === "permission") {
+    return "The global npm installation directory is not writable.";
+  }
+  if (result.cause === "timeout") {
+    return "The npm or Skills download timed out.";
+  }
+  if (result.cause === "network") {
+    return "The npm registry or Skills source could not be reached.";
+  }
+  if (result.cause === "package_missing") {
+    return "The required CLI package or Skills tag is not available.";
+  }
+  if (result.cause === "validation") {
+    return "The installed package could not be validated.";
+  }
+  return `Version synchronization failed at ${result.stage}.`;
+}
+function commandSucceeded(result) {
+  return !result.error && result.status === 0;
+}
+function acquireInstallLock(now) {
+  fs.mkdirSync(getConfigDir(), { recursive: true });
+  const file = syncLockPath();
+  try {
+    return fs.openSync(file, "wx");
+  } catch {
+    try {
+      const age = now.getTime() - fs.statSync(file).mtimeMs;
+      if (age >= LOCK_STALE_MS) {
+        fs.unlinkSync(file);
+        return fs.openSync(file, "wx");
+      }
+    } catch {
+      try {
+        return fs.openSync(file, "wx");
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+}
+function releaseInstallLock(fd) {
+  try {
+    fs.closeSync(fd);
+  } catch {
+  }
+  try {
+    fs.unlinkSync(syncLockPath());
+  } catch {
+  }
+}
+function validateInstalledPackage(npm, target, runner) {
+  const rootResult = runner(npm, ["root", "-g"], COMMAND_TIMEOUT_MS);
+  if (!commandSucceeded(rootResult)) {
+    return { ok: false, message: resultMessage(rootResult) };
+  }
+  const globalRoot = rootResult.stdout.trim();
+  const packageRoot = path.join(globalRoot, "@thinkingai", "ae-cli");
+  const packageJson = path.join(packageRoot, "package.json");
+  const skillsPath = path.join(packageRoot, "skills");
+  try {
+    const installed = JSON.parse(fs.readFileSync(packageJson, "utf8"));
+    if (normalizeCliVersion(installed.version || "") !== target) {
+      return {
+        ok: false,
+        message: `Installed package version ${installed.version || "unknown"} does not match ${target}`
+      };
+    }
+    if (!fs.statSync(skillsPath).isDirectory()) {
+      return { ok: false, message: `Installed package has no skills directory: ${skillsPath}` };
+    }
+    return { ok: true, skillsPath };
+  } catch (error) {
+    return { ok: false, message: error?.message || String(error) };
+  }
+}
+function installVersion(targetRaw, options = {}) {
+  const target = normalizeCliVersion(targetRaw);
+  const runner = options.runner ?? defaultRunner;
+  const progress = options.progress ?? (() => {
+  });
+  const npm = resolveNodeTool("npm");
+  const npx = resolveNodeTool("npx");
+  const lock = acquireInstallLock(options.now ?? /* @__PURE__ */ new Date());
+  if (lock === null) {
+    return {
+      ok: false,
+      stage: "lock",
+      cliInstalled: false,
+      skillsPending: Boolean(options.skipCliInstall),
+      cause: "busy",
+      message: "Another ae-cli process is already synchronizing the global installation."
+    };
+  }
+  let cliInstalled = Boolean(options.skipCliInstall);
+  try {
+    if (!options.skipCliInstall) {
+      progress(`[ae-cli] [1/2] Installing ae-cli ${target}...`);
+      const npmResult = runner(
+        npm,
+        ["install", "-g", `${OPEN_SOURCE_AE_CLI_PACKAGE}@${target}`],
+        COMMAND_TIMEOUT_MS
+      );
+      if (!commandSucceeded(npmResult)) {
+        return {
+          ok: false,
+          stage: "npm_install",
+          cliInstalled: false,
+          skillsPending: false,
+          cause: classifyFailure(npmResult),
+          message: resultMessage(npmResult)
+        };
+      }
+      cliInstalled = true;
+    }
+    const installed = validateInstalledPackage(npm, target, runner);
+    if (!installed.ok) {
+      return {
+        ok: false,
+        stage: "package_validation",
+        cliInstalled,
+        skillsPending: cliInstalled,
+        cause: "validation",
+        message: installed.message
+      };
+    }
+    progress("[ae-cli] [2/2] Synchronizing Skills from the installed npm package...");
+    const localResult = runner(
+      npx,
+      ["-y", "skills", "add", installed.skillsPath, "-g", "-y"],
+      COMMAND_TIMEOUT_MS
+    );
+    if (commandSucceeded(localResult)) {
+      return { ok: true, cliInstalled, skillsSource: "local" };
+    }
+    progress("[ae-cli] Local Skills sync did not complete; trying the GitHub fallback...");
+    const githubResult = runner(
+      npx,
+      ["-y", "skills", "add", `${AE_CLI_SKILLS_REPO}#v${target}`, "-g", "-y"],
+      COMMAND_TIMEOUT_MS
+    );
+    if (commandSucceeded(githubResult)) {
+      return { ok: true, cliInstalled, skillsSource: "github" };
+    }
+    return {
+      ok: false,
+      stage: "skills_github",
+      cliInstalled,
+      skillsPending: cliInstalled,
+      cause: classifyFailure(githubResult),
+      message: resultMessage(githubResult) || resultMessage(localResult)
+    };
+  } finally {
+    releaseInstallLock(lock);
+  }
+}
+function autoSyncDirection(current, expected) {
+  if (versionLine(current) !== versionLine(expected)) return "switch";
+  const currentParts = normalizeCliVersion(current).split("-")[0].split(".").map(Number);
+  const expectedParts = normalizeCliVersion(expected).split("-")[0].split(".").map(Number);
+  for (let i = 0; i < Math.max(currentParts.length, expectedParts.length, 3); i += 1) {
+    const local = currentParts[i] ?? 0;
+    const target = expectedParts[i] ?? 0;
+    if (local < target) return "upgrade";
+    if (local > target) return "downgrade";
+  }
+  return "switch";
+}
+
 // src/core/compat-check.ts
-import fs from "fs";
-import path from "path";
+import fs2 from "fs";
+import path2 from "path";
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var FETCH_TIMEOUT_MS = 3e3;
 var CLI_CONFIG_PATH = "/v1/ta/cli/config";
 function cacheFilePath() {
-  return path.join(getConfigDir(), "compat-check.json");
+  return path2.join(getConfigDir(), "compat-check.json");
 }
 function readStore() {
   try {
     const file = cacheFilePath();
-    if (!fs.existsSync(file)) return { hosts: {} };
-    const raw = JSON.parse(fs.readFileSync(file, "utf8"));
+    if (!fs2.existsSync(file)) return { hosts: {} };
+    const raw = JSON.parse(fs2.readFileSync(file, "utf8"));
     if (!raw || typeof raw !== "object" || !raw.hosts) return { hosts: {} };
     return raw;
   } catch {
@@ -256,8 +593,8 @@ function readStore() {
 function writeStore(store) {
   try {
     const dir = getConfigDir();
-    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(cacheFilePath(), JSON.stringify(store, null, 2));
+    if (!fs2.existsSync(dir)) fs2.mkdirSync(dir, { recursive: true });
+    fs2.writeFileSync(cacheFilePath(), JSON.stringify(store, null, 2));
   } catch {
   }
 }
@@ -279,6 +616,25 @@ function shouldSkipCompatCheck(argv = process.argv) {
   if (isAeSandboxRuntime()) return true;
   return shouldSkipUpdateCheck(argv);
 }
+function rootCommand(argv) {
+  const args = argv.slice(2);
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i];
+    if (token === "--") return void 0;
+    if (token.startsWith("-")) {
+      if (!token.includes("=") && ["--host", "--mcp-url", "--format", "--jq"].includes(token)) {
+        i += 1;
+      }
+      continue;
+    }
+    return token;
+  }
+  return void 0;
+}
+function shouldSkipAutoSync(argv = process.argv) {
+  const command = rootCommand(argv);
+  return command === "update" || command === "auth" || command === "config";
+}
 async function fetchCliConfig(host, cliToken) {
   const url = new URL(CLI_CONFIG_PATH, host.endsWith("/") ? host : `${host}/`);
   url.searchParams.set("cli-token", cliToken);
@@ -352,9 +708,22 @@ function formatCapabilityMissCompatHint(host) {
   }
   return "This capability may be missing on the current private cluster. Update cluster components to the latest version, or pin this machine CLI + skills to the environment version (see ae-cli host compat notices after auth login).";
 }
-async function refreshAndMaybeNotify(host, pkg) {
+function setUpdateNotice(pkg, expected, cluster, verdict, state, stage, message) {
+  pendingHostCompatNotice = void 0;
+  pendingUpdateNotice = {
+    command: "ae-cli update",
+    current: pkg.version,
+    expected,
+    cluster,
+    reason: verdict.kind === "ok" && state === "skills_pending" ? "skills_pending" : verdict.kind,
+    state,
+    ...stage ? { stage } : {},
+    message: message ?? `Current ae-cli is ${pkg.version}; this host requires ${expected}. Run: ae-cli update`
+  };
+}
+async function refreshAndMaybeNotify(host, pkg, allowAutoSync) {
   const token = peekCliToken(host);
-  if (!token) return;
+  if (!token) return { status: "continue" };
   const store = readStore();
   const key = hostKey(host);
   const existing = store.hosts[key];
@@ -364,7 +733,7 @@ async function refreshAndMaybeNotify(host, pkg) {
   if (isStale(existing)) {
     const remote = await fetchCliConfig(host, token);
     if (!remote?.aeCliVersion) {
-      return;
+      return { status: "continue" };
     }
     expected = remote.aeCliVersion;
     cluster = remote.clusterVersion ?? "";
@@ -379,15 +748,15 @@ async function refreshAndMaybeNotify(host, pkg) {
     };
     writeStore(store);
   }
-  if (!expected) return;
-  const verdict = evaluateCompat(pkg.version, expected, cluster);
-  const notice = formatCompatNotice(verdict);
-  if (!notice) {
+  if (!expected) return { status: "continue" };
+  let verdict = evaluateCompat(pkg.version, expected, cluster);
+  let pendingSkills = getPendingSkillsTarget(host) === expected;
+  if (verdict.kind === "ok" && !pendingSkills) {
     pendingHostCompatNotice = void 0;
     pendingUpdateNotice = void 0;
-    return;
+    return { status: "continue" };
   }
-  const entry = store.hosts[key] ?? {
+  let entry = store.hosts[key] ?? {
     host: key,
     localVersion: pkg.version,
     expectedVersion: expected,
@@ -397,35 +766,104 @@ async function refreshAndMaybeNotify(host, pkg) {
   entry.localVersion = pkg.version;
   entry.expectedVersion = expected;
   entry.clusterVersion = cluster || entry.clusterVersion;
+  const canAutoSync = allowAutoSync && isPublicAeCliPackage(pkg.name) && isAutoSyncTargetEligible(expected);
+  if (canAutoSync) {
+    const confirmed = await fetchCliConfig(host, token);
+    if (confirmed?.aeCliVersion) {
+      expected = confirmed.aeCliVersion;
+      cluster = confirmed.clusterVersion ?? cluster ?? "";
+      verdict = evaluateCompat(pkg.version, expected, cluster);
+      pendingSkills = getPendingSkillsTarget(host) === expected;
+      entry = {
+        ...entry,
+        localVersion: pkg.version,
+        expectedVersion: expected,
+        clusterVersion: cluster || "",
+        lastFetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      store.hosts[key] = entry;
+      writeStore(store);
+      if (verdict.kind === "ok" && !pendingSkills) {
+        pendingHostCompatNotice = void 0;
+        pendingUpdateNotice = void 0;
+        return { status: "continue" };
+      }
+      if (isAutoSyncTargetEligible(expected)) {
+        const attempt = reserveAutoAttempt(host, expected);
+        if (attempt.allowed) {
+          const direction = verdict.kind === "ok" && pendingSkills ? "skills" : autoSyncDirection(pkg.version, expected);
+          const verb = direction === "upgrade" ? "upgrading" : direction === "downgrade" ? "downgrading" : direction === "skills" ? "repairing" : "switching";
+          printNotice(
+            `[ae-cli] Current version ${pkg.version}; this host requires ${expected}. Automatically ${verb} CLI and Skills, please wait...`
+          );
+          const result = installVersion(expected, {
+            skipCliInstall: verdict.kind === "ok" && pendingSkills,
+            progress: printNotice
+          });
+          recordVersionSyncResult(host, expected, result);
+          if (result.ok) {
+            printNotice(
+              `[ae-cli] Synchronized to ${expected}. Re-run the previous command to use the new version.`
+            );
+            pendingHostCompatNotice = void 0;
+            pendingUpdateNotice = void 0;
+            return {
+              status: "synced",
+              current: pkg.version,
+              expected,
+              cluster: cluster || "",
+              direction
+            };
+          }
+          const state = result.skillsPending ? "skills_pending" : "auto_sync_failed";
+          const friendlyCause = friendlyVersionSyncFailure(result);
+          const failure = result.skillsPending ? `CLI switched to ${expected}, but Skills synchronization failed. ${friendlyCause} This command will continue; run ae-cli update after access is restored.` : `${friendlyCause} This command will continue; run ae-cli update after fixing access.`;
+          printNotice(`[ae-cli] ${failure}`);
+          setUpdateNotice(pkg, expected, cluster || "", verdict, state, result.stage, failure);
+          entry.lastNotifiedAt = (/* @__PURE__ */ new Date()).toISOString();
+          store.hosts[key] = entry;
+          writeStore(store);
+          return { status: "continue" };
+        }
+      }
+    }
+  }
+  const notice = verdict.kind === "ok" && pendingSkills ? `[ae-cli] CLI ${expected} is installed, but its Skills are not synchronized.
+         Run: ae-cli update` : formatCompatNotice(verdict);
+  if (!notice) return { status: "continue" };
   const dueForTip = shouldNotify(entry);
   if (!dueForTip) {
     pendingHostCompatNotice = void 0;
     pendingUpdateNotice = void 0;
     store.hosts[key] = entry;
     writeStore(store);
-    return;
+    return { status: "continue" };
   }
-  pendingHostCompatNotice = notice;
-  pendingUpdateNotice = {
-    command: "ae-cli update",
-    current: pkg.version,
+  setUpdateNotice(
+    pkg,
     expected,
-    cluster: cluster || "",
-    reason: verdict.kind,
-    message: `Current ae-cli is ${pkg.version}; this host requires ${expected}. Run: ae-cli update`
-  };
+    cluster || "",
+    verdict,
+    pendingSkills ? "skills_pending" : "prompt_only",
+    void 0,
+    pendingSkills ? `Skills for ae-cli ${expected} are not synchronized. Run: ae-cli update` : void 0
+  );
   printNotice(notice);
   entry.lastNotifiedAt = (/* @__PURE__ */ new Date()).toISOString();
   store.hosts[key] = entry;
   writeStore(store);
+  return { status: "continue" };
 }
-async function runHostCompatCheck(pkg, hostOverride) {
-  if (shouldSkipCompatCheck()) return;
+async function runHostCompatCheck(pkg, hostOverride, argv = process.argv) {
+  pendingHostCompatNotice = void 0;
+  pendingUpdateNotice = void 0;
+  if (shouldSkipCompatCheck(argv)) return { status: "continue" };
   const host = hostOverride || getActiveHost();
-  if (!host) return;
+  if (!host) return { status: "continue" };
   try {
-    await refreshAndMaybeNotify(host, pkg);
+    return await refreshAndMaybeNotify(host, pkg, !shouldSkipAutoSync(argv));
   } catch {
+    return { status: "continue" };
   }
 }
 
@@ -560,8 +998,10 @@ async function printOutput(data, format, jqExpr) {
 }
 
 export {
-  OPEN_SOURCE_AE_CLI_PACKAGE,
-  AE_CLI_SKILLS_REPO,
+  recordVersionSyncResult,
+  buildVersionInstallPlan,
+  friendlyVersionSyncFailure,
+  installVersion,
   fetchCliConfig,
   getCachedCompatForHost,
   formatCapabilityMissCompatHint,

package/dist/{chunk-EBPXT3TN.js → chunk-LHVM35J4.js}

@@ -8,7 +8,7 @@ import {
 } from "./chunk-RGXCNC4N.js";
 import {
   withOutputMetadata
-} from "./chunk-JTKMDN4A.js";
+} from "./chunk-KTYR3U6D.js";
 
 // src/core/capability-command.ts
 import { randomBytes } from "crypto";

package/dist/{chunk-RRFK2W7I.js → chunk-PVBYJWC2.js}

@@ -8,7 +8,7 @@ import {
 } from "./chunk-HQ2A7ITL.js";
 import {
   withOutputMetadata
-} from "./chunk-JTKMDN4A.js";
+} from "./chunk-KTYR3U6D.js";
 
 // src/core/capability-command.ts
 import { randomBytes } from "crypto";

package/dist/{config-DDYJPJX3.js → config-BSSALXEN.js}

@@ -8,7 +8,7 @@ import {
 import {
   printError,
   printOutput
-} from "./chunk-JTKMDN4A.js";
+} from "./chunk-KTYR3U6D.js";
 import "./chunk-E7UXXHO3.js";
 import "./chunk-IR4ZLVPW.js";
 import {