windmill-cli 1.518.1 → 1.518.3

package/esm/src/core/branch-profiles.js

@@ -0,0 +1,46 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { log } from "../../deps.js";
+import { getStore } from "./store.js";
+const BRANCH_PROFILES_FILE = "branch-profiles.json";
+export async function getBranchProfilesPath(configDirOverride) {
+    return (await getStore("", configDirOverride)) + BRANCH_PROFILES_FILE;
+}
+export async function loadBranchProfiles(configDirOverride) {
+    try {
+        const path = await getBranchProfilesPath(configDirOverride);
+        const content = await dntShim.Deno.readTextFile(path);
+        return JSON.parse(content);
+    }
+    catch {
+        // File doesn't exist or invalid JSON - return empty mapping
+        return { lastUsed: {} };
+    }
+}
+export async function saveBranchProfiles(mapping, configDirOverride) {
+    const path = await getBranchProfilesPath(configDirOverride);
+    await dntShim.Deno.writeTextFile(path, JSON.stringify(mapping, null, 2));
+}
+export function getBranchProfileKey(branch, baseUrl, workspaceId) {
+    // Normalize baseUrl to ensure consistency
+    let normalizedUrl;
+    try {
+        normalizedUrl = new URL(baseUrl).toString();
+    }
+    catch {
+        // Fallback to non-normalized URL if parsing fails
+        normalizedUrl = baseUrl;
+    }
+    return `${branch}|${normalizedUrl}|${workspaceId}`;
+}
+export async function getLastUsedProfile(branch, baseUrl, workspaceId, configDirOverride) {
+    const mapping = await loadBranchProfiles(configDirOverride);
+    const key = getBranchProfileKey(branch, baseUrl, workspaceId);
+    return mapping.lastUsed[key];
+}
+export async function setLastUsedProfile(branch, baseUrl, workspaceId, profileName, configDirOverride) {
+    const mapping = await loadBranchProfiles(configDirOverride);
+    const key = getBranchProfileKey(branch, baseUrl, workspaceId);
+    mapping.lastUsed[key] = profileName;
+    await saveBranchProfiles(mapping, configDirOverride);
+    log.debug(`Saved last used profile for ${key}: ${profileName}`);
+}

package/esm/src/core/conf.js

@@ -0,0 +1,162 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { log, yamlParseFile, Confirm, yamlStringify } from "../../deps.js";
+import { getCurrentGitBranch, isGitRepository } from "../utils/git.js";
+export let showDiffs = false;
+export function setShowDiffs(value) {
+    showDiffs = value;
+}
+export async function readConfigFile() {
+    try {
+        const conf = (await yamlParseFile("wmill.yaml"));
+        // Handle obsolete overrides format
+        if (conf && 'overrides' in conf) {
+            const overrides = conf.overrides;
+            const hasSettings = overrides && typeof overrides === 'object' && Object.keys(overrides).length > 0;
+            if (hasSettings) {
+                throw new Error("❌ The 'overrides' field is no longer supported.\n" +
+                    "   The configuration system now uses Git branch-based configuration only.\n" +
+                    "   Please delete your wmill.yaml and run 'wmill init' to recreate it with the new format.");
+            }
+            else {
+                // Remove empty overrides with a note
+                log.info("ℹ️  Removing empty 'overrides: {}' from wmill.yaml (migrated to git_branches format)");
+                delete conf.overrides;
+                // Write the updated config back to file
+                try {
+                    await dntShim.Deno.writeTextFile("wmill.yaml", yamlStringify(conf));
+                }
+                catch (error) {
+                    log.warn(`Could not update wmill.yaml to remove empty overrides: ${error instanceof Error ? error.message : error}`);
+                }
+            }
+        }
+        if (conf?.defaultTs == undefined) {
+            log.warn("No defaultTs defined in your wmill.yaml. Using 'bun' as default.");
+        }
+        return typeof conf == "object" ? conf : {};
+    }
+    catch (e) {
+        if (e instanceof Error && (e.message.includes("overrides") || e.message.includes("Obsolete configuration format"))) {
+            throw e; // Re-throw the specific obsolete format error
+        }
+        log.warn("No wmill.yaml found. Use 'wmill init' to bootstrap it. Using 'bun' as default typescript runtime.");
+        return {};
+    }
+}
+// Default sync options - shared across the codebase to prevent duplication
+export const DEFAULT_SYNC_OPTIONS = {
+    defaultTs: 'bun',
+    includes: ['f/**'],
+    excludes: [],
+    codebases: [],
+    skipVariables: false,
+    skipResources: false,
+    skipResourceTypes: false,
+    skipSecrets: true,
+    skipScripts: false,
+    skipFlows: false,
+    skipApps: false,
+    skipFolders: false,
+    includeSchedules: false,
+    includeTriggers: false,
+    includeUsers: false,
+    includeGroups: false,
+    includeSettings: false,
+    includeKey: false
+};
+export async function mergeConfigWithConfigFile(opts) {
+    const configFile = await readConfigFile();
+    return Object.assign(configFile ?? {}, opts);
+}
+// Validate branch configuration early in the process
+export async function validateBranchConfiguration(skipValidation, autoAccept) {
+    if (skipValidation || !isGitRepository()) {
+        return;
+    }
+    const config = await readConfigFile();
+    const { git_branches } = config;
+    const currentBranch = getCurrentGitBranch();
+    // In a git repository, git_branches section is recommended
+    if (!git_branches || Object.keys(git_branches).length === 0) {
+        log.warn("⚠️  WARNING: In a Git repository, the 'git_branches' section is recommended in wmill.yaml.\n" +
+            "   Consider adding a git_branches section with configuration for your Git branches.\n" +
+            "   Run 'wmill init' to recreate the configuration file with proper branch setup.");
+        return;
+    }
+    // Current branch must be defined in git_branches config
+    if (currentBranch && !git_branches[currentBranch]) {
+        // In interactive mode, offer to create the branch
+        if (dntShim.Deno.stdin.isTerminal()) {
+            const availableBranches = Object.keys(git_branches).join(', ');
+            log.info(`Current Git branch '${currentBranch}' is not defined in the git_branches configuration.\n` +
+                `Available branches: ${availableBranches}`);
+            const shouldCreate = autoAccept || await Confirm.prompt({
+                message: `Create empty branch configuration for '${currentBranch}'?`,
+                default: true,
+            });
+            if (shouldCreate) {
+                // Read current config, add branch, and write it back
+                const currentConfig = await readConfigFile();
+                if (!currentConfig.git_branches) {
+                    currentConfig.git_branches = {};
+                }
+                currentConfig.git_branches[currentBranch] = { overrides: {} };
+                await dntShim.Deno.writeTextFile("wmill.yaml", yamlStringify(currentConfig));
+                log.info(`✅ Created empty branch configuration for '${currentBranch}'`);
+            }
+            else {
+                log.warn("⚠️  WARNING: Branch creation cancelled. You can manually add the branch to wmill.yaml or use 'wmill gitsync-settings pull' to pull configuration from an existing windmill workspace git-sync configuration.");
+                return;
+            }
+        }
+        else {
+            log.warn(`⚠️  WARNING: Current Git branch '${currentBranch}' is not defined in the git_branches configuration.\n` +
+                `   Consider adding configuration for branch '${currentBranch}' in the git_branches section of wmill.yaml.\n` +
+                `   Available branches: ${Object.keys(git_branches).join(', ')}`);
+            return;
+        }
+    }
+}
+// Get effective settings by merging top-level settings with branch-specific overrides
+export async function getEffectiveSettings(config, promotion, skipBranchValidation, suppressLogs) {
+    // Start with top-level settings from config
+    const { git_branches, ...topLevelSettings } = config;
+    let effective = { ...topLevelSettings };
+    if (isGitRepository()) {
+        const currentBranch = getCurrentGitBranch();
+        // If promotion is specified, use that branch's promotionOverrides or overrides
+        if (promotion && git_branches && git_branches[promotion]) {
+            const targetBranch = git_branches[promotion];
+            // First try promotionOverrides, then fall back to overrides
+            if (targetBranch.promotionOverrides) {
+                Object.assign(effective, targetBranch.promotionOverrides);
+                if (!suppressLogs) {
+                    log.info(`Applied promotion settings from branch: ${promotion}`);
+                }
+            }
+            else if (targetBranch.overrides) {
+                Object.assign(effective, targetBranch.overrides);
+                if (!suppressLogs) {
+                    log.info(`Applied settings from branch: ${promotion} (no promotionOverrides found)`);
+                }
+            }
+            else {
+                log.debug(`No promotion or regular overrides found for branch '${promotion}', using top-level settings`);
+            }
+        }
+        // Otherwise use current branch overrides (existing behavior)
+        else if (currentBranch && git_branches && git_branches[currentBranch] && git_branches[currentBranch].overrides) {
+            Object.assign(effective, git_branches[currentBranch].overrides);
+            if (!suppressLogs) {
+                log.info(`Applied settings for Git branch: ${currentBranch}`);
+            }
+        }
+        else if (currentBranch) {
+            log.debug(`No branch-specific overrides found for '${currentBranch}', using top-level settings`);
+        }
+    }
+    else {
+        log.debug("Not in a Git repository, using top-level settings");
+    }
+    return effective;
+}

package/esm/src/core/context.js

@@ -0,0 +1,263 @@
+// deno-lint-ignore-file no-explicit-any
+import * as dntShim from "../../_dnt.shims.js";
+import { colors, log, Select, Confirm, Input } from "../../deps.js";
+import { loginInteractive } from "./login.js";
+import { getHeaders } from "../utils/utils.js";
+import { getActiveWorkspace, getWorkspaceByName, allWorkspaces, addWorkspace, } from "../commands/workspace/workspace.js";
+import { getLastUsedProfile, setLastUsedProfile } from "./branch-profiles.js";
+import { readConfigFile } from "./conf.js";
+import { getCurrentGitBranch, isGitRepository } from "../utils/git.js";
+// Helper function to select from multiple matching profiles
+async function selectFromMultipleProfiles(profiles, baseUrl, workspaceId, context, configDir) {
+    if (profiles.length === 1) {
+        return profiles[0];
+    }
+    // Check for last used profile
+    const lastUsedProfileName = await getLastUsedProfile("", baseUrl, workspaceId, configDir);
+    if (lastUsedProfileName) {
+        const lastUsedProfile = profiles.find(p => p.name === lastUsedProfileName);
+        if (lastUsedProfile) {
+            log.info(colors.green(`Using last used profile '${lastUsedProfile.name}' for ${context}`));
+            return lastUsedProfile;
+        }
+    }
+    // No last used or it no longer exists - prompt for selection
+    if (!dntShim.Deno.stdin.isTerminal() || !dntShim.Deno.stdout.isTerminal()) {
+        const selectedProfile = profiles[0];
+        log.info(colors.yellow(`Multiple profiles found for ${context}. Using first available profile: '${selectedProfile.name}'`));
+        // Save selection for next time
+        await setLastUsedProfile("", // No branch context for general workspace selection
+        baseUrl, workspaceId, selectedProfile.name, configDir);
+        return selectedProfile;
+    }
+    log.info(colors.yellow(`\nMultiple workspace profiles found for ${context}:`));
+    const selectedName = await Select.prompt({
+        message: "Select profile",
+        options: profiles.map(p => ({
+            name: `${p.name} (${p.workspaceId} on ${p.remote})`,
+            value: p.name,
+        })),
+    });
+    const selectedProfile = profiles.find(p => p.name === selectedName);
+    // Save selection for next time
+    await setLastUsedProfile("", // No branch context for general workspace selection
+    baseUrl, workspaceId, selectedProfile.name, configDir);
+    return selectedProfile;
+}
+async function tryResolveWorkspace(opts) {
+    const cache = opts.__secret_workspace;
+    if (cache)
+        return { isError: false, value: cache };
+    if (opts.workspace) {
+        const e = await getWorkspaceByName(opts.workspace, opts.configDir);
+        if (!e) {
+            return {
+                isError: true,
+                error: colors.red.underline("Given workspace does not exist."),
+            };
+        }
+        opts.__secret_workspace = e;
+        return { isError: false, value: e };
+    }
+    const defaultWorkspace = await getActiveWorkspace(opts);
+    if (!defaultWorkspace) {
+        return {
+            isError: true,
+            error: colors.red.underline("No workspace given and no default set."),
+        };
+    }
+    return { isError: false, value: defaultWorkspace };
+}
+async function tryResolveBranchWorkspace(opts) {
+    // Only try branch-based resolution if in a Git repository
+    if (!isGitRepository()) {
+        return undefined;
+    }
+    const currentBranch = getCurrentGitBranch();
+    if (!currentBranch) {
+        return undefined;
+    }
+    // Read wmill.yaml to check for branch workspace configuration
+    const config = await readConfigFile();
+    const branchConfig = config.git_branches?.[currentBranch];
+    // Check if branch has workspace configuration
+    if (!branchConfig?.baseUrl || !branchConfig?.workspaceId) {
+        return undefined;
+    }
+    const { baseUrl, workspaceId } = branchConfig;
+    let normalizedBaseUrl;
+    try {
+        normalizedBaseUrl = new URL(baseUrl).toString();
+    }
+    catch (error) {
+        log.error(colors.red(`Invalid baseUrl in branch configuration: ${baseUrl}`));
+        return undefined;
+    }
+    // Find all profiles matching this baseUrl and workspaceId
+    const allProfiles = await allWorkspaces(opts.configDir);
+    const matchingProfiles = allProfiles.filter(w => w.remote === normalizedBaseUrl && w.workspaceId === workspaceId);
+    if (matchingProfiles.length === 0) {
+        // No matching profile exists - prompt to create one
+        log.info(colors.yellow(`\nNo workspace profile found for branch '${currentBranch}'\n` +
+            `(${normalizedBaseUrl}, ${workspaceId})`));
+        if (!dntShim.Deno.stdin.isTerminal() || !dntShim.Deno.stdout.isTerminal()) {
+            log.info("Not a TTY, cannot create profile interactively. Use 'wmill workspace add' first.");
+            return undefined;
+        }
+        const shouldCreate = await Confirm.prompt({
+            message: "Would you like to create a new profile?",
+            default: true,
+        });
+        if (!shouldCreate) {
+            return undefined;
+        }
+        // Prompt for profile details
+        const profileName = await Input.prompt({
+            message: "Profile name",
+            default: workspaceId,
+        });
+        const token = await loginInteractive(normalizedBaseUrl);
+        if (!token) {
+            log.error("Failed to obtain token");
+            return undefined;
+        }
+        // Create the new profile
+        const newWorkspace = {
+            name: profileName,
+            remote: normalizedBaseUrl,
+            workspaceId: workspaceId,
+            token: token,
+        };
+        await addWorkspace(newWorkspace, opts);
+        // Set as last used for this branch
+        await setLastUsedProfile(currentBranch, normalizedBaseUrl, workspaceId, profileName, opts.configDir);
+        log.info(colors.green(`✓ Created profile '${profileName}' for ${workspaceId} on ${normalizedBaseUrl}`));
+        log.info(colors.green(`✓ Profile '${profileName}' is now active`));
+        return newWorkspace;
+    }
+    // Handle multiple profiles - use special branch-aware logic
+    let selectedProfile;
+    if (matchingProfiles.length === 1) {
+        selectedProfile = matchingProfiles[0];
+        log.info(colors.green(`Using workspace profile '${selectedProfile.name}' for branch '${currentBranch}'`));
+    }
+    else {
+        // For multiple profiles, check branch-specific last used first
+        const lastUsedName = await getLastUsedProfile(currentBranch, normalizedBaseUrl, workspaceId, opts.configDir);
+        if (lastUsedName) {
+            const lastUsedProfile = matchingProfiles.find(p => p.name === lastUsedName);
+            if (lastUsedProfile) {
+                log.info(colors.green(`Using workspace profile '${lastUsedProfile.name}' for branch '${currentBranch}' (last used)`));
+                return lastUsedProfile;
+            }
+        }
+        // Fall back to general selection logic
+        selectedProfile = await selectFromMultipleProfiles(matchingProfiles, normalizedBaseUrl, workspaceId, `branch '${currentBranch}'`, opts.configDir);
+        // Save branch-specific selection
+        await setLastUsedProfile(currentBranch, normalizedBaseUrl, workspaceId, selectedProfile.name, opts.configDir);
+        log.info(colors.green(`Using workspace profile '${selectedProfile.name}' for branch '${currentBranch}'`));
+    }
+    return selectedProfile;
+}
+export async function resolveWorkspace(opts) {
+    if (opts.baseUrl) {
+        if (opts.workspace && opts.token) {
+            let normalizedBaseUrl;
+            try {
+                normalizedBaseUrl = new URL(opts.baseUrl).toString(); // add trailing slash if not present
+            }
+            catch (error) {
+                log.info(colors.red(`Invalid base URL: ${opts.baseUrl}`));
+                return dntShim.Deno.exit(-1);
+            }
+            // Try to find existing workspace profile by name, then by workspaceId + remote
+            if (opts.workspace) {
+                // Try by workspace name first
+                let existingWorkspace = await getWorkspaceByName(opts.workspace, opts.configDir);
+                // If not found by name, try to find by workspaceId + remote match
+                if (!existingWorkspace) {
+                    const { allWorkspaces } = await import("../commands/workspace/workspace.js");
+                    const workspaces = await allWorkspaces(opts.configDir);
+                    const matchingWorkspaces = workspaces.filter(w => w.workspaceId === opts.workspace && w.remote === normalizedBaseUrl);
+                    if (matchingWorkspaces.length >= 1) {
+                        existingWorkspace = await selectFromMultipleProfiles(matchingWorkspaces, normalizedBaseUrl, opts.workspace, `workspace "${opts.workspace}" on ${normalizedBaseUrl}`, opts.configDir);
+                    }
+                }
+                if (existingWorkspace) {
+                    // Validate that the base URL matches the profile's remote
+                    if (existingWorkspace.remote !== normalizedBaseUrl) {
+                        log.info(colors.red(`Base URL mismatch: --base-url is ${normalizedBaseUrl} but workspace profile "${opts.workspace}" uses ${existingWorkspace.remote}`));
+                        return dntShim.Deno.exit(-1);
+                    }
+                    // Use the existing workspace profile (preserves workspace name)
+                    return {
+                        ...existingWorkspace,
+                        token: opts.token, // Use the provided token
+                    };
+                }
+            }
+            // No existing profile found, create temporary workspace
+            return {
+                remote: normalizedBaseUrl,
+                workspaceId: opts.workspace,
+                name: opts.workspace,
+                token: opts.token,
+            };
+        }
+        else {
+            log.info(colors.red("If you specify a base URL with --base-url, you must also specify a workspace (--workspace) and token (--token)."));
+            return dntShim.Deno.exit(-1);
+        }
+    }
+    // Try explicit workspace flag first (should override branch-based resolution)
+    const res = await tryResolveWorkspace(opts);
+    if (!res.isError) {
+        return res.value;
+    }
+    // Fall back to branch-based resolution if no explicit workspace
+    const branchWorkspace = await tryResolveBranchWorkspace(opts);
+    if (branchWorkspace) {
+        return branchWorkspace;
+    }
+    // If both failed, show the original error from explicit workspace resolution
+    log.info(colors.red.bold(res.error));
+    return dntShim.Deno.exit(-1);
+}
+export async function fetchVersion(baseUrl) {
+    const requestHeaders = new Headers();
+    const extraHeaders = getHeaders();
+    if (extraHeaders) {
+        for (const [key, value] of Object.entries(extraHeaders)) {
+            requestHeaders.set(key, value);
+        }
+    }
+    const response = await fetch(new URL(new URL(baseUrl).origin + "/api/version"), { headers: requestHeaders, method: "GET" });
+    if (!response.ok) {
+        // Consume response body even on error to avoid resource leak
+        await response.text();
+        throw new Error(`Failed to fetch version: ${response.status} ${response.statusText}`);
+    }
+    return await response.text();
+}
+export async function tryResolveVersion(opts) {
+    if (opts.__cache_version) {
+        return opts.__cache_version;
+    }
+    const workspaceRes = await tryResolveWorkspace(opts);
+    if (workspaceRes.isError)
+        return undefined;
+    const version = await fetchVersion(workspaceRes.value.remote);
+    try {
+        return Number.parseInt(version.split("-", 1)[0].replaceAll(".", "").replace("v", ""));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function validatePath(path) {
+    if (!(path.startsWith("g") || path.startsWith("u") || path.startsWith("f"))) {
+        log.info(colors.red("Given remote path looks invalid. Remote paths are typically of the form <u|g|f>/<username|group|folder>/..."));
+        return false;
+    }
+    return true;
+}

package/esm/src/core/login.js

@@ -0,0 +1,100 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { colors, getPort, log, open, Secret, Select } from "../../deps.js";
+import * as http from "node:http";
+export async function loginInteractive(remote) {
+    let token;
+    if (dntShim.Deno.stdin.isTerminal && !dntShim.Deno.stdin.isTerminal()) {
+        log.info("Not a TTY, can't login interactively.");
+        return undefined;
+    }
+    if ((await Select.prompt({
+        message: "How do you want to login",
+        options: [
+            {
+                name: "Browser",
+                value: "b",
+            },
+            {
+                name: "Token",
+                value: "t",
+            },
+        ],
+    })) === "b") {
+        token = await browserLogin(remote);
+    }
+    else {
+        token = await Secret.prompt("Enter your token");
+    }
+    return token;
+}
+// deno-lint-ignore require-await
+export async function tryGetLoginInfo(opts) {
+    if (opts.token) {
+        return opts.token;
+    }
+    return undefined;
+}
+export async function browserLogin(baseUrl) {
+    const env = dntShim.Deno.env.get("TOKEN_PORT") != undefined
+        ? parseInt(dntShim.Deno.env.get("TOKEN_PORT"))
+        : undefined;
+    const port = await getPort.default({ port: env });
+    if (port == undefined) {
+        log.info(colors.red.underline("failed to aquire port"));
+        return undefined;
+    }
+    // const server = Deno.listen({ transport: "tcp", port });
+    // const url = `${baseUrl}user/cli?port=${port}`;
+    // log.info(`Login by going to ${url}`);
+    // try {
+    //   await open.openApp(open.apps.browser, { arguments: [url] });
+    //   log.info("Opened browser for you");
+    // } catch {
+    //   console.error(`Failed to open browser, please navigate to ${url}`);
+    // }
+    // const firstConnection = await server.accept();
+    // const httpFirstConnection = Deno.serveHttp(firstConnection);
+    // const firstRequest = (await httpFirstConnection.nextRequest())!;
+    // const params = new URL(firstRequest.request.url!).searchParams;
+    // const token = params.get("token");
+    // // const _workspace = params.get("workspace");
+    // await firstRequest?.respondWith(
+    //   Response.redirect(baseUrl + "user/cli-success", 302)
+    // );
+    // setTimeout(() => {
+    //   httpFirstConnection.close();
+    //   server.close();
+    // }, 10);
+    // return token ?? undefined;
+    return new Promise((resolve) => {
+        const server = http.createServer((req, res) => {
+            const params = new URL(req.url, `http://${req.headers.host}`)
+                .searchParams;
+            const token = params.get("token");
+            // Redirect the user to the success page
+            res.writeHead(302, { Location: `${baseUrl}user/cli-success` });
+            res.end();
+            // Close the server after a short delay
+            setTimeout(() => {
+                server.close();
+            }, 10);
+            // Resolve the promise with the token
+            resolve(token ?? undefined);
+        });
+        const url = `${baseUrl}user/cli?port=${port}`;
+        log.info(`Login by going to ${url}`);
+        try {
+            open.openApp(open.apps.browser, { arguments: [url] }).catch((error) => {
+                console.error(`Failed to open browser, please navigate to ${url}, error: ${error}`);
+            });
+            log.info("Opened browser for you");
+        }
+        catch (error) {
+            console.error(`Failed to open browser, please navigate to ${url}, error: ${error}`);
+        }
+        // Start the server
+        server.listen(port, () => {
+            console.log(`Listening on port ${port}`);
+        });
+    });
+}