windmill-cli 1.518.1 → 1.518.3

package/esm/src/core/settings.js

@@ -0,0 +1,432 @@
+import * as dntShim from "../../_dnt.shims.js";
+import process from "node:process";
+import { colors, Confirm, log, yamlParseFile, yamlStringify } from "../../deps.js";
+import * as wmill from "../../gen/services.gen.js";
+import { compareInstanceObjects } from "../commands/instance/instance.js";
+import { isSuperset } from "../types.js";
+import { deepEqual } from "../utils/utils.js";
+import { removeWorkerPrefix } from "../commands/worker-groups/worker_groups.js";
+import { decrypt, encrypt } from "../utils/local_encryption.js";
+const INSTANCE_SETTINGS_PATH = "instance_settings.yaml";
+let instanceSettingsPath = INSTANCE_SETTINGS_PATH;
+async function checkInstanceSettingsPath(opts) {
+    if (opts.prefix && opts.folderPerInstance && opts.prefixSettings) {
+        instanceSettingsPath = `${opts.prefix}/${INSTANCE_SETTINGS_PATH}`;
+    }
+}
+const INSTANCE_CONFIGS_PATH = "instance_configs.yaml";
+let instanceConfigsPath = INSTANCE_CONFIGS_PATH;
+async function checkInstanceConfigPath(opts) {
+    if (opts.prefix && opts.folderPerInstance && opts.prefixSettings) {
+        instanceConfigsPath = `${opts.prefix}/${INSTANCE_CONFIGS_PATH}`;
+    }
+}
+export async function pushWorkspaceSettings(workspace, _path, settings, localSettings) {
+    try {
+        const remoteSettings = await wmill.getSettings({
+            workspace,
+        });
+        const workspaceName = await wmill.getWorkspaceName({
+            workspace,
+        });
+        settings = {
+            // slack_team_id: remoteSettings.slack_team_id,
+            // slack_name: remoteSettings.slack_name,
+            // slack_command_script: remoteSettings.slack_command_script,
+            // slack_email: remoteSettings.slack_email,
+            auto_invite_enabled: remoteSettings.auto_invite_domain !== null,
+            auto_invite_as: remoteSettings.auto_invite_operator
+                ? "operator"
+                : "developer",
+            auto_invite_mode: remoteSettings.auto_add ? "add" : "invite",
+            webhook: remoteSettings.webhook,
+            deploy_to: remoteSettings.deploy_to,
+            error_handler: remoteSettings.error_handler,
+            error_handler_extra_args: remoteSettings.error_handler_extra_args,
+            error_handler_muted_on_cancel: remoteSettings.error_handler_muted_on_cancel,
+            ai_config: remoteSettings.ai_config,
+            large_file_storage: remoteSettings.large_file_storage,
+            git_sync: remoteSettings.git_sync,
+            default_app: remoteSettings.default_app,
+            default_scripts: remoteSettings.default_scripts,
+            name: workspaceName,
+            mute_critical_alerts: remoteSettings.mute_critical_alerts,
+            color: remoteSettings.color,
+            operator_settings: remoteSettings.operator_settings,
+        };
+    }
+    catch (err) {
+        throw new Error(`Failed to get workspace settings: ${err}`);
+    }
+    if (isSuperset(localSettings, settings)) {
+        log.debug(`Workspace settings are up to date`);
+        return;
+    }
+    log.debug(`Workspace settings are not up-to-date, updating...`);
+    if (localSettings.webhook !== settings.webhook) {
+        log.debug(`Updateing webhook...`);
+        await wmill.editWebhook({
+            workspace,
+            requestBody: {
+                webhook: localSettings.webhook,
+            },
+        });
+    }
+    if (localSettings.auto_invite_as !== settings.auto_invite_as ||
+        localSettings.auto_invite_enabled !== settings.auto_invite_enabled ||
+        localSettings.auto_invite_mode !== settings.auto_invite_mode) {
+        log.debug(`Updating auto invite...`);
+        if (!["operator", "developer"].includes(settings.auto_invite_as)) {
+            throw new Error(`Invalid value for auto_invite_as. Valid values are "operator" and "developer"`);
+        }
+        if (!["add", "invite"].includes(settings.auto_invite_mode)) {
+            throw new Error(`Invalid value for auto_invite_mode. Valid values are "invite" and "add"`);
+        }
+        try {
+            await wmill.editAutoInvite({
+                workspace,
+                requestBody: localSettings.auto_invite_enabled
+                    ? {
+                        operator: localSettings.auto_invite_as === "operator",
+                        invite_all: true,
+                        auto_add: localSettings.auto_invite_mode === "add",
+                    }
+                    : {},
+            });
+        }
+        catch (_) {
+            // on cloud
+            log.debug(`Auto invite is not possible on cloud, only auto-inviting same domain...`);
+            await wmill.editAutoInvite({
+                workspace,
+                requestBody: localSettings.auto_invite_enabled
+                    ? {
+                        operator: localSettings.auto_invite_as === "operator",
+                        invite_all: false,
+                        auto_add: localSettings.auto_invite_mode === "add",
+                    }
+                    : {},
+            });
+        }
+    }
+    if (!deepEqual(localSettings.ai_config, settings.ai_config)) {
+        log.debug(`Updating copilot settings...`);
+        await wmill.editCopilotConfig({
+            workspace,
+            requestBody: localSettings.ai_config ?? {},
+        });
+    }
+    if (localSettings.error_handler != settings.error_handler ||
+        !deepEqual(localSettings.error_handler_extra_args, settings.error_handler_extra_args) ||
+        localSettings.error_handler_muted_on_cancel !=
+            settings.error_handler_muted_on_cancel) {
+        log.debug(`Updating error handler...`);
+        await wmill.editErrorHandler({
+            workspace,
+            requestBody: {
+                error_handler: localSettings.error_handler,
+                error_handler_extra_args: localSettings.error_handler_extra_args,
+                error_handler_muted_on_cancel: localSettings.error_handler_muted_on_cancel,
+            },
+        });
+    }
+    if (localSettings.deploy_to != settings.deploy_to) {
+        log.debug(`Updating deploy to...`);
+        await wmill.editDeployTo({
+            workspace,
+            requestBody: {
+                deploy_to: localSettings.deploy_to,
+            },
+        });
+    }
+    if (!deepEqual(localSettings.large_file_storage, settings.large_file_storage)) {
+        log.debug(`Updating large file storage...`);
+        await wmill.editLargeFileStorageConfig({
+            workspace,
+            requestBody: {
+                large_file_storage: localSettings.large_file_storage,
+            },
+        });
+    }
+    if (!deepEqual(localSettings.git_sync, settings.git_sync)) {
+        log.debug(`Updating git sync...`);
+        await wmill.editWorkspaceGitSyncConfig({
+            workspace,
+            requestBody: {
+                git_sync_settings: localSettings.git_sync,
+            },
+        });
+    }
+    if (!deepEqual(localSettings.default_scripts, settings.default_scripts)) {
+        log.debug(`Updating default scripts...`);
+        await wmill.editDefaultScripts({
+            workspace,
+            requestBody: localSettings.default_scripts,
+        });
+    }
+    if (localSettings.default_app != settings.default_app) {
+        log.debug(`Updating default app...`);
+        await wmill.editWorkspaceDefaultApp({
+            workspace,
+            requestBody: {
+                default_app_path: localSettings.default_app,
+            },
+        });
+    }
+    if (localSettings.name != settings.name) {
+        log.debug(`Updating workspace name...`);
+        await wmill.changeWorkspaceName({
+            workspace,
+            requestBody: {
+                new_name: localSettings.name,
+            },
+        });
+    }
+    if (localSettings.mute_critical_alerts != settings.mute_critical_alerts) {
+        log.debug(`Updating mute critical alerts...`);
+        await wmill.workspaceMuteCriticalAlertsUi({
+            workspace,
+            requestBody: {
+                mute_critical_alerts: localSettings.mute_critical_alerts,
+            },
+        });
+    }
+    if (localSettings.color != settings.color) {
+        log.debug(`Updating workspace color...`);
+        await wmill.changeWorkspaceColor({
+            workspace,
+            requestBody: {
+                color: localSettings.color,
+            },
+        });
+    }
+    if (localSettings.operator_settings != settings.operator_settings) {
+        log.debug(`Updating operator settings...`);
+        await wmill.updateOperatorSettings({
+            workspace,
+            requestBody: localSettings.operator_settings,
+        });
+    }
+}
+export async function pushWorkspaceKey(workspace, _path, key, localKey) {
+    try {
+        key = await wmill
+            .getWorkspaceEncryptionKey({
+            workspace,
+        })
+            .then((r) => r.key);
+    }
+    catch (err) {
+        throw new Error(`Failed to get workspace encryption key: ${err}`);
+    }
+    if (localKey && key !== localKey) {
+        const confirm = await Confirm.prompt({
+            message: "The local workspace encryption key does not match the remote. Do you want to reencrypt all your secrets on the remote with the new key?\nSay 'no' if your local secrets are already encrypted with the new key (e.g. workspace/instance migration)\nOtherwise, say 'yes' and pull the secrets after the reencryption.\n",
+            default: true,
+        });
+        log.debug(`Updating workspace encryption key...`);
+        await wmill.setWorkspaceEncryptionKey({
+            workspace,
+            requestBody: {
+                new_key: localKey,
+                skip_reencrypt: !confirm,
+            },
+        });
+    }
+    else {
+        log.debug(`Workspace encryption key is up to date`);
+    }
+}
+export async function readInstanceSettings(opts) {
+    let localSettings = [];
+    await checkInstanceSettingsPath(opts);
+    try {
+        localSettings = (await yamlParseFile(instanceSettingsPath));
+    }
+    catch {
+        log.warn(`No ${instanceSettingsPath} found`);
+    }
+    return localSettings;
+}
+const SENSITIVE_FIELD = ["license_key", "jwt_secret"];
+async function processInstanceSettings(settings, mode) {
+    const encKey = process.env.WMILL_INSTANCE_LOCAL_ENCRYPTION_KEY;
+    if (encKey) {
+        const res = [];
+        for (const s of settings) {
+            if (SENSITIVE_FIELD.includes(s.name) && typeof s.value === "string") {
+                res.push((await processField(s, "value", encKey, mode)));
+            }
+            else if (s.name == "oauths") {
+                if (typeof s.value === "object") {
+                    const oauths = s.value;
+                    for (const [k, v] of Object.entries(oauths)) {
+                        oauths[k] = await processField(v, "secret", encKey, mode);
+                    }
+                    res.push(s);
+                }
+                else {
+                    log.warn(`Unexpected oauths value type: ${typeof s.value}`);
+                    res.push(s);
+                }
+            }
+            else {
+                res.push(s);
+            }
+        }
+        return res;
+    }
+    else {
+        log.warn("No encryption key found, skipping encryption. Recommend setting WMILL_INSTANCE_LOCAL_ENCRYPTION_KEY");
+    }
+    return settings;
+}
+async function processField(obj, field, encKey, mode) {
+    return {
+        ...obj,
+        [field]: mode === "encode"
+            ? await encrypt(obj[field], encKey)
+            : (await decrypt(obj[field], encKey)),
+    };
+}
+export async function pullInstanceSettings(opts, preview = false) {
+    const remoteSettings = await wmill.listGlobalSettings();
+    await checkInstanceSettingsPath(opts);
+    if (preview) {
+        const localSettings = await readInstanceSettings(opts);
+        const processedSettings = await processInstanceSettings(remoteSettings, "encode");
+        return compareInstanceObjects(processedSettings, localSettings, "name", "setting");
+    }
+    else {
+        log.info("Pulling settings from instance");
+        const processedSettings = await processInstanceSettings(remoteSettings, "encode");
+        await dntShim.Deno.writeTextFile(instanceSettingsPath, yamlStringify(processedSettings));
+        log.info(colors.green(`Settings written to ${instanceSettingsPath}`));
+    }
+}
+export async function pushInstanceSettings(opts, preview = false) {
+    const remoteSettings = await wmill.listGlobalSettings();
+    let localSettings = await readInstanceSettings(opts);
+    localSettings = await processInstanceSettings(localSettings, "decode");
+    if (opts.baseUrl) {
+        localSettings = localSettings.filter((s) => s.name !== "base_url");
+        localSettings.push({
+            name: "base_url",
+            //@ts-ignore
+            value: opts.baseUrl,
+        });
+    }
+    if (preview) {
+        return compareInstanceObjects(localSettings, remoteSettings, "name", "setting");
+    }
+    else {
+        for (const setting of localSettings) {
+            const remoteMatch = remoteSettings.find((s) => s.name === setting.name);
+            if (remoteMatch && deepEqual(remoteMatch, setting)) {
+                continue;
+            }
+            try {
+                await wmill.setGlobal({
+                    key: setting.name,
+                    requestBody: {
+                        value: setting.value,
+                    },
+                });
+            }
+            catch (err) {
+                log.error(`Failed to set setting ${setting.name}: ${err}`);
+            }
+        }
+        for (const remoteSetting of remoteSettings) {
+            const localMatch = localSettings.find((s) => s.name === remoteSetting.name);
+            if (!localMatch) {
+                try {
+                    await wmill.setGlobal({
+                        key: remoteSetting.name,
+                        requestBody: {
+                            value: null,
+                        },
+                    });
+                }
+                catch (err) {
+                    log.error(`Failed to delete setting ${remoteSetting.name}: ${err}`);
+                }
+            }
+        }
+        log.info(colors.green("Settings pushed to instance"));
+    }
+}
+export async function readLocalConfigs(opts) {
+    let localConfigs = [];
+    await checkInstanceConfigPath(opts);
+    try {
+        localConfigs = (await yamlParseFile(instanceConfigsPath));
+    }
+    catch {
+        log.warn(`No ${instanceConfigsPath} found`);
+    }
+    return localConfigs;
+}
+export async function pullInstanceConfigs(opts, preview = false) {
+    const remoteConfigs = (await wmill.listConfigs()).map((x) => {
+        return {
+            ...x,
+            name: removeWorkerPrefix(x.name),
+        };
+    });
+    if (preview) {
+        const localConfigs = await readLocalConfigs(opts);
+        return compareInstanceObjects(remoteConfigs, localConfigs, "name", "config");
+    }
+    else {
+        log.info("Pulling configs from instance");
+        await dntShim.Deno.writeTextFile(instanceConfigsPath, yamlStringify(remoteConfigs));
+        log.info(colors.green(`Configs written to ${instanceConfigsPath}`));
+    }
+}
+export async function pushInstanceConfigs(opts, preview = false) {
+    const remoteConfigs = (await wmill.listConfigs()).map((x) => {
+        return {
+            ...x,
+            name: removeWorkerPrefix(x.name),
+        };
+    });
+    const localConfigs = await readLocalConfigs(opts);
+    if (preview) {
+        return compareInstanceObjects(localConfigs, remoteConfigs, "name", "config");
+    }
+    else {
+        log.info("Pushing configs to instance");
+        for (const config of localConfigs) {
+            const remoteMatch = remoteConfigs.find((c) => c.name === config.name);
+            if (remoteMatch && deepEqual(remoteMatch, config)) {
+                continue;
+            }
+            try {
+                await wmill.updateConfig({
+                    name: config.name.startsWith("worker__")
+                        ? config.name
+                        : `worker__${config.name}`,
+                    requestBody: config.config,
+                });
+            }
+            catch (err) {
+                log.error(`Failed to set config ${config.name}: ${err}`);
+            }
+        }
+        for (const removeConfig of remoteConfigs) {
+            const localMatch = localConfigs.find((c) => c.name === removeConfig.name);
+            if (!localMatch) {
+                try {
+                    await wmill.deleteConfig({
+                        name: removeConfig.name,
+                    });
+                }
+                catch (err) {
+                    log.error(`Failed to delete config ${removeConfig.name}: ${err}`);
+                }
+            }
+        }
+        log.info(colors.green("Configs pushed to instance"));
+    }
+}

package/esm/src/core/store.js

@@ -0,0 +1,19 @@
+import { ensureDir } from "../../deps.js";
+import { getConfigDirPath } from "../../windmill-utils-internal/src/config/config.js";
+function hash_string(str) {
+    let hash = 0, i, chr;
+    if (str.length === 0)
+        return hash;
+    for (i = 0; i < str.length; i++) {
+        chr = str.charCodeAt(i);
+        hash = (hash << 5) - hash + chr;
+        hash |= 0; // Convert to 32bit integer
+    }
+    return hash;
+}
+export async function getStore(baseUrl, configDirOverride) {
+    const baseHash = Math.abs(hash_string(baseUrl)).toString(16);
+    const baseStore = (await getConfigDirPath(configDirOverride)) + baseHash + "/";
+    await ensureDir(baseStore);
+    return baseStore;
+}

package/esm/src/main.js

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+import "../_dnt.polyfills.js";
+import "../_dnt.polyfills.js";
+import * as dntShim from "../_dnt.shims.js";
+import { Command, CompletionsCommand, UpgradeCommand, esMain, log, } from "../deps.js";
+import flow from "./commands/flow/flow.js";
+import app from "./commands/app/apps.js";
+import script from "./commands/script/script.js";
+import workspace, { getActiveWorkspace, } from "./commands/workspace/workspace.js";
+import resource from "./commands/resource/resource.js";
+import resourceType from "./commands/resource-type/resource-type.js";
+import user from "./commands/user/user.js";
+import variable from "./commands/variable/variable.js";
+import hub from "./commands/hub/hub.js";
+import folder from "./commands/folder/folder.js";
+import schedule from "./commands/schedule/schedule.js";
+import trigger from "./commands/trigger/trigger.js";
+import sync from "./commands/sync/sync.js";
+import gitsyncSettings from "./commands/gitsync-settings/gitsync-settings.js";
+import instance from "./commands/instance/instance.js";
+import workerGroups from "./commands/worker-groups/worker_groups.js";
+import dev from "./commands/dev/dev.js";
+import { fetchVersion } from "./core/context.js";
+import { OpenAPI } from "../gen/index.js";
+import { getHeaders, getIsWin } from "./utils/utils.js";
+import { setShowDiffs } from "./core/conf.js";
+import { NpmProvider } from "./utils/upgrade.js";
+import { pull as hubPull } from "./commands/hub/hub.js";
+import { pull, push } from "./commands/sync/sync.js";
+import { add as workspaceAdd } from "./commands/workspace/workspace.js";
+import workers from "./commands/workers/workers.js";
+import queues from "./commands/queues/queues.js";
+import init from "./commands/init/init.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) {
+//     console.error("Error details of: " + event.error.message);
+//     console.error(JSON.stringify(event.error, null, 4));
+//   }
+// });
+export const VERSION = "1.518.2";
+const command = new Command()
+    .name("wmill")
+    .action(() => log.info(`Welcome to Windmill CLI ${VERSION}. Use -h for help.`))
+    .description("Windmill CLI")
+    .globalOption("--workspace <workspace:string>", "Specify the target workspace. This overrides the default workspace.")
+    .globalOption("--debug --verbose", "Show debug/verbose logs")
+    .globalOption("--show-diffs", "Show diff informations when syncing (may show sensitive informations)")
+    .globalOption("--token <token:string>", "Specify an API token. This will override any stored token.")
+    .globalOption("--base-url <baseUrl:string>", "Specify the base URL of the API. If used, --token and --workspace are required and no local remote/workspace already set will be used.")
+    .globalOption("--config-dir <configDir:string>", "Specify a custom config directory. Overrides WMILL_CONFIG_DIR environment variable and default ~/.config location.")
+    .env("HEADERS <headers:string>", "Specify headers to use for all requests. e.g: \"HEADERS='h1: v1, h2: v2'\"")
+    .version(VERSION)
+    .versionOption(false)
+    .command("init", init)
+    .command("app", app)
+    .command("flow", flow)
+    .command("script", script)
+    .command("workspace", workspace)
+    .command("resource", resource)
+    .command("resource-type", resourceType)
+    .command("user", user)
+    .command("variable", variable)
+    .command("hub", hub)
+    .command("folder", folder)
+    .command("schedule", schedule)
+    .command("trigger", trigger)
+    .command("dev", dev)
+    .command("sync", sync)
+    .command("gitsync-settings", gitsyncSettings)
+    .command("instance", instance)
+    .command("worker-groups", workerGroups)
+    .command("workers", workers)
+    .command("queues", queues)
+    .command("version --version", "Show version information")
+    .action(async (opts) => {
+    console.log("CLI version: " + VERSION);
+    try {
+        const provider = new NpmProvider({ package: "windmill-cli" });
+        const versions = await provider.getVersions("windmill-cli");
+        if (versions.latest !== VERSION) {
+            console.log(`CLI is outdated. Latest version ${versions.latest} is available. Run \`wmill upgrade\` to update.`);
+        }
+        else {
+            console.log("CLI is up to date");
+        }
+    }
+    catch (e) {
+        console.warn(`Cannot fetch latest CLI version on npmjs to check if up-to-date: ${e}`);
+    }
+    const workspace = await getActiveWorkspace(opts);
+    if (workspace) {
+        try {
+            const backendVersion = await fetchVersion(workspace.remote);
+            console.log("Backend Version: " + backendVersion);
+        }
+        catch (e) {
+            console.warn("Cannot fetch backend version: " + e);
+        }
+    }
+    else {
+        console.warn("Cannot fetch backend version: no active workspace selected, choose one to pick a remote to fetch version of");
+    }
+})
+    .command("upgrade", new UpgradeCommand({
+    provider: new NpmProvider({ package: "windmill-cli" }),
+}).error((e) => {
+    log.error(e);
+    log.info("Try running with sudo and otherwise check the result of the command: npm uninstall windmill-cli && npm install -g windmill-cli");
+}))
+    .command("completions", new CompletionsCommand());
+async function main() {
+    try {
+        if (dntShim.Deno.args.length === 0) {
+            command.showHelp();
+        }
+        const LOG_LEVEL = dntShim.Deno.args.includes("--verbose") || dntShim.Deno.args.includes("--debug")
+            ? "DEBUG"
+            : "INFO";
+        // const NO_COLORS = Deno.args.includes("--no-colors");
+        setShowDiffs(dntShim.Deno.args.includes("--show-diffs"));
+        const isWin = await getIsWin();
+        log.setup({
+            handlers: {
+                console: new log.ConsoleHandler(LOG_LEVEL, {
+                    formatter: ({ msg }) => `${msg}`,
+                    useColors: isWin ? false : true,
+                }),
+            },
+            loggers: {
+                default: {
+                    level: LOG_LEVEL,
+                    handlers: ["console"],
+                },
+            },
+        });
+        log.debug("Debug logging enabled. CLI build against " + VERSION);
+        const extraHeaders = getHeaders();
+        if (extraHeaders) {
+            OpenAPI.HEADERS = extraHeaders;
+        }
+        await command.parse(dntShim.Deno.args);
+    }
+    catch (e) {
+        if (e && typeof e === "object" && "name" in e && e.name === "ApiError") {
+            console.log("Server failed. " + e.statusText + ": " + e.body);
+        }
+        throw e;
+    }
+}
+function isMain() {
+    // dnt-shim-ignore
+    const { Deno } = globalThis;
+    const isDeno = Deno != undefined;
+    if (isDeno) {
+        const isMain = (import.meta.url === ("file:///" + process.argv[1].replace(/\\/g, "/")).replace(/\/{3,}/, "///"));
+        if (isMain) {
+            if (!Deno.args.includes("completions")) {
+                if (Deno.env.get("SKIP_DENO_DEPRECATION_WARNING") !== "true") {
+                    log.warn("Using the deno runtime for the Windmill CLI is deprecated, you can now use node: deno uninstall wmill && npm install -g windmill-cli. To skip this warning set SKIP_DENO_DEPRECATION_WARNING=true");
+                }
+            }
+        }
+        return isMain;
+    }
+    else {
+        //@ts-ignore
+        return esMain.default(import.meta);
+    }
+}
+if (isMain()) {
+    main();
+}
+export default command;