windmill-cli 1.641.0 → 1.643.0

package/esm/windmill-utils-internal/src/config/config.js

@@ -1,190 +0,0 @@
-// Runtime detection
-import * as dntShim from "../../../_dnt.shims.js";
-// @ts-ignore - Cross-platform runtime detection
-const isDeno = typeof dntShim.Deno !== "undefined";
-// @ts-ignore - Cross-platform runtime detection  
-const isNode = typeof process !== "undefined" && process.versions?.node;
-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 dntShim.Deno.env.get(key);
-    }
-    else {
-        // @ts-ignore - Node API
-        return process.env[key];
-    }
-}
-// Cross-platform OS detection with normalization
-function getOS() {
-    if (isDeno) {
-        // @ts-ignore - Deno API
-        return dntShim.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 dntShim.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 dntShim.Deno.mkdir(path, options);
-    }
-    else {
-        // @ts-ignore - Node API
-        const fs = await import('fs/promises');
-        await fs.mkdir(path, options);
-    }
-}
-function throwIfNotDirectory(fileInfo) {
-    if (!fileInfo.isDirectory) {
-        throw new Error("Path is not a directory");
-    }
-}
-function config_dir() {
-    const os = getOS();
-    switch (os) {
-        case "linux": {
-            const xdg = getEnv("XDG_CONFIG_HOME");
-            if (xdg)
-                return xdg;
-            const home = getEnv("HOME");
-            if (home)
-                return `${home}/.config`;
-            break;
-        }
-        case "darwin": {
-            const home = getEnv("HOME");
-            if (home)
-                return `${home}/Library/Preferences`;
-            break;
-        }
-        case "windows":
-            return getEnv("APPDATA") ?? null;
-    }
-    return null;
-}
-function tmp_dir() {
-    const os = getOS();
-    switch (os) {
-        case "linux": {
-            const xdg = getEnv("XDG_RUNTIME_DIR");
-            if (xdg)
-                return `${xdg}-/tmp`;
-            const tmpDir = getEnv("TMPDIR");
-            if (tmpDir)
-                return tmpDir;
-            const tempDir = getEnv("TEMP");
-            if (tempDir)
-                return tempDir;
-            const tmp = getEnv("TMP");
-            if (tmp)
-                return tmp;
-            return "/var/tmp";
-        }
-        case "darwin":
-            return getEnv("TMPDIR") ?? null;
-        case "windows":
-            return getEnv("TMP") ?? getEnv("TEMP") ?? null;
-    }
-    return null;
-}
-async function ensureDir(dir) {
-    try {
-        const fileInfo = await stat(dir);
-        throwIfNotDirectory(fileInfo);
-        return;
-    }
-    catch (err) {
-        // Check for file not found error in cross-platform way
-        if (isDeno) {
-            // @ts-ignore - Deno API
-            if (!(err instanceof dntShim.Deno.errors.NotFound)) {
-                throw err;
-            }
-        }
-        else {
-            // Node.js error codes
-            if (err.code !== 'ENOENT') {
-                throw err;
-            }
-        }
-    }
-    // The dir doesn't exist. Create it.
-    // This can be racy. So we catch AlreadyExists and check stat again.
-    try {
-        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 dntShim.Deno.errors.AlreadyExists)) {
-                throw err;
-            }
-        }
-        else {
-            // Node.js error codes
-            if (err.code !== 'EEXIST') {
-                throw err;
-            }
-        }
-        const fileInfo = await stat(dir);
-        throwIfNotDirectory(fileInfo);
-    }
-}
-export async function getBaseConfigDir(configDirOverride) {
-    const baseDir = configDirOverride ??
-        getEnv("WMILL_CONFIG_DIR") ??
-        config_dir() ??
-        tmp_dir() ??
-        "/tmp/";
-    return baseDir;
-}
-export async function getConfigDirPath(configDirOverride) {
-    const baseDir = await getBaseConfigDir(configDirOverride);
-    const store = baseDir + `/${WINDMILL_CONFIG_DIR}/`;
-    await ensureDir(store);
-    return store;
-}
-export async function getWorkspaceConfigFilePath(configDirOverride) {
-    const configDir = await getConfigDirPath(configDirOverride);
-    return `${configDir}/${WINDMILL_WORKSPACE_CONFIG_FILE}`;
-}
-export async function getActiveWorkspaceConfigFilePath(configDirOverride) {
-    const configDir = await getConfigDirPath(configDirOverride);
-    return `${configDir}/${WINDMILL_ACTIVE_WORKSPACE_FILE}`;
-}
-export async function getInstancesConfigFilePath(configDirOverride) {
-    const configDir = await getConfigDirPath(configDirOverride);
-    return `${configDir}/${INSTANCES_CONFIG_FILE}`;
-}
-export async function getActiveInstanceFilePath(configDirOverride) {
-    const configDir = await getConfigDirPath(configDirOverride);
-    return `${configDir}/${WINDMILL_ACTIVE_INSTANCE_FILE}`;
-}

package/esm/windmill-utils-internal/src/gen/types.gen.js

@@ -1,2 +0,0 @@
-// This file is auto-generated by @hey-api/openapi-ts
-export {};

package/esm/windmill-utils-internal/src/inline-scripts/extractor.js

@@ -1,109 +0,0 @@
-import { newPathAssigner } from "../path-utils/path-assigner.js";
-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, 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, language, is_lock: true });
-    }
-    return r;
-}
-/**
- * Extracts inline scripts from flow modules, converting them to separate files
- * and replacing the original content with file references.
- *
- * @param modules - Array of flow modules to process
- * @param mapping - Optional mapping of module IDs to custom file paths
- * @param separator - Path separator to use
- * @param defaultTs - Default TypeScript runtime to use ("bun" or "deno")
- * @param pathAssigner - Optional path assigner to reuse (for nested calls)
- * @param options - Optional configuration options
- * @returns Array of inline scripts with their paths and content
- */
-export function extractInlineScripts(modules, mapping = {}, separator = "/", defaultTs, pathAssigner, options) {
-    // Create pathAssigner only if not provided (top-level call), but reuse it for nested calls
-    const assigner = pathAssigner ?? newPathAssigner(defaultTs ?? "bun", { skipInlineScriptSuffix: options?.skipInlineScriptSuffix });
-    return modules.flatMap((m) => {
-        if (m.value.type == "rawscript") {
-            return extractRawscriptInline(m.id, m.summary, m.value, mapping, separator, assigner);
-        }
-        else if (m.value.type == "forloopflow") {
-            return extractInlineScripts(m.value.modules, mapping, separator, defaultTs, assigner);
-        }
-        else if (m.value.type == "branchall") {
-            return m.value.branches.flatMap((b) => extractInlineScripts(b.modules, mapping, separator, defaultTs, assigner));
-        }
-        else if (m.value.type == "whileloopflow") {
-            return extractInlineScripts(m.value.modules, mapping, separator, defaultTs, assigner);
-        }
-        else if (m.value.type == "branchone") {
-            return [
-                ...m.value.branches.flatMap((b) => extractInlineScripts(b.modules, mapping, separator, defaultTs, assigner)),
-                ...extractInlineScripts(m.value.default, mapping, separator, defaultTs, assigner),
-            ];
-        }
-        else if (m.value.type == "aiagent") {
-            return (m.value.tools ?? []).flatMap((tool) => {
-                const toolValue = tool.value;
-                // Only process flowmodule tools with rawscript type
-                if (!toolValue || toolValue.tool_type !== 'flowmodule' || toolValue.type !== 'rawscript') {
-                    return [];
-                }
-                return extractRawscriptInline(tool.id, tool.summary, toolValue, mapping, separator, assigner);
-            });
-        }
-        else {
-            return [];
-        }
-    });
-}
-/**
- * Extracts the current mapping of module IDs to file paths from flow modules
- * by analyzing existing inline script references.
- *
- * @param modules - Array of flow modules to analyze (can be undefined)
- * @param mapping - Existing mapping to extend (defaults to empty object)
- * @returns Record mapping module IDs to their corresponding file paths
- */
-export function extractCurrentMapping(modules, mapping = {}) {
-    if (!modules || !Array.isArray(modules)) {
-        return mapping;
-    }
-    modules.forEach((m) => {
-        if (!m?.value?.type) {
-            return;
-        }
-        if (m.value.type === "rawscript") {
-            if (m.value.content && m.value.content.startsWith("!inline ")) {
-                mapping[m.id] = m.value.content.trim().split(" ")[1];
-            }
-        }
-        else if (m.value.type === "forloopflow" ||
-            m.value.type === "whileloopflow") {
-            extractCurrentMapping(m.value.modules, mapping);
-        }
-        else if (m.value.type === "branchall") {
-            m.value.branches.forEach((b) => extractCurrentMapping(b.modules, mapping));
-        }
-        else if (m.value.type === "branchone") {
-            m.value.branches.forEach((b) => extractCurrentMapping(b.modules, mapping));
-            extractCurrentMapping(m.value.default, mapping);
-        }
-        else if (m.value.type === "aiagent") {
-            (m.value.tools ?? []).forEach((tool) => {
-                const toolValue = tool.value;
-                if (!toolValue || toolValue.tool_type !== 'flowmodule' || toolValue.type !== 'rawscript' || !toolValue.content || !toolValue.content.startsWith("!inline")) {
-                    return;
-                }
-                mapping[tool.id] = toolValue.content.trim().split(" ")[1];
-            });
-        }
-    });
-    return mapping;
-}

package/esm/windmill-utils-internal/src/inline-scripts/replacer.js

@@ -1,85 +0,0 @@
-async function replaceRawscriptInline(id, rawscript, fileReader, logger, separator, removeLocks) {
-    if (!rawscript.content || !rawscript.content.startsWith("!inline")) {
-        return;
-    }
-    const path = rawscript.content.split(" ")[1];
-    const pathSuffix = path.split(".").slice(1).join(".");
-    const newPath = id + "." + pathSuffix;
-    try {
-        rawscript.content = await fileReader(path);
-    }
-    catch {
-        logger.error(`Script file ${path} not found`);
-        try {
-            rawscript.content = await fileReader(newPath);
-        }
-        catch {
-            logger.error(`Script file ${newPath} not found`);
-        }
-    }
-    const lock = rawscript.lock;
-    if (removeLocks && removeLocks.includes(path)) {
-        rawscript.lock = undefined;
-    }
-    else if (lock &&
-        typeof lock === "string" &&
-        lock.trimStart().startsWith("!inline ")) {
-        const lockPath = lock.split(" ")[1];
-        try {
-            rawscript.lock = await fileReader(lockPath.replaceAll("/", separator));
-        }
-        catch {
-            logger.error(`Lock file ${lockPath} not found, treating as empty`);
-            rawscript.lock = "";
-        }
-    }
-}
-/**
- * Replaces inline script references with actual file content from the filesystem.
- * This function recursively processes all flow modules and their nested structures.
- *
- * @param modules - Array of flow modules to process
- * @param fileReader - Function to read file content (typically fs.readFile or similar)
- * @param logger - Optional logger object with info and error methods
- * @param localPath - Base path for resolving relative file paths
- * @param removeLocks - Optional array of paths for which to remove lock files
- * @returns Promise that resolves when all inline scripts have been replaced
- */
-export async function replaceInlineScripts(modules, fileReader, logger = {
-    info: () => { },
-    error: () => { },
-}, localPath, separator = "/", removeLocks) {
-    await Promise.all(modules.map(async (module) => {
-        if (!module.value) {
-            throw new Error(`Module value is undefined for module ${module.id}`);
-        }
-        if (module.value.type === "rawscript") {
-            await replaceRawscriptInline(module.id, module.value, fileReader, logger, separator, removeLocks);
-        }
-        else if (module.value.type === "forloopflow" || module.value.type === "whileloopflow") {
-            await replaceInlineScripts(module.value.modules, fileReader, logger, localPath, separator, removeLocks);
-        }
-        else if (module.value.type === "branchall") {
-            await Promise.all(module.value.branches.map(async (branch) => {
-                await replaceInlineScripts(branch.modules, fileReader, logger, localPath, separator, removeLocks);
-            }));
-        }
-        else if (module.value.type === "branchone") {
-            await Promise.all(module.value.branches.map(async (branch) => {
-                await replaceInlineScripts(branch.modules, fileReader, logger, localPath, separator, removeLocks);
-            }));
-            await replaceInlineScripts(module.value.default, fileReader, logger, localPath, separator, removeLocks);
-        }
-        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 !== "rawscript") {
-                    return;
-                }
-                await replaceRawscriptInline(tool.id, toolValue, fileReader, logger, separator, removeLocks);
-            }));
-        }
-    }));
-}

package/esm/windmill-utils-internal/src/parse/parse-schema.js

@@ -1,254 +0,0 @@
-const ITEMS_PRESERVED_FIELDS = [
-    "properties",
-    "required",
-    "additionalProperties",
-    "enum",
-    "resourceType",
-    "contentEncoding",
-    "description",
-];
-/**
- * Converts argument signature types to JSON schema properties.
- * This function handles various Windmill-specific types and converts them
- * to standard JSON schema format while preserving existing property metadata.
- *
- * @param t - The argument signature type definition (can be string or complex object types)
- * @param oldS - Existing schema property to update with new type information
- */
-export function argSigToJsonSchemaType(t, oldS) {
-    const newS = { type: "" };
-    if (t === "int") {
-        newS.type = "integer";
-    }
-    else if (t === "float") {
-        newS.type = "number";
-    }
-    else if (t === "bool") {
-        newS.type = "boolean";
-    }
-    else if (t === "email") {
-        newS.type = "string";
-        newS.format = "email";
-    }
-    else if (t === "sql") {
-        newS.type = "string";
-        newS.format = "sql";
-    }
-    else if (t === "yaml") {
-        newS.type = "string";
-        newS.format = "yaml";
-    }
-    else if (t === "bytes") {
-        newS.type = "string";
-        newS.contentEncoding = "base64";
-        newS.originalType = "bytes";
-    }
-    else if (t === "datetime") {
-        newS.type = "string";
-        newS.format = "date-time";
-    }
-    else if (t === "date") {
-        newS.type = "string";
-        newS.format = "date";
-    }
-    else if (typeof t !== "string" && "oneof" in t) {
-        newS.type = "object";
-        if (t.oneof) {
-            newS.oneOf = t.oneof.map((obj) => {
-                const oldObjS = oldS.oneOf?.find((o) => o?.title === obj.label) ?? undefined;
-                const properties = {};
-                for (const prop of obj.properties) {
-                    if (oldObjS?.properties && prop.key in oldObjS?.properties) {
-                        properties[prop.key] = oldObjS?.properties[prop.key];
-                    }
-                    else {
-                        properties[prop.key] = { description: "", type: "" };
-                    }
-                    argSigToJsonSchemaType(prop.typ, properties[prop.key]);
-                }
-                return {
-                    type: "object",
-                    title: obj.label,
-                    properties,
-                    order: oldObjS?.order ?? undefined,
-                };
-            });
-        }
-    }
-    else if (typeof t !== "string" && `object` in t) {
-        newS.type = "object";
-        if (t.object.name) {
-            newS.format = `resource-${t.object.name}`;
-        }
-        if (t.object.props) {
-            const properties = {};
-            for (const prop of t.object.props) {
-                if (oldS.properties && prop.key in oldS.properties) {
-                    properties[prop.key] = oldS.properties[prop.key];
-                }
-                else {
-                    properties[prop.key] = { description: "", type: "" };
-                }
-                argSigToJsonSchemaType(prop.typ, properties[prop.key]);
-            }
-            newS.properties = properties;
-        }
-    }
-    else if (typeof t !== "string" && `str` in t) {
-        newS.type = "string";
-        if (t.str) {
-            newS.originalType = "enum";
-            newS.enum = t.str;
-        }
-        else if (oldS.originalType == "string" && oldS.enum) {
-            newS.originalType = "string";
-            newS.enum = oldS.enum;
-        }
-        else {
-            newS.originalType = "string";
-            newS.enum = undefined;
-        }
-    }
-    else if (typeof t !== "string" && `resource` in t) {
-        newS.type = "object";
-        newS.format = `resource-${t.resource}`;
-    }
-    else if (typeof t !== "string" && `dynselect` in t) {
-        newS.type = "object";
-        newS.format = `dynselect-${t.dynselect}`;
-    }
-    else if (typeof t !== "string" && `dynmultiselect` in t) {
-        newS.type = "object";
-        newS.format = `dynmultiselect-${t.dynmultiselect}`;
-    }
-    else if (typeof t !== "string" && `list` in t) {
-        newS.type = "array";
-        if (t.list === "int" || t.list === "float") {
-            newS.items = { type: "number" };
-            newS.originalType = "number[]";
-        }
-        else if (t.list === "bytes") {
-            newS.items = { type: "string", contentEncoding: "base64" };
-            newS.originalType = "bytes[]";
-        }
-        else if (t.list &&
-            typeof t.list == "object" &&
-            "str" in t.list &&
-            t.list.str) {
-            newS.items = { type: "string", enum: t.list.str };
-            newS.originalType = "enum[]";
-        }
-        else if (t.list == "string" ||
-            (t.list && typeof t.list == "object" && "str" in t.list)) {
-            newS.items = { type: "string", enum: oldS.items?.enum };
-            newS.originalType = "string[]";
-        }
-        else if (t.list &&
-            typeof t.list == "object" &&
-            "resource" in t.list &&
-            t.list.resource) {
-            newS.items = {
-                type: "resource",
-                resourceType: t.list.resource,
-            };
-            newS.originalType = "resource[]";
-        }
-        else if (t.list &&
-            typeof t.list == "object" &&
-            "object" in t.list &&
-            t.list.object) {
-            if (t.list.object.name) {
-                newS.format = `resource-${t.list.object.name}`;
-            }
-            if (t.list.object.props && t.list.object.props.length > 0) {
-                const properties = {};
-                for (const prop of t.list.object.props) {
-                    properties[prop.key] = { description: "", type: "" };
-                    argSigToJsonSchemaType(prop.typ, properties[prop.key]);
-                }
-                newS.items = { type: "object", properties: properties };
-            }
-            else {
-                // Preserve ALL user-defined fields when parser cannot infer structure
-                newS.items = { type: oldS.items?.type || "object" };
-                if (oldS.items && typeof oldS.items === "object") {
-                    ITEMS_PRESERVED_FIELDS.forEach((field) => {
-                        if (oldS.items && oldS.items[field] !== undefined) {
-                            newS.items[field] = oldS.items[field];
-                        }
-                    });
-                }
-            }
-            newS.originalType = "record[]";
-        }
-        else {
-            // Preserve ALL user-defined fields for untyped lists (same as record[] branch)
-            newS.items = { type: oldS.items?.type || "object" };
-            if (oldS.items && typeof oldS.items === "object") {
-                ITEMS_PRESERVED_FIELDS.forEach((field) => {
-                    if (oldS.items && oldS.items[field] !== undefined) {
-                        newS.items[field] = oldS.items[field];
-                    }
-                });
-            }
-            newS.originalType = "object[]";
-        }
-    }
-    else {
-        // Preserve existing type when inference fails, default to "object" for undefined/null
-        newS.type = oldS.type ?? "object";
-    }
-    const preservedFields = [
-        "description",
-        "pattern",
-        "min",
-        "max",
-        "currency",
-        "currencyLocale",
-        "multiselect",
-        "customErrorMessage",
-        "required",
-        "showExpr",
-        "password",
-        "order",
-        "dateFormat",
-        "title",
-        "placeholder",
-    ];
-    preservedFields.forEach((field) => {
-        // @ts-ignore
-        if (oldS[field] !== undefined) {
-            // @ts-ignore
-            newS[field] = oldS[field];
-        }
-    });
-    if (oldS.type != newS.type) {
-        for (const prop of Object.getOwnPropertyNames(newS)) {
-            if (prop != "description") {
-                // @ts-ignore
-                delete oldS[prop];
-            }
-        }
-    }
-    else if ((oldS.format == "date" || oldS.format === "date-time") &&
-        newS.format == "string") {
-        newS.format = oldS.format;
-    }
-    else if (newS.format == "date-time" && oldS.format == "date") {
-        newS.format = "date";
-    }
-    else if (newS.format == "date" || newS.format == "date-time") {
-        newS.format = oldS.format;
-    }
-    else if (oldS.items?.type != newS.items?.type) {
-        delete oldS.items;
-    }
-    else if (oldS.type == "string" && oldS.format != undefined) {
-        newS.format = oldS.format;
-    }
-    if ((oldS.type != newS.type || newS.type != "string") &&
-        newS.format == undefined) {
-        oldS.format = undefined;
-    }
-    Object.assign(oldS, newS);
-}