windmill-cli 1.587.1 → 1.588.0

package/esm/gen/core/OpenAPI.js

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

package/esm/gen/services.gen.js

@@ -6603,6 +6603,107 @@ export const listCompletedJobs = (data) => {
         }
     });
 };
+/**
+ * export all completed jobs for backup/migration
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.page which page to return (start at 1, default 1)
+ * @param data.perPage number of items to return for a given page (default 30, max 100)
+ * @returns ExportableCompletedJob All completed jobs exported
+ * @throws ApiError
+ */
+export const exportCompletedJobs = (data) => {
+    return __request(OpenAPI, {
+        method: 'GET',
+        url: '/w/{workspace}/jobs/completed/export',
+        path: {
+            workspace: data.workspace
+        },
+        query: {
+            page: data.page,
+            per_page: data.perPage
+        }
+    });
+};
+/**
+ * import completed jobs from backup/migration
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.requestBody
+ * @returns string Successfully imported completed jobs
+ * @throws ApiError
+ */
+export const importCompletedJobs = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/w/{workspace}/jobs/completed/import',
+        path: {
+            workspace: data.workspace
+        },
+        body: data.requestBody,
+        mediaType: 'application/json'
+    });
+};
+/**
+ * export all queued jobs for backup/migration
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.page which page to return (start at 1, default 1)
+ * @param data.perPage number of items to return for a given page (default 30, max 100)
+ * @returns ExportableQueuedJob All queued jobs exported
+ * @throws ApiError
+ */
+export const exportQueuedJobs = (data) => {
+    return __request(OpenAPI, {
+        method: 'GET',
+        url: '/w/{workspace}/jobs/queue/export',
+        path: {
+            workspace: data.workspace
+        },
+        query: {
+            page: data.page,
+            per_page: data.perPage
+        }
+    });
+};
+/**
+ * import queued jobs from backup/migration
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.requestBody
+ * @returns string Successfully imported queued jobs
+ * @throws ApiError
+ */
+export const importQueuedJobs = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/w/{workspace}/jobs/queue/import',
+        path: {
+            workspace: data.workspace
+        },
+        body: data.requestBody,
+        mediaType: 'application/json'
+    });
+};
+/**
+ * delete jobs by IDs from all related tables
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.requestBody
+ * @returns string Successfully deleted jobs
+ * @throws ApiError
+ */
+export const deleteJobs = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/w/{workspace}/jobs/delete',
+        path: {
+            workspace: data.workspace
+        },
+        body: data.requestBody,
+        mediaType: 'application/json'
+    });
+};
 /**
  * list all jobs
  * @param data The data for the request.

package/esm/src/commands/app/apps.js

@@ -6,6 +6,7 @@ import * as wmill from "../../../gen/services.gen.js";
 import { isSuperset } from "../../types.js";
 import { readInlinePathSync } from "../../utils/utils.js";
 import devCommand from "./dev.js";
+import { isVersionsGeq15851 } from "../sync/global.js";
 const alreadySynced = [];
 function respecializeFields(fields) {
     Object.entries(fields).forEach(([k, v]) => {
@@ -14,7 +15,11 @@ function respecializeFields(fields) {
                 fields[k] = { value: v.value, type: "static" };
             }
             else if (v.expr !== undefined) {
-                fields[k] = { expr: v.expr, allowUserResources: v.allowUserResources, type: "javascript" };
+                fields[k] = {
+                    expr: v.expr,
+                    allowUserResources: v.allowUserResources,
+                    type: "javascript",
+                };
             }
         }
     });
@@ -34,11 +39,15 @@ export function replaceInlineScripts(rec, localPath) {
     }
     if (typeof rec == "object") {
         return Object.entries(rec).flatMap(([k, v]) => {
-            if (k == 'runType') {
-                rec["type"] = 'path';
+            if (k == "runType") {
+                if (isVersionsGeq15851()) {
+                    rec["type"] = "path";
+                }
             }
             else if (k == "inlineScript" && typeof v == "object") {
-                rec["type"] = 'inline';
+                if (isVersionsGeq15851()) {
+                    rec["type"] = "inline";
+                }
                 const o = v;
                 if (o["content"] && o["content"].startsWith("!inline")) {
                     const basePath = localPath + o["content"].split(" ")[1];
@@ -89,7 +98,8 @@ export async function pushApp(workspace, remotePath, localPath, message) {
     const path = localPath + "app.yaml";
     const localApp = (await yamlParseFile(path));
     replaceInlineScripts(localApp.value, localPath);
-    await generatingPolicy(localApp, remotePath, localApp?.["public"] ?? false);
+    await generatingPolicy(localApp, remotePath, localApp?.["public"] ??
+        localApp?.["policy"]?.["execution_mode"] == "anonymous");
     if (app) {
         if (isSuperset(localApp, app)) {
             log.info(colors.green(`App ${remotePath} is up to date`));

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

@@ -223,7 +223,6 @@ const command = new Command()
     .command("generate-locks", "re-generate the lock files of all inline scripts of all updated flows")
     .arguments("[flow:file]")
     .option("--yes", "Skip confirmation prompt")
-    .option("-r --use-raw-requirements", "Use raw requirements (requirements.txt, go.mod, package.json, etc) instead of generating them on the server (can also be set with USE_RAW_REQUIREMENTS=true environment variable)")
     .option("-i --includes <patterns:file[]>", "Comma separated patterns to specify which file to take into account (among files that are compatible with windmill). Patterns can include * (any string until '/') and ** (any string)")
     .option("-e --excludes <patterns:file[]>", "Comma separated patterns to specify which file to NOT take into account.")
     .action(generateLocks)

package/esm/src/commands/jobs/jobs.js

@@ -0,0 +1,186 @@
+import { requireLogin } from "../../core/auth.js";
+import { resolveWorkspace } from "../../core/context.js";
+import { colors, Command, Confirm, log } from "../../../deps.js";
+import { mergeConfigWithConfigFile } from "../../core/conf.js";
+import * as fs from "node:fs/promises";
+import * as wmill from "../../../gen/services.gen.js";
+async function pullJobs(opts, workspace) {
+    opts = await mergeConfigWithConfigFile(opts);
+    const ws = await resolveWorkspace({ ...opts, workspace });
+    await requireLogin(opts);
+    log.info("Pulling jobs from workspace " + ws.workspaceId);
+    // Check for active workers and warn user
+    if (!opts.skipWorkerCheck) {
+        try {
+            const workers = await wmill.listWorkers({ pingSince: 60 });
+            if (workers.length > 0) {
+                log.info(colors.yellow(`\nWarning: Found ${workers.length} active worker(s) on the instance.`));
+                log.info("It's recommended to scale down all workers before exporting jobs to ensure that no new jobs are being created during export.");
+                const proceed = await Confirm.prompt({
+                    message: "Do you want to continue with the export anyway?",
+                    default: false,
+                });
+                if (!proceed) {
+                    log.info("Export cancelled. Please scale down workers and try again.");
+                    log.info("You can skip this check with --skip-worker-check flag.");
+                    return;
+                }
+            }
+        }
+        catch (e) {
+            log.debug(`Could not check for active workers: ${e}`);
+        }
+    }
+    // Pull completed jobs
+    let completedJobs = [];
+    let page = 1;
+    const perPage = 1000;
+    while (true) {
+        const batch = await wmill.exportCompletedJobs({
+            workspace: ws.workspaceId,
+            page,
+            perPage,
+        });
+        if (batch.length === 0)
+            break;
+        completedJobs = completedJobs.concat(batch);
+        if (batch.length < perPage)
+            break;
+        page++;
+    }
+    const completedPath = opts.completedOutput || "completed_jobs.json";
+    await fs.writeFile(completedPath, JSON.stringify(completedJobs, null, 2));
+    log.info(colors.green(`Successfully pulled ${completedJobs.length} completed jobs to ${completedPath}`));
+    // Pull queued jobs
+    let queuedJobs = [];
+    page = 1;
+    while (true) {
+        const batch = await wmill.exportQueuedJobs({
+            workspace: ws.workspaceId,
+            page,
+            perPage,
+        });
+        if (batch.length === 0)
+            break;
+        queuedJobs = queuedJobs.concat(batch);
+        if (batch.length < perPage)
+            break;
+        page++;
+    }
+    const queuedPath = opts.queuedOutput || "queued_jobs.json";
+    await fs.writeFile(queuedPath, JSON.stringify(queuedJobs, null, 2));
+    log.info(colors.green(`Successfully pulled ${queuedJobs.length} queued jobs to ${queuedPath}`));
+    // Ask to delete all jobs (queued and completed)
+    const allJobs = [...queuedJobs, ...completedJobs];
+    if (allJobs.length > 0) {
+        const confirmed = await Confirm.prompt({
+            message: `Do you want to delete the ${allJobs.length} pulled jobs (queued + completed) from the workspace? If you don't, you won't be able to import them again on the same instance because of the unique constraint on the job ID.`,
+            default: false,
+        });
+        if (confirmed) {
+            const jobIds = allJobs.map((job) => job.id);
+            await wmill.deleteJobs({
+                workspace: ws.workspaceId,
+                requestBody: jobIds,
+            });
+            log.info(colors.green(`Deleted ${jobIds.length} jobs (queued + completed)`));
+        }
+        else {
+            log.info("Skipping deletion of jobs");
+        }
+    }
+}
+async function pushJobs(opts, workspace) {
+    opts = await mergeConfigWithConfigFile(opts);
+    const ws = await resolveWorkspace({ ...opts, workspace });
+    await requireLogin(opts);
+    log.info(`Pushing jobs to workspace ${ws.workspaceId}`);
+    // Check for active workers before importing
+    if (!opts.skipWorkerCheck) {
+        try {
+            const workers = await wmill.listWorkers({ pingSince: 60 });
+            if (workers.length > 0) {
+                log.info(colors.yellow(`\nWarning: Found ${workers.length} active worker(s) on the instance.`));
+                log.info("It's recommended to scale down all workers before importing jobs to ensure:");
+                log.info("  - No imported jobs are processed immediately during import");
+                log.info("  - You have time to review or adjust the imported jobs before they start running");
+                log.info("");
+                const proceed = await Confirm.prompt({
+                    message: "Do you want to continue with the import anyway?",
+                    default: false,
+                });
+                if (!proceed) {
+                    log.info("Import cancelled. Please scale down workers and try again.");
+                    log.info("You can skip this check with --skip-worker-check flag.");
+                    return;
+                }
+            }
+        }
+        catch (e) {
+            log.debug(`Could not check for active workers: ${e}`);
+        }
+    }
+    // Push completed jobs
+    const completedPath = opts.completedFile || "completed_jobs.json";
+    try {
+        const completedContent = await fs.readFile(completedPath, "utf-8");
+        const completedJobs = JSON.parse(completedContent);
+        if (!Array.isArray(completedJobs)) {
+            throw new Error("Completed jobs file must contain an array of jobs");
+        }
+        const completedResult = await wmill.importCompletedJobs({
+            workspace: ws.workspaceId,
+            requestBody: completedJobs,
+        });
+        log.info(colors.green(`Completed jobs: ${completedResult}`));
+    }
+    catch (e) {
+        if (e.code === "ENOENT") {
+            log.info(colors.yellow(`No completed jobs file found at ${completedPath}, skipping`));
+        }
+        else {
+            throw new Error(`Failed to push completed jobs: ${e}`);
+        }
+    }
+    // Push queued jobs
+    const queuedPath = opts.queuedFile || "queued_jobs.json";
+    try {
+        const queuedContent = await fs.readFile(queuedPath, "utf-8");
+        const queuedJobs = JSON.parse(queuedContent);
+        if (!Array.isArray(queuedJobs)) {
+            throw new Error("Queued jobs file must contain an array of jobs");
+        }
+        const queuedResult = await wmill.importQueuedJobs({
+            workspace: ws.workspaceId,
+            requestBody: queuedJobs,
+        });
+        log.info(colors.green(`Queued jobs: ${queuedResult}`));
+    }
+    catch (e) {
+        if (e.code === "ENOENT") {
+            log.info(colors.yellow(`No queued jobs file found at ${queuedPath}, skipping`));
+        }
+        else {
+            throw new Error(`Failed to push queued jobs: ${e}`);
+        }
+    }
+}
+const pull = new Command()
+    .description("Pull completed and queued jobs from workspace")
+    .option("-c, --completed-output <file:string>", "Completed jobs output file (default: completed_jobs.json)")
+    .option("-q, --queued-output <file:string>", "Queued jobs output file (default: queued_jobs.json)")
+    .option("--skip-worker-check", "Skip checking for active workers before export")
+    .arguments("[workspace:string]")
+    .action(pullJobs);
+const push = new Command()
+    .description("Push completed and queued jobs to workspace")
+    .option("-c, --completed-file <file:string>", "Completed jobs input file (default: completed_jobs.json)")
+    .option("-q, --queued-file <file:string>", "Queued jobs input file (default: queued_jobs.json)")
+    .option("--skip-worker-check", "Skip checking for active workers before import")
+    .arguments("[workspace:string]")
+    .action(pushJobs);
+const command = new Command()
+    .description("Manage jobs (import/export)")
+    .command("pull", pull)
+    .command("push", push);
+export default command;

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

@@ -0,0 +1,23 @@
+import { colors, log } from "../../../deps.js";
+let GLOBAL_VERSIONS = {
+    remoteMajor: undefined,
+    remoteMinor: undefined,
+};
+export function updateGlobalVersions(version) {
+    try {
+        const [prefix, remoteMinorStr] = version.split(".");
+        GLOBAL_VERSIONS = {
+            remoteMajor: parseInt(prefix.split("v")[1]),
+            remoteMinor: parseInt(remoteMinorStr),
+        };
+    }
+    catch (e) {
+        log.info(colors.gray(`Error reading remote version: ${e}`));
+    }
+}
+export function isVersionsGeq15851() {
+    return (GLOBAL_VERSIONS.remoteMajor !== undefined &&
+        GLOBAL_VERSIONS.remoteMajor >= 1 &&
+        GLOBAL_VERSIONS.remoteMinor !== undefined &&
+        GLOBAL_VERSIONS.remoteMinor >= 5851);
+}

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

@@ -7,7 +7,7 @@ import { getTypeStrFromPath, parseFromPath, pushObj, showConflict, showDiff, } f
 import { downloadZip } from "./pull.js";
 import { exts, findContentFile, findResourceFile, handleScriptMetadata, removeExtensionToPath, } from "../script/script.js";
 import { handleFile } from "../script/script.js";
-import { deepEqual, isFileResource, isRawAppFile, isWorkspaceDependencies } from "../../utils/utils.js";
+import { deepEqual, isFileResource, isRawAppFile, isWorkspaceDependencies, } from "../../utils/utils.js";
 import { getEffectiveSettings, mergeConfigWithConfigFile, validateBranchConfiguration, } from "../../core/conf.js";
 import { fromBranchSpecificPath, getBranchSpecificPath, getSpecificItemsForCurrentBranch, isBranchSpecificFile, isCurrentBranchFile, isSpecificItem, } from "../../core/specific_items.js";
 import { getCurrentGitBranch } from "../../utils/git.js";
@@ -20,6 +20,7 @@ import { extractInlineScripts as extractInlineScriptsForFlows } from "../../../w
 import { generateFlowLockInternal } from "../flow/flow_metadata.js";
 import { isExecutionModeAnonymous } from "../app/apps.js";
 import { generateAppLocksInternal } from "../app/app_metadata.js";
+import { updateGlobalVersions } from "./global.js";
 // Merge CLI options with effective settings, preserving CLI flags as overrides
 function mergeCliWithEffectiveOptions(cliOpts, effectiveOpts) {
     // overlay CLI options on top (undefined cliOpts won't override effectiveOpts)
@@ -210,7 +211,7 @@ export function extractInlineScriptsForApps(key, rec, pathAssigner, toId) {
     }
     if (typeof rec == "object") {
         return Object.entries(rec).flatMap(([k, v]) => {
-            if (k == 'runType') {
+            if (k == "runType") {
                 rec["type"] = undefined;
                 rec["schema"] = undefined;
                 return [];
@@ -613,7 +614,9 @@ export async function* readDirRecursiveWithIgnore(ignore, root) {
         for await (const e2 of e.c()) {
             if (e2.isDirectory) {
                 const dirName = e2.path.split(SEP).pop();
-                if (dirName == "node_modules" || dirName == ".claude" || dirName?.startsWith(".")) {
+                if (dirName == "node_modules" ||
+                    dirName == ".claude" ||
+                    dirName?.startsWith(".")) {
                     continue;
                 }
             }
@@ -637,7 +640,9 @@ export async function elementsToMap(els, ignore, json, skips, specificItems) {
             continue;
         }
         const path = entry.path;
-        if (!isFileResource(path) && !isRawAppFile(path) && !isWorkspaceDependencies(path)) {
+        if (!isFileResource(path) &&
+            !isRawAppFile(path) &&
+            !isWorkspaceDependencies(path)) {
             if (json && path.endsWith(".yaml"))
                 continue;
             if (!json && path.endsWith(".json"))
@@ -668,7 +673,9 @@ export async function elementsToMap(els, ignore, json, skips, specificItems) {
         }
         if (isRawAppFile(path)) {
             const suffix = path.split(".raw_app" + SEP).pop();
-            if (suffix?.startsWith("dist/") || suffix == "wmill.d.ts" || suffix == "package-lock.json") {
+            if (suffix?.startsWith("dist/") ||
+                suffix == "wmill.d.ts" ||
+                suffix == "package-lock.json") {
                 continue;
             }
         }
@@ -715,7 +722,8 @@ export async function elementsToMap(els, ignore, json, skips, specificItems) {
                 continue;
             if (skips.skipFolders && fileType === "folder")
                 continue;
-            if (skips.skipWorkspaceDependencies && fileType === "workspace_dependencies")
+            if (skips.skipWorkspaceDependencies &&
+                fileType === "workspace_dependencies")
                 continue;
         }
         catch {
@@ -1087,7 +1095,8 @@ export async function ignoreF(wmillconf) {
                 if (wmillconf.includeKey && fileType === "encryption_key") {
                     return false; // Don't ignore, always include
                 }
-                if (!wmillconf.skipWorkspaceDependencies && fileType === "workspace_dependencies") {
+                if (!wmillconf.skipWorkspaceDependencies &&
+                    fileType === "workspace_dependencies") {
                     return false; // Don't ignore workspace dependencies (they are always included unless explicitly skipped)
                 }
             }
@@ -1539,6 +1548,9 @@ export async function push(opts) {
         log.info("");
     }
     const version = await fetchVersion(workspace.remote);
+    if (version) {
+        updateGlobalVersions(version);
+    }
     log.info(colors.gray("Remote version: " + version));
     log.info(`remote (${workspace.name}) <- local: ${changes.length} changes to apply`);
     // Handle JSON output for dry-run
@@ -1618,7 +1630,8 @@ export async function push(opts) {
                     const alreadySynced = [];
                     const isRawApp = isRawAppFile(changes[0].path);
                     if (isRawApp) {
-                        const deleteRawApp = changes.find(change => change.name === "deleted" && change.path.endsWith(".raw_app/raw_app.yaml"));
+                        const deleteRawApp = changes.find((change) => change.name === "deleted" &&
+                            change.path.endsWith(".raw_app/raw_app.yaml"));
                         if (deleteRawApp) {
                             changes = [deleteRawApp];
                         }
@@ -1767,7 +1780,8 @@ export async function push(opts) {
                                     });
                                     break;
                                 case "raw_app":
-                                    if (target.endsWith(".raw_app/raw_app.yaml") || target.endsWith(".raw_app/raw_app.json")) {
+                                    if (target.endsWith(".raw_app/raw_app.yaml") ||
+                                        target.endsWith(".raw_app/raw_app.json")) {
                                         await wmill.deleteApp({
                                             workspace: workspaceId,
                                             path: removeSuffix(target, ".raw_app/raw_app.json"),
@@ -1871,7 +1885,7 @@ export async function push(opts) {
                                     await wmill.deleteWorkspaceDependencies({
                                         workspace: workspaceId,
                                         language,
-                                        name
+                                        name,
                                     });
                                     break;
                                 default:

package/esm/src/main.js

@@ -32,6 +32,7 @@ import workers from "./commands/workers/workers.js";
 import queues from "./commands/queues/queues.js";
 import dependencies from "./commands/dependencies/dependencies.js";
 import init from "./commands/init/init.js";
+import jobs from "./commands/jobs/jobs.js";
 export { flow, app, script, workspace, resource, resourceType, user, variable, hub, folder, schedule, trigger, sync, gitsyncSettings, instance, dev, hubPull, pull, push, workspaceAdd, };
 // addEventListener("error", (event) => {
 //   if (event.error) {
@@ -39,7 +40,7 @@ export { flow, app, script, workspace, resource, resourceType, user, variable, h
 //     console.error(JSON.stringify(event.error, null, 4));
 //   }
 // });
-export const VERSION = "1.587.1";
+export const VERSION = "1.588.0";
 export const WM_FORK_PREFIX = "wm-fork";
 const command = new Command()
     .name("wmill")
@@ -75,6 +76,7 @@ const command = new Command()
     .command("workers", workers)
     .command("queues", queues)
     .command("dependencies", dependencies)
+    .command("jobs", jobs)
     .command("version --version", "Show version information")
     .action(async (opts) => {
     console.log("CLI version: " + VERSION);

package/package.json

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