windmill-cli 1.641.0 → 1.643.0

package/esm/src/core/conf.js

@@ -1,335 +0,0 @@
-import * as dntShim from "../../_dnt.shims.js";
-import { log, yamlParseFile, Confirm, yamlStringify } from "../../deps.js";
-import { getCurrentGitBranch, getOriginalBranchForWorkspaceForks, isGitRepository, } from "../utils/git.js";
-import { join, dirname, resolve, relative } from "node:path";
-import { existsSync } from "node:fs";
-import { execSync } from "node:child_process";
-import { setNonDottedPaths } from "../utils/resource_folders.js";
-export let showDiffs = false;
-export function setShowDiffs(value) {
-    showDiffs = value;
-}
-function getGitRepoRoot() {
-    try {
-        const result = execSync("git rev-parse --show-toplevel", {
-            encoding: "utf8",
-            stdio: "pipe",
-        });
-        return result.trim();
-    }
-    catch (error) {
-        return null;
-    }
-}
-export const GLOBAL_CONFIG_OPT = { noCdToRoot: false };
-function findWmillYaml() {
-    const startDir = resolve(dntShim.Deno.cwd());
-    const isInGitRepo = isGitRepository();
-    const gitRoot = isInGitRepo ? getGitRepoRoot() : null;
-    let currentDir = startDir;
-    let foundPath = null;
-    // Search upward for wmill.yaml until we find it, reach git root, or reach filesystem root
-    while (true) {
-        const wmillYamlPath = join(currentDir, "wmill.yaml");
-        if (existsSync(wmillYamlPath)) {
-            foundPath = wmillYamlPath;
-            break;
-        }
-        // Check if we've reached the git repository root
-        if (gitRoot && resolve(currentDir) === resolve(gitRoot)) {
-            break;
-        }
-        // Check if we've reached the filesystem root
-        const parentDir = dirname(currentDir);
-        if (parentDir === currentDir) {
-            break;
-        }
-        currentDir = parentDir;
-    }
-    // If wmill.yaml was found in a parent directory, warn the user and change working directory
-    if (!GLOBAL_CONFIG_OPT.noCdToRoot &&
-        foundPath &&
-        resolve(dirname(foundPath)) !== resolve(startDir)) {
-        const configDir = dirname(foundPath);
-        const relativePath = relative(startDir, foundPath);
-        log.warn(`⚠️  wmill.yaml found in parent directory: ${relativePath}`);
-        // Change working directory to where wmill.yaml was found
-        dntShim.Deno.chdir(configDir);
-        log.info(`📁 Changed working directory to: ${configDir}`);
-    }
-    return foundPath;
-}
-export function getWmillYamlPath() {
-    return findWmillYaml();
-}
-export async function readConfigFile() {
-    try {
-        // First, try to find wmill.yaml recursively
-        const wmillYamlPath = findWmillYaml();
-        if (!wmillYamlPath) {
-            log.warn("No wmill.yaml found. Use 'wmill init' to bootstrap it. Using 'bun' as default typescript runtime.");
-            return {};
-        }
-        const conf = (await yamlParseFile(wmillYamlPath));
-        // Handle legacy format migrations (combine overrides and git_branches)
-        let needsConfigWrite = false;
-        const migrationMessages = [];
-        // 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
-                delete conf.overrides;
-                needsConfigWrite = true;
-                migrationMessages.push("ℹ️  Removing empty 'overrides: {}' from wmill.yaml (migrated to gitBranches format)");
-            }
-        }
-        // Handle git_branches to gitBranches migration
-        if (conf && "git_branches" in conf) {
-            if (!conf.gitBranches) {
-                // Deep copy git_branches to gitBranches (even if empty)
-                conf.gitBranches = JSON.parse(JSON.stringify(conf.git_branches));
-                needsConfigWrite = true;
-                migrationMessages.push("⚠️  Migrating 'git_branches' to 'gitBranches' (camelCase). The snake_case format is deprecated.");
-                migrationMessages.push("✅ Successfully migrated 'git_branches' to 'gitBranches' in wmill.yaml");
-            }
-            else {
-                migrationMessages.push("⚠️  Both 'git_branches' and 'gitBranches' found in wmill.yaml. Using 'gitBranches' and ignoring 'git_branches'.");
-            }
-            // Always remove the old field from config object (both file and memory)
-            delete conf.git_branches;
-        }
-        // Perform single atomic write if any migrations are needed
-        if (needsConfigWrite) {
-            try {
-                await dntShim.Deno.writeTextFile(wmillYamlPath, yamlStringify(conf));
-                // Log all migration messages after successful write
-                migrationMessages.forEach((msg) => {
-                    if (msg.startsWith("⚠️")) {
-                        log.warn(msg);
-                    }
-                    else {
-                        log.info(msg);
-                    }
-                });
-            }
-            catch (error) {
-                log.warn(`Could not update wmill.yaml to apply migrations: ${error instanceof Error ? error.message : error}`);
-            }
-        }
-        else if (migrationMessages.length > 0) {
-            // Log messages for non-write cases (like "both found")
-            migrationMessages.forEach((msg) => {
-                if (msg.startsWith("⚠️")) {
-                    log.warn(msg);
-                }
-                else {
-                    log.info(msg);
-                }
-            });
-        }
-        if (conf?.defaultTs == undefined) {
-            log.warn("No defaultTs defined in your wmill.yaml. Using 'bun' as default.");
-        }
-        // Initialize global nonDottedPaths setting from config
-        setNonDottedPaths(conf?.nonDottedPaths ?? false);
-        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
-        }
-        // Since we already found the file path, this is likely a parsing or access error
-        if (e instanceof Error && e.message.includes("Error parsing yaml")) {
-            const yamlError = e.cause instanceof Error ? e.cause.message : String(e.cause);
-            throw new Error("❌ YAML syntax error in wmill.yaml:\n" +
-                "   " +
-                yamlError +
-                "\n" +
-                "   Please fix the YAML syntax in wmill.yaml or delete the file to start fresh.");
-        }
-        else {
-            // File exists but has other issues (permissions, etc.)
-            throw new Error("❌ Failed to read wmill.yaml:\n" +
-                "   " +
-                (e instanceof Error ? e.message : String(e)) +
-                "\n" +
-                "   Please check file permissions or fix the syntax.");
-        }
-    }
-}
-// 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,
-    skipWorkspaceDependencies: false,
-    nonDottedPaths: 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(opts, branchOverride) {
-    // When branch override is provided, skip validation - user is explicitly specifying the branch
-    if (opts.skipBranchValidation || branchOverride || !isGitRepository()) {
-        return;
-    }
-    const config = await readConfigFile();
-    const { gitBranches } = config;
-    const rawBranch = getCurrentGitBranch();
-    const originalBranchIfForked = getOriginalBranchForWorkspaceForks(rawBranch);
-    let currentBranch;
-    if (originalBranchIfForked) {
-        log.info(`Workspace fork detected from branch name \`${rawBranch}\`. Validating branch configuration using original branch \`${originalBranchIfForked}\``);
-        currentBranch = originalBranchIfForked;
-    }
-    else {
-        currentBranch = rawBranch;
-    }
-    // In a git repository, gitBranches section is recommended
-    if (!gitBranches || Object.keys(gitBranches).length === 0) {
-        log.warn("⚠️  WARNING: In a Git repository, the 'gitBranches' section is recommended in wmill.yaml.\n" +
-            "   Consider adding a gitBranches 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 gitBranches config
-    if (currentBranch && !gitBranches[currentBranch]) {
-        // In interactive mode, offer to create the branch
-        if (dntShim.Deno.stdin.isTerminal()) {
-            const availableBranches = Object.keys(gitBranches).join(", ");
-            log.info(`Current Git branch '${currentBranch}' is not defined in the gitBranches configuration.\n` +
-                `Available branches: ${availableBranches}`);
-            const shouldCreate = opts.yes ||
-                (await Confirm.prompt({
-                    message: `Create empty branch configuration for '${currentBranch}'?`,
-                    default: true,
-                }));
-            if (shouldCreate) {
-                // Warn if branch name contains filesystem-unsafe characters
-                if (/[\/\\:*?"<>|.]/.test(currentBranch)) {
-                    const sanitizedBranchName = currentBranch.replace(/[\/\\:*?"<>|.]/g, "_");
-                    log.warn(`⚠️  WARNING: Branch name "${currentBranch}" contains filesystem-unsafe characters (/ \\ : * ? " < > | .).`);
-                    log.warn(`   Branch-specific files will be saved with sanitized name: "${sanitizedBranchName}"`);
-                    log.warn(`   Example: "file.variable.yaml" → "file.${sanitizedBranchName}.variable.yaml"`);
-                }
-                // Read current config, add branch, and write it back
-                const currentConfig = await readConfigFile();
-                if (!currentConfig.gitBranches) {
-                    currentConfig.gitBranches = {};
-                }
-                currentConfig.gitBranches[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 {
-            // Warn about filesystem-unsafe characters in branch name
-            if (/[\/\\:*?"<>|.]/.test(currentBranch)) {
-                const sanitizedBranchName = currentBranch.replace(/[\/\\:*?"<>|.]/g, "_");
-                log.warn(`⚠️  WARNING: Branch name "${currentBranch}" contains filesystem-unsafe characters (/ \\ : * ? " < > | .).`);
-                log.warn(`   Branch-specific files will use sanitized name: "${sanitizedBranchName}"`);
-            }
-            log.warn(`⚠️  WARNING: Current Git branch '${currentBranch}' is not defined in the gitBranches configuration.\n` +
-                `   Consider adding configuration for branch '${currentBranch}' in the gitBranches section of wmill.yaml.\n` +
-                `   Available branches: ${Object.keys(gitBranches).join(", ")}`);
-            return;
-        }
-    }
-}
-// Get effective settings by merging top-level settings with branch-specific overrides
-export async function getEffectiveSettings(config, promotion, skipBranchValidation, suppressLogs, branchOverride) {
-    // Start with top-level settings from config
-    const { gitBranches, ...topLevelSettings } = config;
-    const effective = { ...topLevelSettings };
-    // Determine the branch to use: branchOverride takes precedence, then git detection
-    let currentBranch = null;
-    let originalBranchIfForked = null;
-    let rawGitBranch = null;
-    if (branchOverride) {
-        currentBranch = branchOverride;
-        // Note: "Using branch override" is logged in context.ts when resolving workspace
-    }
-    else if (isGitRepository()) {
-        rawGitBranch = getCurrentGitBranch();
-        originalBranchIfForked = getOriginalBranchForWorkspaceForks(rawGitBranch);
-        if (originalBranchIfForked) {
-            log.info(`Using overrides from original branch \`${originalBranchIfForked}\``);
-            currentBranch = originalBranchIfForked;
-        }
-        else {
-            currentBranch = rawGitBranch;
-        }
-    }
-    else {
-        log.debug("Not in a Git repository and no branch override provided, using top-level settings");
-    }
-    // If promotion is specified, use that branch's promotionOverrides or overrides
-    if (promotion && gitBranches && gitBranches[promotion]) {
-        const targetBranch = gitBranches[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 &&
-        gitBranches &&
-        gitBranches[currentBranch] &&
-        gitBranches[currentBranch].overrides) {
-        Object.assign(effective, gitBranches[currentBranch].overrides);
-        if (!suppressLogs) {
-            const extraLog = originalBranchIfForked
-                ? ` (because it is the origin of the workspace fork branch \`${rawGitBranch}\`)`
-                : "";
-            log.info(`Applied settings for Git branch: ${currentBranch}${extraLog}`);
-        }
-    }
-    else if (currentBranch) {
-        log.debug(`No branch-specific overrides found for '${currentBranch}', using top-level settings`);
-    }
-    return effective;
-}

package/esm/src/core/constants.js

@@ -1,5 +0,0 @@
-/**
- * Shared constants used across the CLI.
- * This file should have minimal imports to avoid circular dependencies.
- */
-export const WM_FORK_PREFIX = "wm-fork";

package/esm/src/core/context.js

@@ -1,326 +0,0 @@
-// 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, getOriginalBranchForWorkspaceForks, getWorkspaceIdForWorkspaceForkFromBranchName, isGitRepository, } from "../utils/git.js";
-import { WM_FORK_PREFIX } from "./constants.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;
-}
-/**
- * Prompts the user to create a new workspace profile interactively
- */
-async function createWorkspaceProfileInteractively(normalizedBaseUrl, workspaceId, currentBranch, opts, context) {
-    // Log appropriate message based on context
-    if (!context.isForked) {
-        log.info(colors.yellow(`\nNo workspace profile found for branch '${context.rawBranch}'\n` +
-            `(${normalizedBaseUrl}, ${workspaceId})`));
-    }
-    else {
-        log.info(colors.yellow(`\nNo workspace profile was found for this forked workspace\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 workspace 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;
-}
-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 };
-    }
-    // Only check for explicit workspace, don't fallback to active workspace here
-    return {
-        isError: true,
-        error: colors.red.underline("No explicit workspace given."),
-    };
-}
-export async function tryResolveBranchWorkspace(opts, branchOverride) {
-    let rawBranch = null;
-    let currentBranch;
-    let originalBranchIfForked = null;
-    let workspaceIdIfForked = null;
-    if (branchOverride) {
-        // Use branch override directly
-        currentBranch = branchOverride;
-        log.info(`Using branch override: ${branchOverride}`);
-    }
-    else {
-        // Only try branch-based resolution if in a Git repository
-        if (!isGitRepository()) {
-            return undefined;
-        }
-        rawBranch = getCurrentGitBranch();
-        if (!rawBranch) {
-            return undefined;
-        }
-        originalBranchIfForked = getOriginalBranchForWorkspaceForks(rawBranch);
-        workspaceIdIfForked =
-            getWorkspaceIdForWorkspaceForkFromBranchName(rawBranch);
-        if (originalBranchIfForked) {
-            log.info(`Using original branch \`${originalBranchIfForked}\` for finding workspace profile from gitBranches section in wmill.yaml`);
-            currentBranch = originalBranchIfForked;
-        }
-        else {
-            currentBranch = rawBranch;
-        }
-    }
-    // Read wmill.yaml to check for branch workspace configuration
-    const config = await readConfigFile();
-    const branchConfig = config.gitBranches?.[currentBranch];
-    // Check if branch has workspace configuration
-    if (!branchConfig?.baseUrl || !branchConfig?.workspaceId) {
-        return undefined;
-    }
-    log.info(`Using branch configuration for branch \`${currentBranch}\` set in gitBranches`);
-    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
-        return await createWorkspaceProfileInteractively(normalizedBaseUrl, workspaceId, currentBranch, opts, { rawBranch: rawBranch ?? currentBranch, isForked: !!originalBranchIfForked });
-    }
-    // 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}' with workspace id \`${workspaceId}\``));
-    }
-    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}'`));
-    }
-    if (workspaceIdIfForked) {
-        selectedProfile.name = `${selectedProfile.name}/${workspaceIdIfForked}`;
-        selectedProfile.workspaceId = workspaceIdIfForked;
-        log.info(`Inferred workspace id \`${workspaceId}\` from branch name because this is a workspace fork branch (\`${rawBranch}\`). `);
-    }
-    return selectedProfile;
-}
-export async function resolveWorkspace(opts, branchOverride) {
-    const cache = opts.__secret_workspace;
-    if (cache)
-        return cache;
-    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);
-        }
-    }
-    const branch = branchOverride ?? getCurrentGitBranch();
-    // Try explicit workspace flag first (should override branch-based resolution). Unless it's a
-    // forked workspace, that we detect through the branch name (only when not using branchOverride)
-    const res = await tryResolveWorkspace(opts);
-    if (!res.isError) {
-        if (branchOverride || !branch || !branch.startsWith(WM_FORK_PREFIX)) {
-            return res.value;
-        }
-        else {
-            log.info(`Found an active workspace \`${res.value.name}\` but the branch name indicates this is a forked workspace. Ignoring active workspace and trying to resolve the correct workspace from the branch name \`${branch}\``);
-        }
-    }
-    // Try branch-based resolution (medium priority)
-    const branchWorkspace = await tryResolveBranchWorkspace(opts, branchOverride);
-    if (branchWorkspace) {
-        opts.__secret_workspace = branchWorkspace;
-        return branchWorkspace;
-    }
-    else if (!branchOverride) {
-        // Only check for fork errors when not using branchOverride
-        const originalBranch = getOriginalBranchForWorkspaceForks(branch);
-        if (originalBranch) {
-            log.error(colors.red.bold(`Failed to resolve workspace profile for workspace fork. This most likely means that the original branch \`${originalBranch}\` where \`${branch}\` is originally forked from, is not setup in the wmill.yaml. You need to update the \`gitBranches\` section for \`${originalBranch}\` to include workspaceId and baseUrl.`));
-            return dntShim.Deno.exit(-1);
-        }
-    }
-    // Fall back to active workspace (lowest priority)
-    const activeWorkspace = await getActiveWorkspace(opts);
-    if (activeWorkspace) {
-        opts.__secret_workspace = activeWorkspace;
-        return activeWorkspace;
-    }
-    // If everything failed, show error
-    log.info(colors.red.bold("No workspace given and no default set."));
-    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;
-}