windmill-cli 1.518.2 → 1.518.3

package/esm/src/commands/variable/variable.js

@@ -0,0 +1,121 @@
+// deno-lint-ignore-file no-explicit-any
+import * as dntShim from "../../../_dnt.shims.js";
+import { requireLogin } from "../../core/auth.js";
+import { resolveWorkspace, validatePath } from "../../core/context.js";
+import { isSuperset, parseFromFile, removeType, } from "../../types.js";
+import { colors, Command, Confirm, log, SEP, Table } from "../../../deps.js";
+import * as wmill from "../../../gen/services.gen.js";
+async function list(opts) {
+    const workspace = await resolveWorkspace(opts);
+    await requireLogin(opts);
+    const variables = await wmill.listVariable({
+        workspace: workspace.workspaceId,
+    });
+    new Table()
+        .header(["Path", "Is Secret", "Account", "Value"])
+        .padding(2)
+        .border(true)
+        .body(variables.map((x) => [
+        x.path,
+        x.is_secret ? "true" : "false",
+        x.account ?? "-",
+        x.value ?? "-",
+    ]))
+        .render();
+}
+export async function pushVariable(workspace, remotePath, variable, localVariable, plainSecrets) {
+    remotePath = removeType(remotePath, "variable");
+    log.debug(`Processing local variable ${remotePath}`);
+    try {
+        variable = await wmill.getVariable({
+            workspace: workspace,
+            path: remotePath.replaceAll(SEP, "/"),
+            decryptSecret: plainSecrets,
+            includeEncrypted: true,
+        });
+        log.debug(`Variable ${remotePath} exists on remote`);
+    }
+    catch {
+        log.debug(`Variable ${remotePath} does not exist on remote`);
+    }
+    if (variable) {
+        if (isSuperset(localVariable, variable)) {
+            log.debug(`Variable ${remotePath} is up-to-date`);
+            return;
+        }
+        log.debug(`Variable ${remotePath} is not up-to-date, updating`);
+        await wmill.updateVariable({
+            workspace,
+            path: remotePath.replaceAll(SEP, "/"),
+            alreadyEncrypted: !plainSecrets,
+            requestBody: {
+                ...localVariable,
+                is_secret: localVariable.is_secret && !variable.is_secret ? true : undefined,
+            },
+        });
+    }
+    else {
+        log.info(colors.yellow.bold(`Creating new variable ${remotePath}...`));
+        await wmill.createVariable({
+            workspace,
+            alreadyEncrypted: !plainSecrets,
+            requestBody: {
+                path: remotePath.replaceAll(SEP, "/"),
+                ...localVariable,
+            },
+        });
+    }
+}
+async function push(opts, filePath, remotePath) {
+    const workspace = await resolveWorkspace(opts);
+    await requireLogin(opts);
+    if (!validatePath(remotePath)) {
+        return;
+    }
+    const fstat = await dntShim.Deno.stat(filePath);
+    if (!fstat.isFile) {
+        throw new Error("file path must refer to a file.");
+    }
+    log.info(colors.bold.yellow("Pushing variable..."));
+    await pushVariable(workspace.workspaceId, remotePath, undefined, parseFromFile(filePath), opts.plainSecrets ?? false);
+    log.info(colors.bold.underline.green(`Variable ${remotePath} pushed`));
+}
+async function add(opts, value, remotePath) {
+    const workspace = await resolveWorkspace(opts);
+    await requireLogin(opts);
+    if (!validatePath(remotePath)) {
+        return;
+    }
+    if (await wmill.existsVariable({
+        workspace: workspace.workspaceId,
+        path: remotePath,
+    })) {
+        if (!(await Confirm.prompt({
+            message: `Variable already exist, do you want to update its value?`,
+            default: true,
+        }))) {
+            return;
+        }
+        log.info(colors.bold.yellow("Updating variable..."));
+    }
+    log.info(colors.bold.yellow("Pushing variable..."));
+    await pushVariable(workspace.workspaceId, remotePath + ".variable.yaml", undefined, {
+        value,
+        is_secret: !opts.public && !opts.plainSecrets,
+        description: "",
+    }, opts.plainSecrets ?? false);
+    log.info(colors.bold.underline.green(`Variable ${remotePath} pushed`));
+}
+const command = new Command()
+    .description("variable related commands")
+    .action(list)
+    .command("push", "Push a local variable spec. This overrides any remote versions.")
+    .arguments("<file_path:string> <remote_path:string>")
+    .option("--plain-secrets", "Push secrets as plain text")
+    .action(push)
+    .command("add", "Create a new variable on the remote. This will update the variable if it already exists.")
+    .arguments("<value:string> <remote_path:string>")
+    .option("--plain-secrets", "Push secrets as plain text")
+    .option("--public", "Legacy option, use --plain-secrets instead")
+    .action(add);
+export default command;

package/esm/src/commands/worker-groups/worker_groups.js

@@ -0,0 +1,96 @@
+import { Command, Confirm, setClient, Table } from "../../../deps.js";
+import { log } from "../../../deps.js";
+import { allInstances, getActiveInstance, pickInstance } from "../instance/instance.js";
+import * as wmill from "../../../gen/services.gen.js";
+import { pullInstanceConfigs, pushInstanceConfigs } from "../../core/settings.js";
+export async function getInstance(opts) {
+    const instances = await allInstances();
+    const instanceName = await getActiveInstance(opts);
+    const instance = instances.find((i) => i.name === instanceName);
+    if (instance) {
+        setClient(instance.token, instance.remote.slice(0, instance.remote.length - 1));
+    }
+    return instance;
+}
+export function removeWorkerPrefix(name) {
+    if (name.startsWith("worker__")) {
+        return name.substring(8);
+    }
+    return name;
+}
+export async function displayWorkerGroups(opts) {
+    log.info("2 actions available, pull and push.");
+    const activeInstance = await getActiveInstance({});
+    if (activeInstance) {
+        log.info("Active instance: " + activeInstance);
+        const instance = await getInstance({});
+        if (instance) {
+            const wGroups = await wmill.listWorkerGroups();
+            new Table()
+                .header(["name", "config"])
+                .padding(2)
+                .border(true)
+                .body(wGroups.map((x) => [removeWorkerPrefix(x.name), JSON.stringify(x.config, null, 2)]))
+                .render();
+        }
+        else {
+            log.error(`Instance ${activeInstance} not found`);
+        }
+    }
+    else {
+        log.info("No active instance found");
+        log.info("Use 'wmill instance add' to add a new instance");
+    }
+}
+async function pullWorkerGroups(opts) {
+    await pickInstance(opts, true);
+    const totalChanges = await pullInstanceConfigs(opts, true) ?? 0;
+    if (totalChanges === 0) {
+        log.info("No changes to apply");
+        return;
+    }
+    let confirm = true;
+    if (opts.yes !== true) {
+        confirm = await Confirm.prompt({
+            message: `Do you want to pul these ${totalChanges} instance-level changes?`,
+            default: true,
+        });
+    }
+    if (confirm) {
+        await pullInstanceConfigs(opts, false);
+    }
+}
+async function pushWorkerGroups(opts) {
+    await pickInstance(opts, true);
+    const totalChanges = await pushInstanceConfigs(opts, true) ?? 0;
+    if (totalChanges === 0) {
+        log.info("No changes to apply");
+        return;
+    }
+    let confirm = true;
+    if (opts.yes !== true) {
+        confirm = await Confirm.prompt({
+            message: `Do you want to apply these ${totalChanges} instance-level changes?`,
+            default: true,
+        });
+    }
+    if (confirm) {
+        await pushInstanceConfigs(opts, false);
+    }
+}
+const command = new Command()
+    .description("display worker groups, pull and push worker groups configs")
+    .action(displayWorkerGroups)
+    .command("pull")
+    .description("Pull worker groups (similar to `wmill instance pull --skip-users --skip-settings --skip-groups`)")
+    .option("--instance", "Name of the instance to push to, override the active instance")
+    .option("--base-url", "Base url to be passed to the instance settings instead of the local one")
+    .option("--yes", "Pull without needing confirmation")
+    .action(pullWorkerGroups)
+    .command("push")
+    .description("Push instance settings, users, configs, group and overwrite remote")
+    .option("--instance [instance]", "Name of the instance to push to, override the active instance")
+    .option("--base-url [baseUrl]", "If used with --token, will be used as the base url for the instance")
+    .option("--yes", "Push without needing confirmation")
+    .action(pushWorkerGroups);
+export default command;

package/esm/src/commands/workers/workers.js

@@ -0,0 +1,79 @@
+import { Command, Table } from "../../../deps.js";
+import { log } from "../../../deps.js";
+import * as wmill from "../../../gen/services.gen.js";
+import { pickInstance } from "../instance/instance.js";
+function toPercent(value) {
+    return value != undefined ? `${(value * 100).toFixed(1)}%` : '?%';
+}
+async function displayWorkers(opts) {
+    const activeInstance = await pickInstance(opts, true);
+    if (activeInstance) {
+        const workerGroups = await wmill.listWorkerGroups();
+        const workers = await wmill.listWorkers({
+            pingSince: 10
+        });
+        const groupedWorkers = workerGroups.map(group => {
+            const groupWorkers = workers.filter(worker => worker.worker_group === group.name);
+            return {
+                groupName: group.name,
+                workers: groupWorkers
+            };
+        });
+        // Add workers that don't belong to any worker group
+        const ungroupedWorkers = workers.filter(worker => !workerGroups.some(group => group.name === worker.worker_group));
+        if (ungroupedWorkers.length > 0) {
+            ungroupedWorkers.forEach(worker => {
+                const groupName = worker.worker_group || "Ungrouped";
+                let group = groupedWorkers.find(g => g.groupName === groupName);
+                if (!group) {
+                    group = { groupName, workers: [] };
+                    groupedWorkers.push(group);
+                }
+                group.workers.push(worker);
+            });
+        }
+        // Sort groupedWorkers
+        groupedWorkers.sort((a, b) => {
+            // Always put 'default' first
+            if (a.groupName === 'default')
+                return -1;
+            if (b.groupName === 'default')
+                return 1;
+            // Then sort by number of workers (descending order)
+            return b.workers.length - a.workers.length;
+        });
+        groupedWorkers.forEach(group => {
+            log.info(`\nWorker Group: ${group.groupName} (${group.workers.length} workers)`);
+            if (group.workers.length === 0) {
+                log.info("  No workers in this group");
+            }
+            else {
+                new Table()
+                    .header(["Worker ID", "Host", "Queues", "Jobs", "Occupancy rate 15s/5m/30m/ever)", "Last job", "Last Ping"])
+                    .padding(2)
+                    .border(true)
+                    .maxColWidth(30)
+                    .body(group.workers.map(worker => [
+                    worker.worker,
+                    worker.worker_instance,
+                    worker.custom_tags?.join(', ') || '',
+                    worker.jobs_executed,
+                    `${toPercent(worker.occupancy_rate_15s)}/${toPercent(worker.occupancy_rate_5m)}/${toPercent(worker.occupancy_rate_30m)}/${toPercent(worker.occupancy_rate)}`,
+                    worker.last_job_id ? worker.last_job_id + ' ' + worker.last_job_workspace_id : '',
+                    `${worker.last_ping}s ago`
+                ]))
+                    .render();
+            }
+        });
+    }
+    else {
+        log.info("No active instance found");
+        log.info("Use 'wmill instance add' to add a new instance");
+    }
+}
+const command = new Command()
+    .description("List all workers grouped by worker groups")
+    .option("--instance [instance]", "Name of the instance to push to, override the active instance")
+    .option("--base-url [baseUrl]", "If used with --token, will be used as the base url for the instance")
+    .action(displayWorkers);
+export default command;

package/esm/src/commands/workspace/workspace.js

@@ -0,0 +1,348 @@
+// deno-lint-ignore-file no-explicit-any
+import * as dntShim from "../../../_dnt.shims.js";
+import { getActiveWorkspaceConfigFilePath, getWorkspaceConfigFilePath } from "../../../windmill-utils-internal/src/config/config.js";
+import { loginInteractive, tryGetLoginInfo } from "../../core/login.js";
+import { colors, Command, Confirm, Input, log, setClient, Table } from "../../../deps.js";
+import { requireLogin } from "../../core/auth.js";
+import * as wmill from "../../../gen/services.gen.js";
+export async function allWorkspaces(configDirOverride) {
+    try {
+        const file = await getWorkspaceConfigFilePath(configDirOverride);
+        const txt = await dntShim.Deno.readTextFile(file);
+        return txt
+            .split("\n")
+            .map((line) => {
+            if (line.length <= 2) {
+                return;
+            }
+            const instance = JSON.parse(line);
+            return instance;
+        })
+            .filter(Boolean);
+    }
+    catch (_) {
+        return [];
+    }
+}
+async function getActiveWorkspaceName(opts) {
+    if (opts?.workspace) {
+        return opts?.workspace;
+    }
+    try {
+        const file = await getActiveWorkspaceConfigFilePath(opts?.configDir);
+        return await dntShim.Deno.readTextFile(file);
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function getActiveWorkspace(opts = undefined) {
+    const name = await getActiveWorkspaceName(opts);
+    if (!name) {
+        return undefined;
+    }
+    return await getWorkspaceByName(name, opts?.configDir);
+}
+export async function getWorkspaceByName(workspaceName, configDirOverride) {
+    const workspaceStream = await allWorkspaces(configDirOverride);
+    for await (const workspace of workspaceStream) {
+        if (workspace.name === workspaceName) {
+            return workspace;
+        }
+    }
+    return undefined;
+}
+async function list(opts) {
+    const workspaces = await allWorkspaces(opts.configDir);
+    const activeName = await getActiveWorkspaceName(opts);
+    new Table()
+        .header(["name", "remote", "workspace id"])
+        .padding(2)
+        .border(true)
+        .body(workspaces.map((x) => {
+        const a = [x.name, x.remote, x.workspaceId];
+        if (x.name === activeName) {
+            return a.map((x) => colors.underline(x));
+        }
+        else {
+            return a;
+        }
+    }))
+        .render();
+    log.info("Active: " + colors.green.bold(activeName || "none"));
+}
+async function switchC(opts, workspaceName) {
+    if (opts.workspace) {
+        log.info(colors.red.bold("! Workspace needs to be specified as positional argument, not as option."));
+        return;
+    }
+    const all = await allWorkspaces(opts.configDir);
+    if (all.findIndex((x) => x.name === workspaceName) === -1) {
+        log.info(colors.red.bold(`! This workspace profile ${workspaceName} does not exist locally.`));
+        log.info("available workspace profiles:");
+        for (const w of all) {
+            log.info("  - " + w.name);
+        }
+        return;
+    }
+    await setActiveWorkspace(workspaceName, opts.configDir);
+    return;
+}
+export async function setActiveWorkspace(workspaceName, configDirOverride) {
+    const file = await getActiveWorkspaceConfigFilePath(configDirOverride);
+    await dntShim.Deno.writeTextFile(file, workspaceName);
+}
+export async function add(opts, workspaceName, workspaceId, remote) {
+    if (opts.workspace) {
+        log.info(colors.red.bold("! Workspace needs to be specified as positional argument, not as option."));
+        return;
+    }
+    while (workspaceName === undefined) {
+        if (!workspaceName) {
+            workspaceName = await Input.prompt("Name this workspace:");
+        }
+    }
+    if (!workspaceId) {
+        workspaceId = await Input.prompt({
+            message: "Enter the ID of this workspace",
+            default: workspaceName,
+            suggestions: [workspaceName],
+        });
+    }
+    if (!remote) {
+        // first check whether workspaceId is actually a URL
+        try {
+            const url = new URL(workspaceId);
+            workspaceId = workspaceName;
+            remote = url.toString();
+        }
+        catch {
+            // not a url
+            remote = new URL(await Input.prompt({
+                message: "Enter the Remote URL",
+                suggestions: ["https://app.windmill.dev/"],
+                default: "https://app.windmill.dev/",
+            })).toString();
+        }
+    }
+    remote = new URL(remote).toString(); // add trailing slash in all cases!
+    let token = await tryGetLoginInfo(opts);
+    if (!token && dntShim.Deno.stdin.isTerminal && !dntShim.Deno.stdin.isTerminal()) {
+        log.info("Not a TTY, can't login interactively. Pass the token in --token");
+        return;
+    }
+    while (!token) {
+        token = await loginInteractive(remote);
+    }
+    setClient(token, remote.endsWith("/") ? remote.substring(0, remote.length - 1) : remote);
+    let alreadyExists = false;
+    try {
+        alreadyExists = await wmill.existsWorkspace({
+            requestBody: { id: workspaceId },
+        });
+    }
+    catch (e) {
+        log.info(colors.red.bold("! Credentials or instance is invalid. Aborting."));
+        throw e;
+    }
+    if (opts.create) {
+        if (!alreadyExists) {
+            log.info(colors.yellow(`Workspace at id ${workspaceId} on ${remote} does not exist. Creating...`));
+            const automateUsernameCreation = (await wmill.getGlobal({
+                key: "automate_username_creation",
+            })) ?? false;
+            await wmill.createWorkspace({
+                requestBody: {
+                    id: workspaceId,
+                    name: opts.createWorkspaceName ?? workspaceName,
+                    username: automateUsernameCreation ? undefined : opts.createUsername,
+                },
+            });
+        }
+    }
+    else if (!alreadyExists) {
+        log.info(colors.red.bold(`! Workspace at id ${workspaceId} on ${remote} does not exist. Re-run with --create to create it. Aborting.`));
+        log.info("On that instance and with those credentials, the workspaces that you can access are:");
+        const workspaces = await wmill.listWorkspaces();
+        for (const workspace of workspaces) {
+            log.info(`- ${workspace.id} (name: ${workspace.name})`);
+        }
+        dntShim.Deno.exit(1);
+    }
+    await addWorkspace({
+        name: workspaceName,
+        remote: remote,
+        workspaceId: workspaceId,
+        token: token,
+    }, opts);
+    await setActiveWorkspace(workspaceName, opts.configDir);
+    log.info(colors.green.underline(`Added workspace ${workspaceName} for ${workspaceId} on ${remote}!`));
+}
+export async function addWorkspace(workspace, opts) {
+    workspace.remote = new URL(workspace.remote).toString(); // add trailing slash in all cases!
+    // Check for conflicts before adding
+    const existingWorkspaces = await allWorkspaces(opts.configDir);
+    const isInteractive = dntShim.Deno.stdin.isTerminal() && dntShim.Deno.stdout.isTerminal() && !opts.force;
+    // Check 1: Workspace name already exists
+    const nameConflict = existingWorkspaces.find(w => w.name === workspace.name);
+    if (nameConflict) {
+        // If it's the exact same workspace (same remote + workspaceId), just update the token
+        if (nameConflict.remote === workspace.remote && nameConflict.workspaceId === workspace.workspaceId) {
+            log.info(colors.yellow(`Updating token for existing workspace "${workspace.name}"`));
+        }
+        else {
+            // Different remote or workspaceId - this is a conflict
+            log.info(colors.red.bold(`❌ Workspace name "${workspace.name}" already exists!`));
+            log.info(`   Existing: ${nameConflict.workspaceId} on ${nameConflict.remote}`);
+            log.info(`   New:      ${workspace.workspaceId} on ${workspace.remote}`);
+            if (!isInteractive) {
+                // In non-interactive mode (tests, scripts), auto-overwrite with force flag
+                if (opts.force) {
+                    log.info(colors.yellow("Force flag enabled, overwriting existing workspace."));
+                }
+                else {
+                    throw new Error("Workspace name conflict. Use --force to overwrite or choose a different name.");
+                }
+            }
+            else {
+                const overwrite = await Confirm.prompt({
+                    message: "Do you want to overwrite the existing workspace?",
+                    default: false,
+                });
+                if (!overwrite) {
+                    log.info(colors.yellow("Operation cancelled."));
+                    return;
+                }
+            }
+        }
+    }
+    // Remove existing workspace with same name (if updating)
+    await removeWorkspace(workspace.name, true, opts);
+    // Add the new workspace
+    const filePath = await getWorkspaceConfigFilePath(opts.configDir);
+    const file = await dntShim.Deno.open(filePath, {
+        append: true,
+        write: true,
+        read: true,
+        create: true,
+    });
+    await file.write(new TextEncoder().encode(JSON.stringify(workspace) + "\n"));
+    file.close();
+}
+export async function removeWorkspace(name, silent, opts) {
+    const orgWorkspaces = await allWorkspaces(opts.configDir);
+    if (orgWorkspaces.findIndex((x) => x.name === name) === -1) {
+        if (!silent) {
+            log.info(colors.red.bold(`! Workspace profile ${name} does not exist locally`));
+            log.info("available workspace profiles:");
+            await list(opts);
+        }
+        return;
+    }
+    if (!silent) {
+        log.info(colors.yellow(`Removing existing workspace ${name}`));
+    }
+    const filePath = await getWorkspaceConfigFilePath(opts.configDir);
+    await dntShim.Deno.writeTextFile(filePath, orgWorkspaces
+        .filter((x) => x.name !== name)
+        .map((x) => JSON.stringify(x))
+        .join("\n") + "\n");
+    if (!silent) {
+        log.info(colors.green.underline(`Succesfully removed workspace ${name}!`));
+    }
+}
+async function remove(_opts, name) {
+    await removeWorkspace(name, false, _opts);
+}
+async function whoami(_opts) {
+    await requireLogin(_opts);
+    log.info(await wmill.globalWhoami());
+    const activeName = await getActiveWorkspaceName(_opts);
+    log.info("Active: " + colors.green.bold(activeName || "none"));
+}
+async function bind(opts, bindWorkspace) {
+    const { isGitRepository, getCurrentGitBranch } = await import("../../utils/git.js");
+    if (!isGitRepository()) {
+        log.error(colors.red("Not in a Git repository"));
+        return;
+    }
+    const branch = opts.branch || getCurrentGitBranch();
+    if (!branch) {
+        log.error(colors.red("Could not determine current Git branch"));
+        return;
+    }
+    const { readConfigFile } = await import("../../core/conf.js");
+    const config = await readConfigFile();
+    const activeWorkspace = await getActiveWorkspace(opts);
+    if (!activeWorkspace && bindWorkspace) {
+        log.error(colors.red("No active workspace. Use 'wmill workspace add' or 'wmill workspace switch' first"));
+        return;
+    }
+    // For unbind, check if branch exists
+    if (!bindWorkspace && (!config.git_branches || !config.git_branches[branch])) {
+        log.error(colors.red(`Branch '${branch}' not found in wmill.yaml git_branches`));
+        return;
+    }
+    // Update the branch configuration with workspace binding
+    if (!config.git_branches) {
+        config.git_branches = {};
+    }
+    if (!config.git_branches[branch]) {
+        config.git_branches[branch] = { overrides: {} };
+    }
+    if (bindWorkspace && activeWorkspace) {
+        config.git_branches[branch].baseUrl = activeWorkspace.remote;
+        config.git_branches[branch].workspaceId = activeWorkspace.workspaceId;
+        log.info(colors.green(`✓ Bound branch '${branch}' to workspace '${activeWorkspace.name}'\n` +
+            `  ${activeWorkspace.workspaceId} on ${activeWorkspace.remote}`));
+    }
+    else {
+        // Unbind
+        delete config.git_branches[branch].baseUrl;
+        delete config.git_branches[branch].workspaceId;
+        log.info(colors.green(`✓ Removed workspace binding from branch '${branch}'`));
+    }
+    // Write back the updated config
+    const { yamlStringify } = await import("../../../deps.js");
+    try {
+        await dntShim.Deno.writeTextFile("wmill.yaml", yamlStringify(config));
+    }
+    catch (error) {
+        log.error(colors.red(`Failed to save configuration: ${error.message}`));
+        return;
+    }
+}
+const command = new Command()
+    .alias("profile")
+    .description("workspace related commands")
+    .action(list)
+    .command("switch")
+    .complete("workspace", async () => (await allWorkspaces()).map((x) => x.name))
+    .description("Switch to another workspace")
+    .arguments("<workspace_name:string:workspace>")
+    .action(switchC)
+    .command("add")
+    .description("Add a workspace")
+    .arguments("[workspace_name:string] [workspace_id:string] [remote:string]")
+    .option("-c --create", "Create the workspace if it does not exist")
+    .option("--create-workspace-name <workspace_name:string>", "Specify the workspace name. Ignored if --create is not specified or the workspace already exists. Will default to the workspace id.")
+    .option("--create-username <username:string>", "Specify your own username in the newly created workspace. Ignored if --create is not specified, the workspace already exists or automatic username creation is enabled on the instance.", {
+    default: "admin",
+})
+    .action(add)
+    .command("remove")
+    .description("Remove a workspace")
+    .arguments("<workspace_name:string>")
+    .action(remove)
+    .command("whoami")
+    .description("Show the currently active user")
+    .action(whoami)
+    .command("bind")
+    .description("Bind the current Git branch to the active workspace")
+    .option("--branch <branch:string>", "Specify branch (defaults to current)")
+    .action((opts) => bind(opts, true))
+    .command("unbind")
+    .description("Remove workspace binding from the current Git branch")
+    .option("--branch <branch:string>", "Specify branch (defaults to current)")
+    .action((opts) => bind(opts, false));
+export default command;

package/esm/src/core/auth.js

@@ -0,0 +1,40 @@
+// deno-lint-ignore-file no-explicit-any
+import { log, setClient } from "../../deps.js";
+import * as wmill from "../../gen/services.gen.js";
+import { loginInteractive, tryGetLoginInfo } from "./login.js";
+/**
+ * Main authentication function - moved from context.ts to break circular dependencies
+ * This function maintains the original API signature from context.ts
+ */
+export async function requireLogin(opts) {
+    // Import resolveWorkspace to avoid circular dependency at module level
+    const { resolveWorkspace } = await import("./context.js");
+    const workspace = await resolveWorkspace(opts);
+    let token = await tryGetLoginInfo(opts);
+    if (!token) {
+        token = workspace.token;
+    }
+    setClient(token, workspace.remote.substring(0, workspace.remote.length - 1));
+    try {
+        return await wmill.globalWhoami();
+    }
+    catch (error) {
+        // Check for network errors and provide clearer messages
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        if (errorMsg.includes('fetch') || errorMsg.includes('connection') || errorMsg.includes('ECONNREFUSED') || errorMsg.includes('refused')) {
+            throw new Error(`Network error: Could not connect to Windmill server at ${workspace.remote}`);
+        }
+        log.info("! Could not reach API given existing credentials. Attempting to reauth...");
+        const newToken = await loginInteractive(workspace.remote);
+        if (!newToken) {
+            throw new Error("Unauthorized: Could not authenticate with the provided credentials");
+        }
+        // Update workspace token
+        const { removeWorkspace, addWorkspace } = await import("../commands/workspace/workspace.js");
+        removeWorkspace(workspace.name, false, opts);
+        workspace.token = newToken;
+        addWorkspace(workspace, opts);
+        setClient(newToken, workspace.remote.substring(0, workspace.remote.length - 1));
+        return await wmill.globalWhoami();
+    }
+}