windmill-cli 1.720.0 → 1.721.0

package/esm/main.js

@@ -16772,7 +16772,7 @@ var init_OpenAPI = __esm(() => {
     PASSWORD: undefined,
     TOKEN: getEnv3("WM_TOKEN"),
     USERNAME: undefined,
-    VERSION: "1.720.0",
+    VERSION: "1.721.0",
     WITH_CREDENTIALS: true,
     interceptors: {
       request: new Interceptors,
@@ -25304,7 +25304,7 @@ var init_auth = __esm(async () => {
 });
 
 // src/core/constants.ts
-var WM_FORK_PREFIX = "wm-fork", VERSION = "1.720.0";
+var WM_FORK_PREFIX = "wm-fork", VERSION = "1.721.0";
 
 // src/utils/git.ts
 var exports_git = {};
@@ -65751,21 +65751,25 @@ var exports_sync = {};
 __export(exports_sync, {
   yamlSortedEntries: () => yamlSortedEntries,
   yamlOptions: () => yamlOptions,
+  summarizeCaseRewrites: () => summarizeCaseRewrites,
   resolveWsNameForConfigFromFlags: () => resolveWsNameForConfigFromFlags,
   readDirRecursiveWithIgnore: () => readDirRecursiveWithIgnore2,
   push: () => push4,
   pull: () => pull,
   isWhitelisted: () => isWhitelisted,
+  isCaseInsensitiveFilesystem: () => isCaseInsensitiveFilesystem,
   ignoreF: () => ignoreF,
   gitDeploy: () => gitDeploy,
   generateDatatablesDocumentation: () => generateDatatablesDocumentation,
   generateAgentsDocumentation: () => generateAgentsDocumentation,
   findCodebase: () => findCodebase,
+  findCaseInsensitiveCollisions: () => findCaseInsensitiveCollisions,
   extractInlineScriptsForApps: () => extractInlineScriptsForApps,
   extractFieldsForRawApps: () => extractFieldsForRawApps,
   elementsToMap: () => elementsToMap,
   default: () => sync_default,
   computeWsSpecificFlagOnlyPushes: () => computeWsSpecificFlagOnlyPushes,
+  canonicalizeCaseInsensitiveKeys: () => canonicalizeCaseInsensitiveKeys,
   FSFSElement: () => FSFSElement
 });
 import { writeFile as writeFile7, readdir as readdir4, stat as stat7, rm, copyFile, mkdir as mkdir5 } from "node:fs/promises";
@@ -66930,11 +66934,178 @@ ${configHint}`);
   }
   return map;
 }
-async function compareDynFSElement(els1, els2, ignore, json, skips, ignoreMetadataDeletion, codebases, ignoreCodebaseChanges, specificItems, branchOverride, isEls1Remote) {
-  const [m1, m2] = els2 ? await Promise.all([
+function findCaseInsensitiveCollisions(paths) {
+  const byLower = new Map;
+  for (const full of paths) {
+    const segs = full.split(/[\\/]/).filter((s) => s.length > 0);
+    let acc = "";
+    for (let i = 0;i < segs.length; i++) {
+      acc = i === 0 ? segs[i] : `${acc}/${segs[i]}`;
+      const lower = acc.toLowerCase();
+      let set = byLower.get(lower);
+      if (!set) {
+        set = new Set;
+        byLower.set(lower, set);
+      }
+      set.add(acc);
+    }
+  }
+  const collidingLowers = new Set;
+  for (const [lower, set] of byLower) {
+    if (set.size > 1)
+      collidingLowers.add(lower);
+  }
+  const collisions = [];
+  for (const lower of collidingLowers) {
+    const parts = lower.split("/");
+    let hasCollidingAncestor = false;
+    for (let i = 1;i < parts.length; i++) {
+      if (collidingLowers.has(parts.slice(0, i).join("/"))) {
+        hasCollidingAncestor = true;
+        break;
+      }
+    }
+    if (!hasCollidingAncestor) {
+      collisions.push([...byLower.get(lower)].sort());
+    }
+  }
+  return collisions;
+}
+function canonicalizeCaseInsensitiveKeys(localMap, remoteMap) {
+  const root = { children: new Map };
+  for (const k of Object.keys(remoteMap)) {
+    let node = root;
+    for (const seg of k.split(/[\\/]/)) {
+      if (seg.length === 0)
+        continue;
+      const lk = seg.toLowerCase();
+      let entry = node.children.get(lk);
+      if (!entry) {
+        entry = { canonical: seg, ambiguous: false, node: { children: new Map } };
+        node.children.set(lk, entry);
+      } else if (entry.canonical !== seg) {
+        entry.ambiguous = true;
+      }
+      node = entry.node;
+    }
+  }
+  const out = {};
+  const rewritten = [];
+  for (const [k, v] of Object.entries(localMap)) {
+    const sep3 = k.includes("\\") ? "\\" : "/";
+    const segs = k.split(/[\\/]/);
+    const canonSegs = [];
+    let node = root;
+    let changed = false;
+    for (const seg of segs) {
+      if (seg.length === 0) {
+        canonSegs.push(seg);
+        continue;
+      }
+      const entry = node?.children.get(seg.toLowerCase());
+      if (entry && !entry.ambiguous) {
+        if (entry.canonical !== seg)
+          changed = true;
+        canonSegs.push(entry.canonical);
+        node = entry.node;
+      } else {
+        canonSegs.push(seg);
+        node = undefined;
+      }
+    }
+    const canonKey = canonSegs.join(sep3);
+    if (changed && canonKey !== k) {
+      out[canonKey] = v;
+      rewritten.push({ from: k, to: canonKey });
+    } else {
+      out[k] = v;
+    }
+  }
+  return {
+    map: out,
+    ambiguous: findCaseInsensitiveCollisions(Object.keys(remoteMap)),
+    rewritten
+  };
+}
+function summarizeCaseRewrites(rewritten) {
+  const seen = new Set;
+  const out = [];
+  for (const { from, to } of rewritten) {
+    const fromSegs = from.split(/[\\/]/);
+    const toSegs = to.split(/[\\/]/);
+    let i = 0;
+    while (i < fromSegs.length && i < toSegs.length && fromSegs[i] === toSegs[i]) {
+      i++;
+    }
+    const fromPrefix = fromSegs.slice(0, i + 1).join("/");
+    const toPrefix = toSegs.slice(0, i + 1).join("/");
+    const key = `${fromPrefix} -> ${toPrefix}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      out.push(key);
+    }
+  }
+  return out;
+}
+function warnUnrepresentableCaseCollisions(collisions) {
+  if (collisions.length === 0)
+    return;
+  const groups = collisions.map((g) => `  - ${g.join("  <->  ")}`).join(`
+`);
+  warn(`Found ${collisions.length} path(s) that differ only by letter case:
+` + `${groups}
+` + `On case-insensitive filesystems (Windows, default macOS) these collapse ` + `into a single file/directory and cannot both be synced. Rename one side ` + `to a distinct path to make the tree sync reliably across platforms.`);
+}
+async function isCaseInsensitiveFilesystem(dir) {
+  const override = (process.env.WMILL_CASE_INSENSITIVE_FS ?? "").trim().toLowerCase();
+  if (override === "true" || override === "1")
+    return true;
+  if (override === "false" || override === "0")
+    return false;
+  if (_caseInsensitiveFsCache !== undefined)
+    return _caseInsensitiveFsCache;
+  let result = false;
+  try {
+    const upper = path10.join(dir, `.wmill-CASEPROBE-${process.pid}.tmp`);
+    const lower = path10.join(dir, `.wmill-caseprobe-${process.pid}.tmp`);
+    await writeFile7(upper, "", "utf-8");
+    try {
+      await stat7(lower);
+      result = true;
+    } catch {
+      result = false;
+    }
+    await rm(upper).catch(() => {});
+    await rm(lower).catch(() => {});
+  } catch {
+    result = false;
+  }
+  _caseInsensitiveFsCache = result;
+  return result;
+}
+async function compareDynFSElement(els1, els2, ignore, json, skips, ignoreMetadataDeletion, codebases, ignoreCodebaseChanges, specificItems, branchOverride, isEls1Remote, caseInsensitiveFs) {
+  let [m1, m2] = els2 ? await Promise.all([
     elementsToMap(els1, ignore, json, skips, specificItems, branchOverride, isEls1Remote),
     elementsToMap(els2, ignore, json, skips, specificItems, branchOverride, !isEls1Remote)
   ]) : [await elementsToMap(els1, ignore, json, skips, specificItems, branchOverride, isEls1Remote), {}];
+  if (els2 && isEls1Remote !== undefined) {
+    const remoteMap = isEls1Remote ? m1 : m2;
+    warnUnrepresentableCaseCollisions(findCaseInsensitiveCollisions(Object.keys(remoteMap)));
+    if (caseInsensitiveFs) {
+      const { map, rewritten } = canonicalizeCaseInsensitiveKeys(isEls1Remote ? m2 : m1, remoteMap);
+      if (isEls1Remote) {
+        m2 = map;
+      } else {
+        m1 = map;
+      }
+      const summary = summarizeCaseRewrites(rewritten);
+      if (summary.length > 0) {
+        info(`Reconciled ${summary.length} local path(s) to the server's casing ` + `(case-insensitive filesystem):
+` + summary.map((s) => `  ${s}`).join(`
+`));
+      }
+    }
+  }
   const changes = [];
   function parseYaml(k, v) {
     if (k.endsWith(".script.yaml")) {
@@ -67374,7 +67545,7 @@ async function pull(opts) {
   const zipFile = await downloadZip(workspace, opts.plainSecrets, opts.skipVariables, opts.skipResources, opts.skipResourceTypes, opts.skipSecrets, opts.includeSchedules, opts.includeTriggers, opts.includeUsers, opts.includeGroups, opts.includeSettings, opts.includeKey, opts.skipWorkspaceDependencies, opts.defaultTs);
   const remote = ZipFSElement(zipFile, !opts.json, opts.defaultTs ?? "bun", resourceTypeToFormatExtension, resourceTypeToIsFileset, true, parseSyncBehavior(opts.syncBehavior) >= 1);
   const local = !opts.stateful ? await FSFSElement(process.cwd(), codebases, true) : await FSFSElement(path10.join(process.cwd(), ".wmill"), [], true);
-  const { changes, localMap } = await compareDynFSElement(remote, local, await ignoreF(opts), opts.json ?? false, opts, false, codebases, true, specificItems, wsNameForFiles, true);
+  const { changes, localMap } = await compareDynFSElement(remote, local, await ignoreF(opts), opts.json ?? false, opts, false, codebases, true, specificItems, wsNameForFiles, true, await isCaseInsensitiveFilesystem(process.cwd()));
   info(`remote (${workspace.name}) -> local: ${changes.length} changes to apply`);
   if (wsSpecificMerge.serverItems && wsSpecificMerge.serverItems.length > 0) {
     const changedPaths = new Set(changes.map((c) => c.path));
@@ -67737,7 +67908,7 @@ Push aborted: ${lockIssues.length} script(s) missing locks.`));
   } catch {}
   const remote = ZipFSElement(await downloadZip(workspace, opts.plainSecrets, opts.skipVariables, opts.skipResources, opts.skipResourceTypes, opts.skipSecrets, opts.includeSchedules, opts.includeTriggers, opts.includeUsers, opts.includeGroups, opts.includeSettings, opts.includeKey, opts.skipWorkspaceDependencies, opts.defaultTs), !opts.json, opts.defaultTs ?? "bun", resourceTypeToFormatExtension, resourceTypeToIsFileset, false, parseSyncBehavior(opts.syncBehavior) >= 1);
   const local = await FSFSElement(path10.join(process.cwd(), ""), codebases, false);
-  const { changes, localMap } = await compareDynFSElement(local, remote, await ignoreF(opts), opts.json ?? false, opts, true, codebases, false, specificItems, wsNameForFiles, false);
+  const { changes, localMap } = await compareDynFSElement(local, remote, await ignoreF(opts), opts.json ?? false, opts, true, codebases, false, specificItems, wsNameForFiles, false, await isCaseInsensitiveFilesystem(process.cwd()));
   const wsSpecificFlagOnly = computeWsSpecificFlagOnlyPushes(localMap, localSpecificItems, serverWsSpecificItems);
   for (const item of wsSpecificFlagOnly) {
     if (changes.some((c) => c.path === item.filePath))
@@ -68523,7 +68694,7 @@ Done! All ${changes.length} changes pushed to the remote workspace ${workspace.w
     }
   }
 }
-var import_yaml11, branchDeprecationWarned = false, yamlOptions, isNotWmillFile = (p, isDirectory2) => {
+var import_yaml11, branchDeprecationWarned = false, yamlOptions, _caseInsensitiveFsCache, isNotWmillFile = (p, isDirectory2) => {
   if (p.endsWith(SEP9)) {
     return false;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "windmill-cli",
-  "version": "1.720.0",
+  "version": "1.721.0",
   "description": "CLI for Windmill",
   "license": "Apache 2.0",
   "type": "module",