windmill-utils-internal 1.3.4 → 1.3.6

package/dist/cjs/inline-scripts/extractor.d.ts

@@ -1,13 +1,16 @@
 import { PathAssigner } from "../path-utils/path-assigner";
-import { FlowModule } from "../gen/types.gen";
+import { FlowModule, ScriptLang } from "../gen/types.gen";
 /**
  * Represents an inline script extracted from a flow module
  */
-interface InlineScript {
+export interface InlineScript {
     /** File path where the script content should be written */
     path: string;
     /** The actual script content */
     content: string;
+    /** The script language */
+    language: ScriptLang;
+    is_lock: boolean;
 }
 /**
  * Options for extractInlineScripts function
@@ -37,5 +40,4 @@ export declare function extractInlineScripts(modules: FlowModule[], mapping?: Re
  * @param mapping - Existing mapping to extend (defaults to empty object)
  * @returns Record mapping module IDs to their corresponding file paths
  */
-export declare function extractCurrentMapping(modules: FlowModule[] | undefined, mapping?: Record<string, string>): Record<string, string>;
-export {};
+export declare function extractCurrentMapping(modules: FlowModule[] | undefined, mapping?: Record<string, string>, failureModule?: FlowModule, preprocessorModule?: FlowModule): Record<string, string>;

package/dist/cjs/inline-scripts/extractor.js

@@ -6,14 +6,15 @@ const path_assigner_1 = require("../path-utils/path-assigner");
 function extractRawscriptInline(id, summary, rawscript, mapping, separator, assigner) {
     const [basePath, ext] = assigner.assignPath(summary ?? id, rawscript.language);
     const path = mapping[id] ?? basePath + ext;
+    const language = rawscript.language;
     const content = rawscript.content;
-    const r = [{ path: path, content: content }];
+    const r = [{ path: path, content: content, language, is_lock: false }];
     rawscript.content = "!inline " + path.replaceAll(separator, "/");
     const lock = rawscript.lock;
     if (lock && lock != "") {
         const lockPath = basePath + "lock";
         rawscript.lock = "!inline " + lockPath.replaceAll(separator, "/");
-        r.push({ path: lockPath, content: lock });
+        r.push({ path: lockPath, content: lock, language, is_lock: true });
     }
     return r;
 }
@@ -74,7 +75,13 @@ function extractInlineScripts(modules, mapping = {}, separator = "/", defaultTs,
  * @param mapping - Existing mapping to extend (defaults to empty object)
  * @returns Record mapping module IDs to their corresponding file paths
  */
-function extractCurrentMapping(modules, mapping = {}) {
+function extractCurrentMapping(modules, mapping = {}, failureModule, preprocessorModule) {
+    if (failureModule) {
+        extractCurrentMapping([failureModule], mapping);
+    }
+    if (preprocessorModule) {
+        extractCurrentMapping([preprocessorModule], mapping);
+    }
     if (!modules || !Array.isArray(modules)) {
         return mapping;
     }

package/dist/cjs/inline-scripts/replacer.d.ts

@@ -1,4 +1,10 @@
-import { FlowModule } from "../gen/types.gen";
+import { FlowModule, FlowValue, RawScript } from "../gen/types.gen";
+export type LocalScriptInfo = {
+    content: string;
+    language: RawScript["language"];
+    lock?: string;
+    tag?: string;
+};
 /**
  * Replaces inline script references with actual file content from the filesystem.
  * This function recursively processes all flow modules and their nested structures.
@@ -14,3 +20,24 @@ export declare function replaceInlineScripts(modules: FlowModule[], fileReader:
     info: (message: string) => void;
     error: (message: string) => void;
 } | undefined, localPath: string, separator?: string, removeLocks?: string[]): Promise<void>;
+/**
+ * Replaces PathScript ("script" type) modules with RawScript ("rawscript" type) using local file content.
+ * This is used during flow preview so that local script changes are tested instead of remote versions.
+ *
+ * @param modules - Array of flow modules to process
+ * @param scriptReader - Function that takes a script path and returns local content/language/lock, or undefined if not found locally
+ * @param logger - Logger for info/error messages
+ */
+export declare function replacePathScriptsWithLocal(modules: FlowModule[], scriptReader: (scriptPath: string) => Promise<LocalScriptInfo | undefined>, logger?: {
+    info: (message: string) => void;
+    error: (message: string) => void;
+}): Promise<void>;
+/**
+ * Replaces all PathScript modules in a flow value (modules, failure_module, preprocessor_module)
+ * with RawScript using local file content.
+ */
+export declare function replaceAllPathScriptsWithLocal(flowValue: FlowValue, scriptReader: (scriptPath: string) => Promise<LocalScriptInfo | undefined>, logger?: {
+    info: (message: string) => void;
+    error: (message: string) => void;
+}): Promise<void>;
+export declare function collectPathScriptPaths(flowValue: FlowValue): string[];

package/dist/cjs/inline-scripts/replacer.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.replaceInlineScripts = replaceInlineScripts;
+exports.replacePathScriptsWithLocal = replacePathScriptsWithLocal;
+exports.replaceAllPathScriptsWithLocal = replaceAllPathScriptsWithLocal;
+exports.collectPathScriptPaths = collectPathScriptPaths;
 async function replaceRawscriptInline(id, rawscript, fileReader, logger, separator, removeLocks) {
     if (!rawscript.content || !rawscript.content.startsWith("!inline")) {
         return;
@@ -86,3 +89,134 @@ async function replaceInlineScripts(modules, fileReader, logger = {
         }
     }));
 }
+/**
+ * Replaces PathScript ("script" type) modules with RawScript ("rawscript" type) using local file content.
+ * This is used during flow preview so that local script changes are tested instead of remote versions.
+ *
+ * @param modules - Array of flow modules to process
+ * @param scriptReader - Function that takes a script path and returns local content/language/lock, or undefined if not found locally
+ * @param logger - Logger for info/error messages
+ */
+async function replacePathScriptsWithLocal(modules, scriptReader, logger = {
+    info: () => { },
+    error: () => { },
+}) {
+    await Promise.all(modules.map(async (module) => {
+        if (!module.value) {
+            return;
+        }
+        if (module.value.type === "script") {
+            const scriptPath = module.value.path;
+            const localScript = await scriptReader(scriptPath);
+            if (localScript) {
+                const pathScript = module.value;
+                module.value = {
+                    type: "rawscript",
+                    content: localScript.content,
+                    language: localScript.language,
+                    lock: localScript.lock,
+                    path: scriptPath,
+                    input_transforms: pathScript.input_transforms,
+                    tag: pathScript.tag_override ?? localScript.tag,
+                };
+            }
+        }
+        else if (module.value.type === "forloopflow" || module.value.type === "whileloopflow") {
+            await replacePathScriptsWithLocal(module.value.modules, scriptReader, logger);
+        }
+        else if (module.value.type === "branchall") {
+            await Promise.all(module.value.branches.map(async (branch) => {
+                await replacePathScriptsWithLocal(branch.modules, scriptReader, logger);
+            }));
+        }
+        else if (module.value.type === "branchone") {
+            await Promise.all(module.value.branches.map(async (branch) => {
+                await replacePathScriptsWithLocal(branch.modules, scriptReader, logger);
+            }));
+            await replacePathScriptsWithLocal(module.value.default, scriptReader, logger);
+        }
+        else if (module.value.type === "aiagent") {
+            await Promise.all((module.value.tools ?? []).map(async (tool) => {
+                const toolValue = tool.value;
+                if (!toolValue || toolValue.tool_type !== "flowmodule" || toolValue.type !== "script") {
+                    return;
+                }
+                const localScript = await scriptReader(toolValue.path);
+                if (localScript) {
+                    tool.value = {
+                        tool_type: "flowmodule",
+                        type: "rawscript",
+                        content: localScript.content,
+                        language: localScript.language,
+                        lock: localScript.lock,
+                        path: toolValue.path,
+                        input_transforms: toolValue.input_transforms,
+                        tag: toolValue.tag_override ?? localScript.tag,
+                    };
+                }
+            }));
+        }
+    }));
+}
+function collectPathScriptPathsFromModules(modules, paths) {
+    for (const module of modules) {
+        if (!module.value) {
+            continue;
+        }
+        if (module.value.type === "script") {
+            paths.add(module.value.path);
+        }
+        else if (module.value.type === "forloopflow" ||
+            module.value.type === "whileloopflow") {
+            collectPathScriptPathsFromModules(module.value.modules, paths);
+        }
+        else if (module.value.type === "branchall") {
+            for (const branch of module.value.branches) {
+                collectPathScriptPathsFromModules(branch.modules, paths);
+            }
+        }
+        else if (module.value.type === "branchone") {
+            for (const branch of module.value.branches) {
+                collectPathScriptPathsFromModules(branch.modules, paths);
+            }
+            collectPathScriptPathsFromModules(module.value.default, paths);
+        }
+        else if (module.value.type === "aiagent") {
+            for (const tool of module.value.tools ?? []) {
+                const toolValue = tool.value;
+                if (toolValue &&
+                    toolValue.tool_type === "flowmodule" &&
+                    toolValue.type === "script") {
+                    paths.add(toolValue.path);
+                }
+            }
+        }
+    }
+}
+/**
+ * Replaces all PathScript modules in a flow value (modules, failure_module, preprocessor_module)
+ * with RawScript using local file content.
+ */
+async function replaceAllPathScriptsWithLocal(flowValue, scriptReader, logger = {
+    info: () => { },
+    error: () => { },
+}) {
+    await replacePathScriptsWithLocal(flowValue.modules, scriptReader, logger);
+    if (flowValue.failure_module) {
+        await replacePathScriptsWithLocal([flowValue.failure_module], scriptReader, logger);
+    }
+    if (flowValue.preprocessor_module) {
+        await replacePathScriptsWithLocal([flowValue.preprocessor_module], scriptReader, logger);
+    }
+}
+function collectPathScriptPaths(flowValue) {
+    const paths = new Set();
+    collectPathScriptPathsFromModules(flowValue.modules, paths);
+    if (flowValue.failure_module) {
+        collectPathScriptPathsFromModules([flowValue.failure_module], paths);
+    }
+    if (flowValue.preprocessor_module) {
+        collectPathScriptPathsFromModules([flowValue.preprocessor_module], paths);
+    }
+    return [...paths];
+}

package/dist/cjs/path-utils/path-assigner.d.ts

@@ -29,6 +29,11 @@ export declare const EXTENSION_TO_LANGUAGE: Record<string, SupportedLanguage>;
  * @returns The language, or undefined if not recognized
  */
 export declare function getLanguageFromExtension(ext: string, defaultTs?: "bun" | "deno"): SupportedLanguage | undefined;
+/**
+ * Sanitizes a summary string for use as a filesystem-safe name.
+ * Removes or replaces characters that are invalid on common filesystems.
+ */
+export declare function sanitizeForFilesystem(summary: string): string;
 export interface PathAssigner {
     assignPath(summary: string | undefined, language: SupportedLanguage): [string, string];
 }

package/dist/cjs/path-utils/path-assigner.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EXTENSION_TO_LANGUAGE = exports.LANGUAGE_EXTENSIONS = void 0;
 exports.getLanguageExtension = getLanguageExtension;
 exports.getLanguageFromExtension = getLanguageFromExtension;
+exports.sanitizeForFilesystem = sanitizeForFilesystem;
 exports.newPathAssigner = newPathAssigner;
 exports.newRawAppPathAssigner = newRawAppPathAssigner;
 const INLINE_SCRIPT_PREFIX = "inline_script";
@@ -100,6 +101,21 @@ function getLanguageFromExtension(ext, defaultTs = "bun") {
     }
     return undefined;
 }
+/**
+ * Sanitizes a summary string for use as a filesystem-safe name.
+ * Removes or replaces characters that are invalid on common filesystems.
+ */
+function sanitizeForFilesystem(summary) {
+    return summary
+        .toLowerCase()
+        .replaceAll(" ", "_")
+        // Remove characters invalid on Windows/Unix/Mac: / \ : * ? " < > |
+        // Also remove control characters (0x00-0x1F) and DEL (0x7F)
+        // deno-lint-ignore no-control-regex
+        .replace(/[/\\:*?"<>|\x00-\x1f\x7f]/g, "")
+        // Trim leading/trailing dots and underscores (hidden files, Windows edge cases)
+        .replace(/^[._]+|[._]+$/g, "");
+}
 /**
  * Creates a new path assigner for inline scripts.
  *
@@ -117,7 +133,7 @@ function newPathAssigner(defaultTs, options) {
     const seen_names = new Set();
     function assignPath(summary, language) {
         let name;
-        name = summary?.toLowerCase()?.replaceAll(" ", "_") ?? "";
+        name = summary ? sanitizeForFilesystem(summary) : "";
         let original_name = name;
         if (name == "") {
             original_name = INLINE_SCRIPT_PREFIX;
@@ -148,7 +164,7 @@ function newRawAppPathAssigner(defaultTs) {
     const seen_names = new Set();
     function assignPath(summary, language) {
         let name;
-        name = summary?.toLowerCase()?.replaceAll(" ", "_") ?? "";
+        name = summary ? sanitizeForFilesystem(summary) : "";
         let original_name = name;
         if (name == "") {
             original_name = "runnable";

package/dist/esm/config/config.js

@@ -1,67 +1,23 @@
-// Runtime detection
-// @ts-ignore - Cross-platform runtime detection
-const isDeno = typeof Deno !== "undefined";
-// @ts-ignore - Cross-platform runtime detection  
-const isNode = typeof process !== "undefined" && process.versions?.node;
+import { stat, mkdir } from "node:fs/promises";
 export const WINDMILL_CONFIG_DIR = "windmill";
 export const WINDMILL_ACTIVE_WORKSPACE_FILE = "activeWorkspace";
 export const WINDMILL_WORKSPACE_CONFIG_FILE = "remotes.ndjson";
 export const INSTANCES_CONFIG_FILE = "instances.ndjson";
 export const WINDMILL_ACTIVE_INSTANCE_FILE = "activeInstance";
-// Cross-platform environment variable access
 function getEnv(key) {
-    if (isDeno) {
-        // @ts-ignore - Deno API
-        return Deno.env.get(key);
-    }
-    else {
-        // @ts-ignore - Node API
-        return process.env[key];
-    }
+    return process.env[key];
 }
-// Cross-platform OS detection with normalization
 function getOS() {
-    if (isDeno) {
-        // @ts-ignore - Deno API
-        return Deno.build.os;
-    }
-    else if (isNode) {
-        // @ts-ignore - Node API
-        const platform = process.platform;
-        switch (platform) {
-            case "linux": return "linux";
-            case "darwin": return "darwin";
-            case "win32": return "windows"; // Normalize win32 to windows
-            default: return null;
-        }
-    }
-    return null;
-}
-// Cross-platform file system operations
-async function stat(path) {
-    if (isDeno) {
-        // @ts-ignore - Deno API
-        return await Deno.stat(path);
-    }
-    else {
-        // @ts-ignore - Node API
-        const fs = await import('fs/promises');
-        return await fs.stat(path);
-    }
-}
-async function mkdir(path, options) {
-    if (isDeno) {
-        // @ts-ignore - Deno API
-        await Deno.mkdir(path, options);
-    }
-    else {
-        // @ts-ignore - Node API
-        const fs = await import('fs/promises');
-        await fs.mkdir(path, options);
+    const platform = process.platform;
+    switch (platform) {
+        case "linux": return "linux";
+        case "darwin": return "darwin";
+        case "win32": return "windows";
+        default: return null;
     }
 }
 function throwIfNotDirectory(fileInfo) {
-    if (!fileInfo.isDirectory) {
+    if (!fileInfo.isDirectory()) {
         throw new Error("Path is not a directory");
     }
 }
@@ -120,18 +76,8 @@ async function ensureDir(dir) {
         return;
     }
     catch (err) {
-        // Check for file not found error in cross-platform way
-        if (isDeno) {
-            // @ts-ignore - Deno API
-            if (!(err instanceof Deno.errors.NotFound)) {
-                throw err;
-            }
-        }
-        else {
-            // Node.js error codes
-            if (err.code !== 'ENOENT') {
-                throw err;
-            }
+        if (err.code !== 'ENOENT') {
+            throw err;
         }
     }
     // The dir doesn't exist. Create it.
@@ -140,18 +86,8 @@ async function ensureDir(dir) {
         await mkdir(dir, { recursive: true });
     }
     catch (err) {
-        // Check for already exists error in cross-platform way
-        if (isDeno) {
-            // @ts-ignore - Deno API
-            if (!(err instanceof Deno.errors.AlreadyExists)) {
-                throw err;
-            }
-        }
-        else {
-            // Node.js error codes
-            if (err.code !== 'EEXIST') {
-                throw err;
-            }
+        if (err.code !== 'EEXIST') {
+            throw err;
         }
         const fileInfo = await stat(dir);
         throwIfNotDirectory(fileInfo);

package/dist/esm/gen/core/OpenAPI.js

@@ -26,7 +26,7 @@ export const OpenAPI = {
     PASSWORD: undefined,
     TOKEN: getEnv("WM_TOKEN"),
     USERNAME: undefined,
-    VERSION: '1.628.3',
+    VERSION: '1.666.0',
     WITH_CREDENTIALS: true,
     interceptors: {
         request: new Interceptors(),