windmill-cli 1.618.2 → 1.620.0

package/esm/gen/core/OpenAPI.js

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

package/esm/gen/services.gen.js

@@ -5633,22 +5633,20 @@ export const existsRawApp = (data) => {
     });
 };
 /**
- * get app by path
+ * get raw app data by
  * @param data The data for the request.
  * @param data.workspace
- * @param data.version
- * @param data.path
+ * @param data.secretWithExtension
  * @returns string app details
  * @throws ApiError
  */
 export const getRawAppData = (data) => {
     return __request(OpenAPI, {
         method: 'GET',
-        url: '/w/{workspace}/apps/get_data/{version}/{path}',
+        url: '/w/{workspace}/apps/get_data/v/{secretWithExtension}',
         path: {
             workspace: data.workspace,
-            version: data.version,
-            path: data.path
+            secretWithExtension: data.secretWithExtension
         }
     });
 };

package/esm/src/commands/flow/flow.js

@@ -149,6 +149,57 @@ async function run(opts, path) {
     });
     log.info(JSON.stringify(jobInfo.result ?? {}, null, 2));
 }
+async function preview(opts, flowPath) {
+    const workspace = await resolveWorkspace(opts);
+    await requireLogin(opts);
+    // Normalize path - ensure it's a directory path to a .flow folder
+    if (!flowPath.endsWith(".flow") && !flowPath.endsWith(".flow" + SEP)) {
+        // Check if it's a flow.yaml file
+        if (flowPath.endsWith("flow.yaml") || flowPath.endsWith("flow.json")) {
+            flowPath = flowPath.substring(0, flowPath.lastIndexOf(SEP));
+        }
+        else {
+            throw new Error("Flow path must be a .flow directory or a flow.yaml file");
+        }
+    }
+    if (!flowPath.endsWith(SEP)) {
+        flowPath += SEP;
+    }
+    // Read and parse the flow definition
+    const localFlow = (await yamlParseFile(flowPath + "flow.yaml"));
+    // Replace inline scripts with their actual content
+    await replaceInlineScripts(localFlow.value.modules, async (path) => await dntShim.Deno.readTextFile(flowPath + path), log, flowPath, SEP);
+    const input = opts.data ? await resolve(opts.data) : {};
+    if (!opts.silent) {
+        log.info(colors.yellow(`Running flow preview for ${flowPath}...`));
+    }
+    log.debug(`Flow value: ${JSON.stringify(localFlow.value, null, 2)}`);
+    // Run the flow preview
+    let result;
+    try {
+        result = await wmill.runFlowPreviewAndWaitResult({
+            workspace: workspace.workspaceId,
+            requestBody: {
+                value: localFlow.value,
+                path: flowPath.substring(0, flowPath.indexOf(".flow")).replaceAll(SEP, "/"),
+                args: input,
+            },
+        });
+    }
+    catch (e) {
+        if (e.body) {
+            log.error(`Flow preview failed: ${JSON.stringify(e.body)}`);
+        }
+        throw e;
+    }
+    if (opts.silent) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        log.info(colors.bold.underline.green("Flow preview completed"));
+        log.info(JSON.stringify(result, null, 2));
+    }
+}
 async function generateLocks(opts, folder) {
     const workspace = await resolveWorkspace(opts);
     await requireLogin(opts);
@@ -220,6 +271,11 @@ const command = new Command()
     .option("-d --data <data:string>", "Inputs specified as a JSON string or a file using @<filename> or stdin using @-.")
     .option("-s --silent", "Do not ouput anything other then the final output. Useful for scripting.")
     .action(run)
+    .command("preview", "preview a local flow without deploying it. Runs the flow definition from local files.")
+    .arguments("<flow_path:string>")
+    .option("-d --data <data:string>", "Inputs specified as a JSON string or a file using @<filename> or stdin using @-.")
+    .option("-s --silent", "Do not output anything other then the final output. Useful for scripting.")
+    .action(preview)
     .command("generate-locks", "re-generate the lock files of all inline scripts of all updated flows")
     .arguments("[flow:file]")
     .option("--yes", "Skip confirmation prompt")

package/esm/src/commands/script/script.js

@@ -785,6 +785,178 @@ async function generateMetadata(opts, scriptPath) {
         }
     }
 }
+async function preview(opts, filePath) {
+    opts = await mergeConfigWithConfigFile(opts);
+    const workspace = await resolveWorkspace(opts);
+    await requireLogin(opts);
+    if (!validatePath(filePath)) {
+        return;
+    }
+    const fstat = await dntShim.Deno.stat(filePath);
+    if (!fstat.isFile) {
+        throw new Error("file path must refer to a file.");
+    }
+    if (filePath.endsWith(".script.json") || filePath.endsWith(".script.yaml")) {
+        throw Error("Cannot preview a script metadata file, point to the script content file instead (.py, .ts, .go, .sh)");
+    }
+    const codebases = await listSyncCodebases(opts);
+    const language = inferContentTypeFromFilePath(filePath, opts?.defaultTs);
+    const content = await dntShim.Deno.readTextFile(filePath);
+    const input = opts.data ? await resolve(opts.data) : {};
+    // Check if this is a codebase script
+    const codebase = language == "bun" ? findCodebase(filePath, codebases) : undefined;
+    let bundledContent = undefined;
+    let isTar = false;
+    if (codebase) {
+        if (codebase.customBundler) {
+            if (!opts.silent) {
+                log.info(`Using custom bundler ${codebase.customBundler} for preview`);
+            }
+            bundledContent = execSync(codebase.customBundler + " " + filePath, {
+                maxBuffer: 1024 * 1024 * 50,
+            }).toString();
+        }
+        else {
+            const esbuild = await import("esbuild");
+            if (!opts.silent) {
+                log.info(`Bundling ${filePath} for preview...`);
+            }
+            const startTime = performance.now();
+            const format = codebase.format ?? "cjs";
+            const out = await esbuild.build({
+                entryPoints: [filePath],
+                format: format,
+                bundle: true,
+                write: false,
+                external: codebase.external,
+                inject: codebase.inject,
+                define: codebase.define,
+                loader: codebase.loader ?? { ".node": "file" },
+                outdir: "/",
+                platform: "node",
+                packages: "bundle",
+                target: format == "cjs" ? "node20.15.1" : "esnext",
+                banner: codebase.banner,
+            });
+            const endTime = performance.now();
+            bundledContent = out.outputFiles[0].text;
+            // Handle multiple output files (create tarball)
+            if (out.outputFiles.length > 1) {
+                const archiveNpm = await import("@ayonli/jsext/archive");
+                if (!opts.silent) {
+                    log.info(`Creating tarball for multiple output files...`);
+                }
+                const tarball = new archiveNpm.Tarball();
+                const mainPath = filePath.split(SEP).pop()?.split(".")[0] + ".js";
+                const mainContent = out.outputFiles.find((file) => file.path == "/" + mainPath)?.text ?? "";
+                tarball.append(new File([mainContent], "main.js", { type: "text/plain" }));
+                for (const file of out.outputFiles) {
+                    if (file.path == "/" + mainPath)
+                        continue;
+                    // deno-lint-ignore no-explicit-any
+                    const fil = new File([file.contents], file.path.substring(1));
+                    tarball.append(fil);
+                }
+                const blob = await streamToBlob(tarball.stream());
+                bundledContent = btoa(await blob.text());
+                isTar = true;
+            }
+            else if (Array.isArray(codebase.assets) && codebase.assets.length > 0) {
+                // Handle assets
+                const archiveNpm = await import("@ayonli/jsext/archive");
+                if (!opts.silent) {
+                    log.info(`Adding assets to tarball...`);
+                }
+                const tarball = new archiveNpm.Tarball();
+                tarball.append(new File([bundledContent], "main.js", { type: "text/plain" }));
+                for (const asset of codebase.assets) {
+                    const data = fs.readFileSync(asset.from);
+                    const blob = new Blob([data], { type: "text/plain" });
+                    const file = new File([blob], asset.to);
+                    tarball.append(file);
+                }
+                const blob = await streamToBlob(tarball.stream());
+                bundledContent = btoa(await blob.text());
+                isTar = true;
+            }
+            if (!opts.silent) {
+                log.info(`Bundled ${filePath}: ${(bundledContent.length / 1024).toFixed(0)}kB (${(endTime - startTime).toFixed(0)}ms)`);
+            }
+        }
+    }
+    if (!opts.silent) {
+        log.info(colors.yellow(`Running preview for ${filePath}...`));
+    }
+    // For codebase scripts with bundles, we need to use a multipart form upload
+    if (bundledContent) {
+        const form = new FormData();
+        const previewPayload = {
+            content: content, // Pass the original content (frontend does this too)
+            path: filePath.substring(0, filePath.indexOf(".")).replaceAll(SEP, "/"),
+            args: input,
+            language: language,
+            kind: isTar ? "tarbundle" : "bundle",
+            format: codebase?.format ?? "cjs",
+        };
+        form.append("preview", JSON.stringify(previewPayload));
+        form.append("file", new Blob([bundledContent], { type: "application/javascript" }));
+        const url = workspace.remote +
+            "api/w/" +
+            workspace.workspaceId +
+            "/jobs/run/preview_bundle";
+        const response = await fetch(url, {
+            method: "POST",
+            headers: { Authorization: `Bearer ${workspace.token}` },
+            body: form,
+        });
+        if (!response.ok) {
+            throw new Error(`Preview failed: ${response.status} - ${response.statusText} - ${await response.text()}`);
+        }
+        const jobId = await response.text();
+        if (!opts.silent) {
+            await track_job(workspace.workspaceId, jobId);
+        }
+        // Wait for the job to complete and get the result
+        while (true) {
+            try {
+                const completedJob = await wmill.getCompletedJob({
+                    workspace: workspace.workspaceId,
+                    id: jobId,
+                });
+                const result = completedJob.result ?? {};
+                if (opts.silent) {
+                    console.log(JSON.stringify(result, null, 2));
+                }
+                else {
+                    log.info(JSON.stringify(result, null, 2));
+                }
+                break;
+            }
+            catch {
+                await new Promise((resolve) => setTimeout(resolve, 100));
+            }
+        }
+    }
+    else {
+        // For regular scripts, use the standard preview API
+        const result = await wmill.runScriptPreviewAndWaitResult({
+            workspace: workspace.workspaceId,
+            requestBody: {
+                content,
+                path: filePath.substring(0, filePath.indexOf(".")).replaceAll(SEP, "/"),
+                args: input,
+                language: language,
+            },
+        });
+        if (opts.silent) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            log.info(colors.bold.underline.green("Preview completed"));
+            log.info(JSON.stringify(result, null, 2));
+        }
+    }
+}
 const command = new Command()
     .description("script related commands")
     .option("--show-archived", "Enable archived scripts in output")
@@ -800,6 +972,11 @@ const command = new Command()
     .option("-d --data <data:file>", "Inputs specified as a JSON string or a file using @<filename> or stdin using @-.")
     .option("-s --silent", "Do not output anything other then the final output. Useful for scripting.")
     .action(run)
+    .command("preview", "preview a local script without deploying it. Supports both regular and codebase scripts.")
+    .arguments("<path:file>")
+    .option("-d --data <data:file>", "Inputs specified as a JSON string or a file using @<filename> or stdin using @-.")
+    .option("-s --silent", "Do not output anything other than the final output. Useful for scripting.")
+    .action(preview)
     .command("bootstrap", "create a new script")
     .arguments("<path:file> <language:string>")
     .option("--summary <summary:string>", "script summary")

package/esm/src/commands/sync/sync.js

@@ -35,6 +35,16 @@ export function findCodebase(path, codebases) {
         return;
     }
     for (const c of codebases) {
+        // First check if the path is within this codebase's relative_path
+        const codebasePath = c.relative_path.replaceAll("\\", "/");
+        const normalizedPath = path.replaceAll("\\", "/");
+        if (!normalizedPath.startsWith(codebasePath + "/") && normalizedPath !== codebasePath) {
+            continue;
+        }
+        // Get the path relative to the codebase root for pattern matching
+        const relativePath = normalizedPath.startsWith(codebasePath + "/")
+            ? normalizedPath.substring(codebasePath.length + 1)
+            : normalizedPath;
         let included = false;
         let excluded = false;
         if (c.includes == undefined || c.includes == null) {
@@ -47,7 +57,7 @@ export function findCodebase(path, codebases) {
             if (included) {
                 break;
             }
-            if (minimatch(path, r)) {
+            if (minimatch(relativePath, r)) {
                 included = true;
             }
         }
@@ -55,7 +65,7 @@ export function findCodebase(path, codebases) {
             c.excludes = [c.excludes];
         }
         for (const r of c.excludes ?? []) {
-            if (minimatch(path, r)) {
+            if (minimatch(relativePath, r)) {
                 excluded = true;
             }
         }
@@ -1047,6 +1057,8 @@ export async function* readDirRecursiveWithIgnore(ignore, root) {
 export async function elementsToMap(els, ignore, json, skips, specificItems, branchOverride) {
     const map = {};
     const processedBasePaths = new Set();
+    // Cache git branch at the start to avoid repeated execSync calls per file
+    const cachedBranch = branchOverride ?? getCurrentGitBranch() ?? undefined;
     for await (const entry of readDirRecursiveWithIgnore(ignore, els)) {
         // console.log("FOO", entry.path, entry.ignored, entry.isDirectory)
         if (entry.isDirectory || entry.ignored) {
@@ -1146,7 +1158,7 @@ export async function elementsToMap(els, ignore, json, skips, specificItems, bra
         }
         // Handle branch-specific files - skip files for other branches
         if (specificItems && isBranchSpecificFile(path)) {
-            if (!isCurrentBranchFile(path, branchOverride)) {
+            if (!isCurrentBranchFile(path, cachedBranch)) {
                 // Skip branch-specific files for other branches
                 continue;
             }
@@ -1182,9 +1194,9 @@ export async function elementsToMap(els, ignore, json, skips, specificItems, bra
             }
         }
         // Handle branch-specific path mapping after all filtering
-        if (isCurrentBranchFile(path, branchOverride)) {
+        if (cachedBranch && isCurrentBranchFile(path, cachedBranch)) {
             // This is a branch-specific file for current branch
-            const currentBranch = branchOverride || getCurrentGitBranch();
+            const currentBranch = cachedBranch;
             const basePath = fromBranchSpecificPath(path, currentBranch);
             // Only use branch-specific files if the item type IS configured as branch-specific
             // AND matches the pattern. Otherwise, skip and use base file instead.
@@ -2064,6 +2076,8 @@ export async function push(opts) {
         // Create a pool of workers that processes items as they become available
         const pool = new Set();
         const queue = [...groupedChangesArray];
+        // Cache git branch at the start to avoid repeated execSync calls per change
+        const cachedBranchForPush = opts.branch || (isGitRepository() ? getCurrentGitBranch() : null);
         while (queue.length > 0 || pool.size > 0) {
             // Fill the pool until we reach parallelizationFactor
             while (pool.size < parallelizationFactor && queue.length > 0) {
@@ -2117,7 +2131,7 @@ export async function push(opts) {
                                     // For branch-specific resources, push to the base path on the workspace server
                                     // This ensures branch-specific files are stored with their base names in the workspace
                                     let serverPath = resourceFilePath;
-                                    const currentBranch = opts.branch || (isGitRepository() ? getCurrentGitBranch() : null);
+                                    const currentBranch = cachedBranchForPush;
                                     if (currentBranch && isBranchSpecificFile(resourceFilePath)) {
                                         serverPath = fromBranchSpecificPath(resourceFilePath, currentBranch);
                                     }

package/esm/src/main.js

@@ -3,6 +3,12 @@ import "../_dnt.polyfills.js";
 import "../_dnt.polyfills.js";
 import * as dntShim from "../_dnt.shims.js";
 import { Command, CompletionsCommand, UpgradeCommand, esMain, log, } from "../deps.js";
+// Node.js-specific imports for symlink resolution in isMain()
+// These are only used in Node.js, not Deno
+// dnt-shim-ignore
+import { realpathSync } from "node:fs";
+// dnt-shim-ignore
+import { fileURLToPath } from "node:url";
 import flow from "./commands/flow/flow.js";
 import app from "./commands/app/app.js";
 import script from "./commands/script/script.js";
@@ -40,7 +46,7 @@ export { flow, app, script, workspace, resource, resourceType, user, variable, h
 //     console.error(JSON.stringify(event.error, null, 4));
 //   }
 // });
-export const VERSION = "1.618.2";
+export const VERSION = "1.620.0";
 // Re-exported from constants.ts to maintain backwards compatibility
 export { WM_FORK_PREFIX } from "./core/constants.js";
 const command = new Command()
@@ -170,8 +176,23 @@ function isMain() {
         return isMain;
     }
     else {
-        //@ts-ignore
-        return esMain.default(globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta));
+        // For Node.js, we need to handle symlinks properly.
+        // The dnt polyfill doesn't resolve symlinks when comparing process.argv[1]
+        // with import.meta.url, so `wmill` symlink doesn't match the real file path.
+        // We resolve symlinks manually to get accurate comparison.
+        try {
+            const scriptPath = process.argv[1];
+            if (!scriptPath)
+                return false;
+            const realScriptPath = realpathSync(scriptPath);
+            const modulePath = fileURLToPath(globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).url);
+            return realScriptPath === modulePath;
+        }
+        catch {
+            // Fallback to esMain if something fails
+            //@ts-ignore
+            return esMain.default(globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta));
+        }
     }
 }
 if (isMain()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "windmill-cli",
-  "version": "1.618.2",
+  "version": "1.620.0",
   "description": "CLI for Windmill",
   "repository": {
     "type": "git",

package/types/gen/services.gen.d.ts

@@ -2809,11 +2809,10 @@ export declare const listRawApps: (data: ListRawAppsData) => CancelablePromise<L
  */
 export declare const existsRawApp: (data: ExistsRawAppData) => CancelablePromise<ExistsRawAppResponse>;
 /**
- * get app by path
+ * get raw app data by
  * @param data The data for the request.
  * @param data.workspace
- * @param data.version
- * @param data.path
+ * @param data.secretWithExtension
  * @returns string app details
  * @throws ApiError
  */