lcclaude 1.0.0

package/dist/src/utils/fastMode.js

@@ -0,0 +1,331 @@
+import axios from "axios";
+import { getOauthConfig, OAUTH_BETA_HEADER } from "../constants/oauth.js";
+import { getFeatureValue_CACHED_MAY_BE_STALE } from "../services/analytics/growthbook.js";
+import {
+  getIsNonInteractiveSession,
+  getKairosActive,
+  preferThirdPartyAuthentication
+} from "../bootstrap/state.js";
+import {
+  logEvent
+} from "../services/analytics/index.js";
+import {
+  getAnthropicApiKey,
+  getClaudeAIOAuthTokens,
+  handleOAuth401Error,
+  hasProfileScope
+} from "./auth.js";
+import { isInBundledMode } from "./bundledMode.js";
+import { getGlobalConfig, saveGlobalConfig } from "./config.js";
+import { logForDebugging } from "./debug.js";
+import { isEnvTruthy } from "./envUtils.js";
+import {
+  getDefaultMainLoopModelSetting,
+  isOpus1mMergeEnabled,
+  parseUserSpecifiedModel
+} from "./model/model.js";
+import { getAPIProvider } from "./model/providers.js";
+import { isEssentialTrafficOnly } from "./privacyLevel.js";
+import {
+  getInitialSettings,
+  getSettingsForSource,
+  updateSettingsForSource
+} from "./settings/settings.js";
+import { createSignal } from "./signal.js";
+export function isFastModeEnabled() {
+  return !isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_FAST_MODE);
+}
+export function isFastModeAvailable() {
+  if (!isFastModeEnabled()) {
+    return false;
+  }
+  return getFastModeUnavailableReason() === null;
+}
+function getDisabledReasonMessage(disabledReason, authType) {
+  switch (disabledReason) {
+    case "free":
+      return authType === "oauth" ? "Fast mode requires a paid subscription" : "Fast mode unavailable during evaluation. Please purchase credits.";
+    case "preference":
+      return "Fast mode has been disabled by your organization";
+    case "extra_usage_disabled":
+      return "Fast mode requires extra usage billing · /extra-usage to enable";
+    case "network_error":
+      return "Fast mode unavailable due to network connectivity issues";
+    case "unknown":
+      return "Fast mode is currently unavailable";
+  }
+}
+export function getFastModeUnavailableReason() {
+  if (!isFastModeEnabled()) {
+    return "Fast mode is not available";
+  }
+  const statigReason = getFeatureValue_CACHED_MAY_BE_STALE("tengu_penguins_off", null);
+  if (statigReason !== null) {
+    logForDebugging(`Fast mode unavailable: ${statigReason}`);
+    return statigReason;
+  }
+  if (!isInBundledMode() && getFeatureValue_CACHED_MAY_BE_STALE("tengu_marble_sandcastle", false)) {
+    return "Fast mode requires the native binary · Install from: https://claude.com/product/claude-code";
+  }
+  if (getIsNonInteractiveSession() && preferThirdPartyAuthentication() && !getKairosActive()) {
+    const flagFastMode = getSettingsForSource("flagSettings")?.fastMode;
+    if (!flagFastMode) {
+      const reason = "Fast mode is not available in the Agent SDK";
+      logForDebugging(`Fast mode unavailable: ${reason}`);
+      return reason;
+    }
+  }
+  if (getAPIProvider() !== "firstParty") {
+    const reason = "Fast mode is not available on Bedrock, Vertex, or Foundry";
+    logForDebugging(`Fast mode unavailable: ${reason}`);
+    return reason;
+  }
+  if (orgStatus.status === "disabled") {
+    if (orgStatus.reason === "network_error" || orgStatus.reason === "unknown") {
+      if (isEnvTruthy(process.env.CLAUDE_CODE_SKIP_FAST_MODE_NETWORK_ERRORS)) {
+        return null;
+      }
+    }
+    const authType = getClaudeAIOAuthTokens() !== null ? "oauth" : "api-key";
+    const reason = getDisabledReasonMessage(orgStatus.reason, authType);
+    logForDebugging(`Fast mode unavailable: ${reason}`);
+    return reason;
+  }
+  return null;
+}
+export const FAST_MODE_MODEL_DISPLAY = "Opus 4.6";
+export function getFastModeModel() {
+  return "opus" + (isOpus1mMergeEnabled() ? "[1m]" : "");
+}
+export function getInitialFastModeSetting(model) {
+  if (!isFastModeEnabled()) {
+    return false;
+  }
+  if (!isFastModeAvailable()) {
+    return false;
+  }
+  if (!isFastModeSupportedByModel(model)) {
+    return false;
+  }
+  const settings = getInitialSettings();
+  if (settings.fastModePerSessionOptIn) {
+    return false;
+  }
+  return settings.fastMode === true;
+}
+export function isFastModeSupportedByModel(modelSetting) {
+  if (!isFastModeEnabled()) {
+    return false;
+  }
+  const model = modelSetting ?? getDefaultMainLoopModelSetting();
+  const parsedModel = parseUserSpecifiedModel(model);
+  return parsedModel.toLowerCase().includes("opus-4-6");
+}
+let runtimeState = { status: "active" };
+let hasLoggedCooldownExpiry = false;
+const cooldownTriggered = createSignal();
+const cooldownExpired = createSignal();
+export const onCooldownTriggered = cooldownTriggered.subscribe;
+export const onCooldownExpired = cooldownExpired.subscribe;
+export function getFastModeRuntimeState() {
+  if (runtimeState.status === "cooldown" && Date.now() >= runtimeState.resetAt) {
+    if (isFastModeEnabled() && !hasLoggedCooldownExpiry) {
+      logForDebugging("Fast mode cooldown expired, re-enabling fast mode");
+      hasLoggedCooldownExpiry = true;
+      cooldownExpired.emit();
+    }
+    runtimeState = { status: "active" };
+  }
+  return runtimeState;
+}
+export function triggerFastModeCooldown(resetTimestamp, reason) {
+  if (!isFastModeEnabled()) {
+    return;
+  }
+  runtimeState = { status: "cooldown", resetAt: resetTimestamp, reason };
+  hasLoggedCooldownExpiry = false;
+  const cooldownDurationMs = resetTimestamp - Date.now();
+  logForDebugging(`Fast mode cooldown triggered (${reason}), duration ${Math.round(cooldownDurationMs / 1000)}s`);
+  logEvent("tengu_fast_mode_fallback_triggered", {
+    cooldown_duration_ms: cooldownDurationMs,
+    cooldown_reason: reason
+  });
+  cooldownTriggered.emit(resetTimestamp, reason);
+}
+export function clearFastModeCooldown() {
+  runtimeState = { status: "active" };
+}
+export function handleFastModeRejectedByAPI() {
+  if (orgStatus.status === "disabled") {
+    return;
+  }
+  orgStatus = { status: "disabled", reason: "preference" };
+  updateSettingsForSource("userSettings", { fastMode: undefined });
+  saveGlobalConfig((current) => ({
+    ...current,
+    penguinModeOrgEnabled: false
+  }));
+  orgFastModeChange.emit(false);
+}
+const overageRejection = createSignal();
+export const onFastModeOverageRejection = overageRejection.subscribe;
+function getOverageDisabledMessage(reason) {
+  switch (reason) {
+    case "out_of_credits":
+      return "Fast mode disabled · extra usage credits exhausted";
+    case "org_level_disabled":
+    case "org_service_level_disabled":
+      return "Fast mode disabled · extra usage disabled by your organization";
+    case "org_level_disabled_until":
+      return "Fast mode disabled · extra usage spending cap reached";
+    case "member_level_disabled":
+      return "Fast mode disabled · extra usage disabled for your account";
+    case "seat_tier_level_disabled":
+    case "seat_tier_zero_credit_limit":
+    case "member_zero_credit_limit":
+      return "Fast mode disabled · extra usage not available for your plan";
+    case "overage_not_provisioned":
+    case "no_limits_configured":
+      return "Fast mode requires extra usage billing · /extra-usage to enable";
+    default:
+      return "Fast mode disabled · extra usage not available";
+  }
+}
+function isOutOfCreditsReason(reason) {
+  return reason === "org_level_disabled_until" || reason === "out_of_credits";
+}
+export function handleFastModeOverageRejection(reason) {
+  const message = getOverageDisabledMessage(reason);
+  logForDebugging(`Fast mode overage rejection: ${reason ?? "unknown"} — ${message}`);
+  logEvent("tengu_fast_mode_overage_rejected", {
+    overage_disabled_reason: reason ?? "unknown"
+  });
+  if (!isOutOfCreditsReason(reason)) {
+    updateSettingsForSource("userSettings", { fastMode: undefined });
+    saveGlobalConfig((current) => ({
+      ...current,
+      penguinModeOrgEnabled: false
+    }));
+  }
+  overageRejection.emit(message);
+}
+export function isFastModeCooldown() {
+  return getFastModeRuntimeState().status === "cooldown";
+}
+export function getFastModeState(model, fastModeUserEnabled) {
+  const enabled = isFastModeEnabled() && isFastModeAvailable() && !!fastModeUserEnabled && isFastModeSupportedByModel(model);
+  if (enabled && isFastModeCooldown()) {
+    return "cooldown";
+  }
+  if (enabled) {
+    return "on";
+  }
+  return "off";
+}
+let orgStatus = { status: "pending" };
+const orgFastModeChange = createSignal();
+export const onOrgFastModeChanged = orgFastModeChange.subscribe;
+async function fetchFastModeStatus(auth) {
+  const endpoint = `${getOauthConfig().BASE_API_URL}/api/claude_code_penguin_mode`;
+  const headers = "accessToken" in auth ? {
+    Authorization: `Bearer ${auth.accessToken}`,
+    "anthropic-beta": OAUTH_BETA_HEADER
+  } : { "x-api-key": auth.apiKey };
+  const response = await axios.get(endpoint, { headers });
+  return response.data;
+}
+const PREFETCH_MIN_INTERVAL_MS = 30000;
+let lastPrefetchAt = 0;
+let inflightPrefetch = null;
+export function resolveFastModeStatusFromCache() {
+  if (!isFastModeEnabled()) {
+    return;
+  }
+  if (orgStatus.status !== "pending") {
+    return;
+  }
+  const isAnt = process.env.USER_TYPE === "ant";
+  const cachedEnabled = getGlobalConfig().penguinModeOrgEnabled === true;
+  orgStatus = isAnt || cachedEnabled ? { status: "enabled" } : { status: "disabled", reason: "unknown" };
+}
+export async function prefetchFastModeStatus() {
+  if (isEssentialTrafficOnly()) {
+    return;
+  }
+  if (!isFastModeEnabled()) {
+    return;
+  }
+  if (inflightPrefetch) {
+    logForDebugging("Fast mode prefetch in progress, returning in-flight promise");
+    return inflightPrefetch;
+  }
+  const apiKey = getAnthropicApiKey();
+  const hasUsableOAuth = getClaudeAIOAuthTokens()?.accessToken && hasProfileScope();
+  if (!hasUsableOAuth && !apiKey) {
+    const isAnt = process.env.USER_TYPE === "ant";
+    const cachedEnabled = getGlobalConfig().penguinModeOrgEnabled === true;
+    orgStatus = isAnt || cachedEnabled ? { status: "enabled" } : { status: "disabled", reason: "preference" };
+    return;
+  }
+  const now = Date.now();
+  if (now - lastPrefetchAt < PREFETCH_MIN_INTERVAL_MS) {
+    logForDebugging("Skipping fast mode prefetch, fetched recently");
+    return;
+  }
+  lastPrefetchAt = now;
+  const fetchWithCurrentAuth = async () => {
+    const currentTokens = getClaudeAIOAuthTokens();
+    const auth = currentTokens?.accessToken && hasProfileScope() ? { accessToken: currentTokens.accessToken } : apiKey ? { apiKey } : null;
+    if (!auth) {
+      throw new Error("No auth available");
+    }
+    return fetchFastModeStatus(auth);
+  };
+  async function doFetch() {
+    try {
+      let status;
+      try {
+        status = await fetchWithCurrentAuth();
+      } catch (err) {
+        const isAuthError = axios.isAxiosError(err) && (err.response?.status === 401 || err.response?.status === 403 && typeof err.response?.data === "string" && err.response.data.includes("OAuth token has been revoked"));
+        if (isAuthError) {
+          const failedAccessToken = getClaudeAIOAuthTokens()?.accessToken;
+          if (failedAccessToken) {
+            await handleOAuth401Error(failedAccessToken);
+            status = await fetchWithCurrentAuth();
+          } else {
+            throw err;
+          }
+        } else {
+          throw err;
+        }
+      }
+      const previousEnabled = orgStatus.status !== "pending" ? orgStatus.status === "enabled" : getGlobalConfig().penguinModeOrgEnabled;
+      orgStatus = status.enabled ? { status: "enabled" } : {
+        status: "disabled",
+        reason: status.disabled_reason ?? "preference"
+      };
+      if (previousEnabled !== status.enabled) {
+        if (!status.enabled) {
+          updateSettingsForSource("userSettings", { fastMode: undefined });
+        }
+        saveGlobalConfig((current) => ({
+          ...current,
+          penguinModeOrgEnabled: status.enabled
+        }));
+        orgFastModeChange.emit(status.enabled);
+      }
+      logForDebugging(`Org fast mode: ${status.enabled ? "enabled" : `disabled (${status.disabled_reason ?? "preference"})`}`);
+    } catch (err) {
+      const isAnt = process.env.USER_TYPE === "ant";
+      const cachedEnabled = getGlobalConfig().penguinModeOrgEnabled === true;
+      orgStatus = isAnt || cachedEnabled ? { status: "enabled" } : { status: "disabled", reason: "network_error" };
+      logForDebugging(`Failed to fetch org fast mode status, defaulting to ${orgStatus.status === "enabled" ? "enabled (cached)" : "disabled (network_error)"}: ${err}`, { level: "error" });
+      logEvent("tengu_org_penguin_mode_fetch_failed", {});
+    } finally {
+      inflightPrefetch = null;
+    }
+  }
+  inflightPrefetch = doFetch();
+  return inflightPrefetch;
+}

package/dist/src/utils/file.js

@@ -0,0 +1,318 @@
+import { chmodSync, writeFileSync as fsWriteFileSync } from "fs";
+import { realpath, stat } from "fs/promises";
+import { homedir } from "os";
+import {
+  basename,
+  dirname,
+  extname,
+  isAbsolute,
+  join,
+  normalize,
+  relative,
+  resolve,
+  sep
+} from "path";
+import { logEvent } from "../services/analytics/index.js";
+import { getFeatureValue_CACHED_MAY_BE_STALE } from "../services/analytics/growthbook.js";
+import { getCwd } from "../utils/cwd.js";
+import { logForDebugging } from "./debug.js";
+import { isENOENT, isFsInaccessible } from "./errors.js";
+import {
+  detectEncodingForResolvedPath,
+  detectLineEndingsForString
+} from "./fileRead.js";
+import { fileReadCache } from "./fileReadCache.js";
+import { getFsImplementation, safeResolvePath } from "./fsOperations.js";
+import { logError } from "./log.js";
+import { expandPath } from "./path.js";
+import { getPlatform } from "./platform.js";
+export async function pathExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+export const MAX_OUTPUT_SIZE = 0.25 * 1024 * 1024;
+export function readFileSafe(filepath) {
+  try {
+    const fs = getFsImplementation();
+    return fs.readFileSync(filepath, { encoding: "utf8" });
+  } catch (error) {
+    logError(error);
+    return null;
+  }
+}
+export function getFileModificationTime(filePath) {
+  const fs = getFsImplementation();
+  return Math.floor(fs.statSync(filePath).mtimeMs);
+}
+export async function getFileModificationTimeAsync(filePath) {
+  const s = await getFsImplementation().stat(filePath);
+  return Math.floor(s.mtimeMs);
+}
+export function writeTextContent(filePath, content, encoding, endings) {
+  let toWrite = content;
+  if (endings === "CRLF") {
+    toWrite = content.replaceAll(`\r
+`, `
+`).split(`
+`).join(`\r
+`);
+  }
+  writeFileSyncAndFlush_DEPRECATED(filePath, toWrite, { encoding });
+}
+export function detectFileEncoding(filePath) {
+  try {
+    const fs = getFsImplementation();
+    const { resolvedPath } = safeResolvePath(fs, filePath);
+    return detectEncodingForResolvedPath(resolvedPath);
+  } catch (error) {
+    if (isFsInaccessible(error)) {
+      logForDebugging(`detectFileEncoding failed for expected reason: ${error.code}`, {
+        level: "debug"
+      });
+    } else {
+      logError(error);
+    }
+    return "utf8";
+  }
+}
+export function detectLineEndings(filePath, encoding = "utf8") {
+  try {
+    const fs = getFsImplementation();
+    const { resolvedPath } = safeResolvePath(fs, filePath);
+    const { buffer, bytesRead } = fs.readSync(resolvedPath, { length: 4096 });
+    const content = buffer.toString(encoding, 0, bytesRead);
+    return detectLineEndingsForString(content);
+  } catch (error) {
+    logError(error);
+    return "LF";
+  }
+}
+export function convertLeadingTabsToSpaces(content) {
+  if (!content.includes("\t"))
+    return content;
+  return content.replace(/^\t+/gm, (_) => "  ".repeat(_.length));
+}
+export function getAbsoluteAndRelativePaths(path) {
+  const absolutePath = path ? expandPath(path) : undefined;
+  const relativePath = absolutePath ? relative(getCwd(), absolutePath) : undefined;
+  return { absolutePath, relativePath };
+}
+export function getDisplayPath(filePath) {
+  const { relativePath } = getAbsoluteAndRelativePaths(filePath);
+  if (relativePath && !relativePath.startsWith("..")) {
+    return relativePath;
+  }
+  const homeDir = homedir();
+  if (filePath.startsWith(homeDir + sep)) {
+    return "~" + filePath.slice(homeDir.length);
+  }
+  return filePath;
+}
+export function findSimilarFile(filePath) {
+  const fs = getFsImplementation();
+  try {
+    const dir = dirname(filePath);
+    const fileBaseName = basename(filePath, extname(filePath));
+    const files = fs.readdirSync(dir);
+    const similarFiles = files.filter((file) => basename(file.name, extname(file.name)) === fileBaseName && join(dir, file.name) !== filePath);
+    const firstMatch = similarFiles[0];
+    if (firstMatch) {
+      return firstMatch.name;
+    }
+    return;
+  } catch (error) {
+    if (!isENOENT(error)) {
+      logError(error);
+    }
+    return;
+  }
+}
+export const FILE_NOT_FOUND_CWD_NOTE = "Note: your current working directory is";
+export async function suggestPathUnderCwd(requestedPath) {
+  const cwd = getCwd();
+  const cwdParent = dirname(cwd);
+  let resolvedPath = requestedPath;
+  try {
+    const resolvedDir = await realpath(dirname(requestedPath));
+    resolvedPath = join(resolvedDir, basename(requestedPath));
+  } catch {}
+  const cwdParentPrefix = cwdParent === sep ? sep : cwdParent + sep;
+  if (!resolvedPath.startsWith(cwdParentPrefix) || resolvedPath.startsWith(cwd + sep) || resolvedPath === cwd) {
+    return;
+  }
+  const relFromParent = relative(cwdParent, resolvedPath);
+  const correctedPath = join(cwd, relFromParent);
+  try {
+    await stat(correctedPath);
+    return correctedPath;
+  } catch {
+    return;
+  }
+}
+export function isCompactLinePrefixEnabled() {
+  return !getFeatureValue_CACHED_MAY_BE_STALE("tengu_compact_line_prefix_killswitch", false);
+}
+export function addLineNumbers({
+  content,
+  startLine
+}) {
+  if (!content) {
+    return "";
+  }
+  const lines = content.split(/\r?\n/);
+  if (isCompactLinePrefixEnabled()) {
+    return lines.map((line, index) => `${index + startLine}	${line}`).join(`
+`);
+  }
+  return lines.map((line, index) => {
+    const numStr = String(index + startLine);
+    if (numStr.length >= 6) {
+      return `${numStr}→${line}`;
+    }
+    return `${numStr.padStart(6, " ")}→${line}`;
+  }).join(`
+`);
+}
+export function stripLineNumberPrefix(line) {
+  const match = line.match(/^\s*\d+[\u2192\t](.*)$/);
+  return match?.[1] ?? line;
+}
+export function isDirEmpty(dirPath) {
+  try {
+    return getFsImplementation().isDirEmptySync(dirPath);
+  } catch (e) {
+    return isENOENT(e);
+  }
+}
+export function readFileSyncCached(filePath) {
+  const { content } = fileReadCache.readFile(filePath);
+  return content;
+}
+export function writeFileSyncAndFlush_DEPRECATED(filePath, content, options = { encoding: "utf-8" }) {
+  const fs = getFsImplementation();
+  let targetPath = filePath;
+  try {
+    const linkTarget = fs.readlinkSync(filePath);
+    targetPath = isAbsolute(linkTarget) ? linkTarget : resolve(dirname(filePath), linkTarget);
+    logForDebugging(`Writing through symlink: ${filePath} -> ${targetPath}`);
+  } catch {}
+  const tempPath = `${targetPath}.tmp.${process.pid}.${Date.now()}`;
+  let targetMode;
+  let targetExists = false;
+  try {
+    targetMode = fs.statSync(targetPath).mode;
+    targetExists = true;
+    logForDebugging(`Preserving file permissions: ${targetMode.toString(8)}`);
+  } catch (e) {
+    if (!isENOENT(e))
+      throw e;
+    if (options.mode !== undefined) {
+      targetMode = options.mode;
+      logForDebugging(`Setting permissions for new file: ${targetMode.toString(8)}`);
+    }
+  }
+  try {
+    logForDebugging(`Writing to temp file: ${tempPath}`);
+    const writeOptions = {
+      encoding: options.encoding,
+      flush: true
+    };
+    if (!targetExists && options.mode !== undefined) {
+      writeOptions.mode = options.mode;
+    }
+    fsWriteFileSync(tempPath, content, writeOptions);
+    logForDebugging(`Temp file written successfully, size: ${content.length} bytes`);
+    if (targetExists && targetMode !== undefined) {
+      chmodSync(tempPath, targetMode);
+      logForDebugging(`Applied original permissions to temp file`);
+    }
+    logForDebugging(`Renaming ${tempPath} to ${targetPath}`);
+    fs.renameSync(tempPath, targetPath);
+    logForDebugging(`File ${targetPath} written atomically`);
+  } catch (atomicError) {
+    logForDebugging(`Failed to write file atomically: ${atomicError}`, {
+      level: "error"
+    });
+    logEvent("tengu_atomic_write_error", {});
+    try {
+      logForDebugging(`Cleaning up temp file: ${tempPath}`);
+      fs.unlinkSync(tempPath);
+    } catch (cleanupError) {
+      logForDebugging(`Failed to clean up temp file: ${cleanupError}`);
+    }
+    logForDebugging(`Falling back to non-atomic write for ${targetPath}`);
+    try {
+      const fallbackOptions = {
+        encoding: options.encoding,
+        flush: true
+      };
+      if (!targetExists && options.mode !== undefined) {
+        fallbackOptions.mode = options.mode;
+      }
+      fsWriteFileSync(targetPath, content, fallbackOptions);
+      logForDebugging(`File ${targetPath} written successfully with non-atomic fallback`);
+    } catch (fallbackError) {
+      logForDebugging(`Non-atomic write also failed: ${fallbackError}`);
+      throw fallbackError;
+    }
+  }
+}
+export function getDesktopPath() {
+  const platform = getPlatform();
+  const homeDir = homedir();
+  if (platform === "macos") {
+    return join(homeDir, "Desktop");
+  }
+  if (platform === "windows") {
+    const windowsHome = process.env.USERPROFILE ? process.env.USERPROFILE.replace(/\\/g, "/") : null;
+    if (windowsHome) {
+      const wslPath = windowsHome.replace(/^[A-Z]:/, "");
+      const desktopPath = `/mnt/c${wslPath}/Desktop`;
+      if (getFsImplementation().existsSync(desktopPath)) {
+        return desktopPath;
+      }
+    }
+    try {
+      const usersDir = "/mnt/c/Users";
+      const userDirs = getFsImplementation().readdirSync(usersDir);
+      for (const user of userDirs) {
+        if (user.name === "Public" || user.name === "Default" || user.name === "Default User" || user.name === "All Users") {
+          continue;
+        }
+        const potentialDesktopPath = join(usersDir, user.name, "Desktop");
+        if (getFsImplementation().existsSync(potentialDesktopPath)) {
+          return potentialDesktopPath;
+        }
+      }
+    } catch (error) {
+      logError(error);
+    }
+  }
+  const desktopPath = join(homeDir, "Desktop");
+  if (getFsImplementation().existsSync(desktopPath)) {
+    return desktopPath;
+  }
+  return homeDir;
+}
+export function isFileWithinReadSizeLimit(filePath, maxSizeBytes = MAX_OUTPUT_SIZE) {
+  try {
+    const stats = getFsImplementation().statSync(filePath);
+    return stats.size <= maxSizeBytes;
+  } catch {
+    return false;
+  }
+}
+export function normalizePathForComparison(filePath) {
+  let normalized = normalize(filePath);
+  if (getPlatform() === "windows") {
+    normalized = normalized.replace(/\//g, "\\").toLowerCase();
+  }
+  return normalized;
+}
+export function pathsEqual(path1, path2) {
+  return normalizePathForComparison(path1) === normalizePathForComparison(path2);
+}