windmill-cli 1.518.2 → 1.518.3

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

@@ -0,0 +1,236 @@
+// deno-lint-ignore-file no-explicit-any
+import * as dntShim from "../../../_dnt.shims.js";
+import { isSuperset } from "../../types.js";
+import { Confirm, SEP, log, yamlStringify } from "../../../deps.js";
+import { colors, Command, Table, yamlParseFile } from "../../../deps.js";
+import * as wmill from "../../../gen/services.gen.js";
+import { requireLogin } from "../../core/auth.js";
+import { resolveWorkspace, validatePath } from "../../core/context.js";
+import { resolve, track_job } from "../script/script.js";
+import { defaultFlowDefinition } from "../../../bootstrap/flow_bootstrap.js";
+import { generateFlowLockInternal } from "../../utils/metadata.js";
+import { mergeConfigWithConfigFile } from "../../core/conf.js";
+import { FSFSElement, elementsToMap, ignoreF } from "../sync/sync.js";
+import { replaceInlineScripts } from "../../../windmill-utils-internal/src/inline-scripts/replacer.js";
+const alreadySynced = [];
+export async function pushFlow(workspace, remotePath, localPath, message) {
+    if (alreadySynced.includes(localPath)) {
+        return;
+    }
+    alreadySynced.push(localPath);
+    remotePath = remotePath.replaceAll(SEP, "/");
+    let flow = undefined;
+    try {
+        flow = await wmill.getFlowByPath({
+            workspace: workspace,
+            path: remotePath,
+        });
+    }
+    catch {
+        // flow doesn't exist
+    }
+    if (!localPath.endsWith(SEP)) {
+        localPath += SEP;
+    }
+    const localFlow = (await yamlParseFile(localPath + "flow.yaml"));
+    await replaceInlineScripts(localFlow.value.modules, async (path) => await dntShim.Deno.readTextFile(localPath + path), log, localPath, SEP);
+    if (flow) {
+        if (isSuperset(localFlow, flow)) {
+            log.info(colors.green(`Flow ${remotePath} is up to date`));
+            return;
+        }
+        log.info(colors.bold.yellow(`Updating flow ${remotePath}...`));
+        await wmill.updateFlow({
+            workspace: workspace,
+            path: remotePath.replaceAll(SEP, "/"),
+            requestBody: {
+                path: remotePath.replaceAll(SEP, "/"),
+                deployment_message: message,
+                ...localFlow,
+            },
+        });
+    }
+    else {
+        log.info(colors.bold.yellow("Creating new flow..."));
+        try {
+            await wmill.createFlow({
+                workspace: workspace,
+                requestBody: {
+                    path: remotePath.replaceAll(SEP, "/"),
+                    deployment_message: message,
+                    ...localFlow,
+                },
+            });
+        }
+        catch (e) {
+            throw new Error(
+            //@ts-ignore
+            `Failed to create flow ${remotePath}: ${e.body ?? e.message}`);
+        }
+    }
+}
+async function push(opts, filePath, remotePath) {
+    if (!validatePath(remotePath)) {
+        return;
+    }
+    const workspace = await resolveWorkspace(opts);
+    await requireLogin(opts);
+    await pushFlow(workspace.workspaceId, remotePath, filePath);
+    log.info(colors.bold.underline.green("Flow pushed"));
+}
+async function list(opts) {
+    const workspace = await resolveWorkspace(opts);
+    await requireLogin(opts);
+    let page = 0;
+    const perPage = 10;
+    const total = [];
+    while (true) {
+        const res = await wmill.listFlows({
+            workspace: workspace.workspaceId,
+            page,
+            perPage,
+            showArchived: opts.showArchived ?? false,
+            includeDraftOnly: opts.includeDraftOnly ?? false,
+        });
+        page += 1;
+        total.push(...res);
+        if (res.length < perPage) {
+            break;
+        }
+    }
+    new Table()
+        .header(["path", "summary", "edited by"])
+        .padding(2)
+        .border(true)
+        .body(total.map((x) => [x.path, x.summary, x.edited_by]))
+        .render();
+}
+async function run(opts, path) {
+    const workspace = await resolveWorkspace(opts);
+    await requireLogin(opts);
+    const input = opts.data ? await resolve(opts.data) : {};
+    const id = await wmill.runFlowByPath({
+        workspace: workspace.workspaceId,
+        path,
+        requestBody: input,
+    });
+    let i = 0;
+    while (true) {
+        const jobInfo = await wmill.getJob({
+            workspace: workspace.workspaceId,
+            id,
+        });
+        if (jobInfo.flow_status.modules.length <= i) {
+            break;
+        }
+        const module = jobInfo.flow_status.modules[i];
+        if (module.job) {
+            if (!opts.silent) {
+                log.info("====== Job " + (i + 1) + " ======");
+                await track_job(workspace.workspaceId, module.job);
+            }
+        }
+        else {
+            if (!opts.silent) {
+                log.info(module.type);
+            }
+            await new Promise((resolve, _) => setTimeout(() => resolve(undefined), 100));
+            continue;
+        }
+        i++;
+    }
+    if (!opts.silent) {
+        log.info(colors.green.underline.bold("Flow ran to completion"));
+        log.info("\n");
+    }
+    const jobInfo = await wmill.getCompletedJob({
+        workspace: workspace.workspaceId,
+        id,
+    });
+    log.info(jobInfo.result ?? {});
+}
+async function generateLocks(opts, folder) {
+    const useRawReqs = opts.useRawRequirements || dntShim.Deno.env.get("USE_RAW_REQUIREMENTS") === "true";
+    const workspace = await resolveWorkspace(opts);
+    await requireLogin(opts);
+    opts = await mergeConfigWithConfigFile(opts);
+    if (folder) {
+        // read script metadata file
+        await generateFlowLockInternal(folder, false, workspace, opts, undefined, undefined, useRawReqs);
+    }
+    else {
+        const ignore = await ignoreF(opts);
+        const elems = Object.keys(await elementsToMap(await FSFSElement(dntShim.Deno.cwd(), [], true), (p, isD) => {
+            return (ignore(p, isD) ||
+                (!isD &&
+                    !p.endsWith(SEP + "flow.yaml") &&
+                    !p.endsWith(SEP + "flow.json")));
+        }, false, {})).map((x) => x.substring(0, x.lastIndexOf(SEP)));
+        let hasAny = false;
+        for (const folder of elems) {
+            const candidate = await generateFlowLockInternal(folder, true, workspace, opts, undefined, undefined, useRawReqs);
+            if (candidate) {
+                hasAny = true;
+                log.info(colors.green(`+ ${candidate}`));
+            }
+        }
+        if (hasAny) {
+            if (!opts.yes &&
+                !(await Confirm.prompt({
+                    message: "Update the locks of the inline scripts of the above flows?",
+                    default: true,
+                }))) {
+                return;
+            }
+        }
+        else {
+            log.info(colors.green.bold("No locks to update"));
+            return;
+        }
+        for (const folder of elems) {
+            await generateFlowLockInternal(folder, false, workspace, opts, undefined, undefined, useRawReqs);
+        }
+    }
+}
+export function bootstrap(opts, flowPath) {
+    if (!validatePath(flowPath)) {
+        return;
+    }
+    const flowDirFullPath = `${flowPath}.flow`;
+    dntShim.Deno.mkdirSync(flowDirFullPath, { recursive: false });
+    const newFlowDefinition = defaultFlowDefinition();
+    if (opts.summary !== undefined) {
+        newFlowDefinition.summary = opts.summary;
+    }
+    if (opts.description !== undefined) {
+        newFlowDefinition.description = opts.description;
+    }
+    const newFlowDefinitionYaml = yamlStringify(newFlowDefinition);
+    const flowYamlPath = `${flowDirFullPath}/flow.yaml`;
+    dntShim.Deno.writeTextFile(flowYamlPath, newFlowDefinitionYaml, { createNew: true });
+}
+const command = new Command()
+    .description("flow related commands")
+    .option("--show-archived", "Enable archived scripts in output")
+    .action(list)
+    .command("push", "push a local flow spec. This overrides any remote versions.")
+    .arguments("<file_path:string> <remote_path:string>")
+    .action(push)
+    .command("run", "run a flow by path.")
+    .arguments("<path:string>")
+    .option("-d --data <data:string>", "Inputs specified as a JSON string or a file using @<filename> or stdin using @-.")
+    .option("-s --silent", "Do not ouput anything other then the final output. Useful for scripting.")
+    .action(run)
+    .command("generate-locks", "re-generate the lock files of all inline scripts of all updated flows")
+    .arguments("[flow:file]")
+    .option("--yes", "Skip confirmation prompt")
+    .option("-r --use-raw-requirements", "Use raw requirements (requirements.txt, go.mod, package.json, etc) instead of generating them on the server (can also be set with USE_RAW_REQUIREMENTS=true environment variable)")
+    .option("-i --includes <patterns:file[]>", "Comma separated patterns to specify which file to take into account (among files that are compatible with windmill). Patterns can include * (any string until '/') and ** (any string)")
+    .option("-e --excludes <patterns:file[]>", "Comma separated patterns to specify which file to NOT take into account.")
+    .action(generateLocks)
+    .command("bootstrap", "create a new empty flow")
+    .arguments("<flow_path:string>")
+    .option("--summary <summary:string>", "script summary")
+    .option("--description <description:string>", "script description")
+    .action(bootstrap);
+export default command;

package/esm/src/commands/folder/folder.js

@@ -0,0 +1,101 @@
+// deno-lint-ignore-file no-explicit-any
+import * as dntShim from "../../../_dnt.shims.js";
+import { colors, Command, log, SEP, Table } from "../../../deps.js";
+import * as wmill from "../../../gen/services.gen.js";
+import { requireLogin } from "../../core/auth.js";
+import { resolveWorkspace, validatePath } from "../../core/context.js";
+import { isSuperset, parseFromFile } from "../../types.js";
+async function list(opts) {
+    const workspace = await resolveWorkspace(opts);
+    await requireLogin(opts);
+    const folders = await wmill.listFolders({
+        workspace: workspace.workspaceId,
+    });
+    new Table()
+        .header(["Name", "Owners", "Extra Perms"])
+        .padding(2)
+        .border(true)
+        .body(folders.map((x) => [
+        x.name,
+        x.owners?.join(",") ?? "-",
+        JSON.stringify(x.extra_perms ?? {}),
+    ]))
+        .render();
+}
+export async function pushFolder(workspace, name, folder, localFolder) {
+    if (name.startsWith(SEP)) {
+        name = name.substring(1);
+    }
+    if (name.startsWith("f" + SEP)) {
+        name = name.substring(2);
+    }
+    name = name.split(SEP)[0];
+    log.debug(`Processing local folder ${name}`);
+    // deleting old app if it exists in raw mode
+    try {
+        folder = await wmill.getFolder({ workspace, name });
+        log.debug(`Folder ${name} exists on remote`);
+    }
+    catch {
+        log.debug(`Folder ${name} does not exist on remote`);
+        //ignore
+    }
+    if (folder) {
+        if (isSuperset(localFolder, folder)) {
+            log.debug(`Folder ${name} is up to date`);
+            return;
+        }
+        log.debug(`Folder ${name} is not up-to-date, updating...`);
+        try {
+            await wmill.updateFolder({
+                workspace: workspace,
+                name: name,
+                requestBody: {
+                    ...localFolder,
+                },
+            });
+        }
+        catch (e) {
+            //@ts-ignore
+            console.error(e.body);
+            throw e;
+        }
+    }
+    else {
+        console.log(colors.bold.yellow("Creating new folder: " + name));
+        try {
+            await wmill.createFolder({
+                workspace: workspace,
+                requestBody: {
+                    name: name,
+                    ...localFolder,
+                },
+            });
+        }
+        catch (e) {
+            //@ts-ignore
+            throw Error(`Failed to create folder ${name}: ${e.body ?? e.message}`);
+        }
+    }
+}
+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.");
+    }
+    console.log(colors.bold.yellow("Pushing folder..."));
+    await pushFolder(workspace.workspaceId, remotePath, undefined, parseFromFile(filePath));
+    console.log(colors.bold.underline.green("Folder pushed"));
+}
+const command = new Command()
+    .description("folder related commands")
+    .action(list)
+    .command("push", "push a local folder spec. This overrides any remote versions.")
+    .arguments("<file_path:string> <remote_path:string>")
+    .action(push);
+export default command;

package/esm/src/commands/gitsync-settings/converter.js

@@ -0,0 +1,134 @@
+// Helper to compare string arrays (used for includes/excludes/extraIncludes)
+function arraysEqual(arr1, arr2) {
+    if (arr1.length !== arr2.length) {
+        return false;
+    }
+    const sorted1 = [...arr1].sort();
+    const sorted2 = [...arr2].sort();
+    return sorted1.every((item, index) => item === sorted2[index]);
+}
+export class GitSyncSettingsConverter {
+    // Convert backend include_type array to SyncOptions boolean flags
+    static fromBackendFormat(settings) {
+        const includeTypes = settings.include_type || [];
+        const result = {
+            includes: settings.include_path || [],
+            excludes: settings.exclude_path || [],
+            skipScripts: !includeTypes.includes("script"),
+            skipFlows: !includeTypes.includes("flow"),
+            skipApps: !includeTypes.includes("app"),
+            skipFolders: !includeTypes.includes("folder"),
+            skipVariables: !includeTypes.includes("variable"),
+            skipResources: !includeTypes.includes("resource"),
+            skipResourceTypes: !includeTypes.includes("resourcetype"),
+            skipSecrets: !includeTypes.includes("secret"),
+            includeSchedules: includeTypes.includes("schedule"),
+            includeTriggers: includeTypes.includes("trigger"),
+            includeUsers: includeTypes.includes("user"),
+            includeGroups: includeTypes.includes("group"),
+            includeSettings: includeTypes.includes("settings"),
+            includeKey: includeTypes.includes("key"),
+        };
+        // Only include extraIncludes if it has content
+        if (settings.extra_include_path && settings.extra_include_path.length > 0) {
+            result.extraIncludes = settings.extra_include_path;
+        }
+        return result;
+    }
+    // Convert SyncOptions boolean flags to backend include_type array
+    static toBackendFormat(opts) {
+        const includeTypes = [];
+        if (!opts.skipScripts)
+            includeTypes.push("script");
+        if (!opts.skipFlows)
+            includeTypes.push("flow");
+        if (!opts.skipApps)
+            includeTypes.push("app");
+        if (!opts.skipFolders)
+            includeTypes.push("folder");
+        if (!opts.skipVariables)
+            includeTypes.push("variable");
+        if (!opts.skipResources)
+            includeTypes.push("resource");
+        if (!opts.skipResourceTypes)
+            includeTypes.push("resourcetype");
+        if (!opts.skipSecrets)
+            includeTypes.push("secret");
+        if (opts.includeSchedules)
+            includeTypes.push("schedule");
+        if (opts.includeTriggers)
+            includeTypes.push("trigger");
+        if (opts.includeUsers)
+            includeTypes.push("user");
+        if (opts.includeGroups)
+            includeTypes.push("group");
+        if (opts.includeSettings)
+            includeTypes.push("settings");
+        if (opts.includeKey)
+            includeTypes.push("key");
+        const result = {
+            include_path: opts.includes || [],
+            include_type: includeTypes,
+        };
+        // Only include optional arrays if they have content
+        if (opts.excludes && opts.excludes.length > 0) {
+            result.exclude_path = opts.excludes;
+        }
+        if (opts.extraIncludes && opts.extraIncludes.length > 0) {
+            result.extra_include_path = opts.extraIncludes;
+        }
+        return result;
+    }
+    // Normalize SyncOptions for semantic comparison - treat undefined values as their defaults
+    static normalize(opts) {
+        return {
+            ...opts,
+            includes: opts.includes || [],
+            excludes: opts.excludes || [],
+            extraIncludes: opts.extraIncludes || [],
+            skipVariables: opts.skipVariables ?? false,
+            skipResources: opts.skipResources ?? false,
+            skipResourceTypes: opts.skipResourceTypes ?? false,
+            skipSecrets: opts.skipSecrets ?? true,
+            skipScripts: opts.skipScripts ?? false,
+            skipFlows: opts.skipFlows ?? false,
+            skipApps: opts.skipApps ?? false,
+            skipFolders: opts.skipFolders ?? false,
+            includeSchedules: opts.includeSchedules ?? false,
+            includeTriggers: opts.includeTriggers ?? false,
+            includeUsers: opts.includeUsers ?? false,
+            includeGroups: opts.includeGroups ?? false,
+            includeSettings: opts.includeSettings ?? false,
+            includeKey: opts.includeKey ?? false,
+        };
+    }
+    // Extract only git-sync relevant fields for comparison
+    static extractGitSyncFields(opts) {
+        return {
+            includes: opts.includes || [],
+            excludes: opts.excludes || [],
+            extraIncludes: opts.extraIncludes || [],
+            skipScripts: opts.skipScripts,
+            skipFlows: opts.skipFlows,
+            skipApps: opts.skipApps,
+            skipFolders: opts.skipFolders,
+            skipVariables: opts.skipVariables,
+            skipResources: opts.skipResources,
+            skipResourceTypes: opts.skipResourceTypes,
+            skipSecrets: opts.skipSecrets,
+            includeSchedules: opts.includeSchedules,
+            includeTriggers: opts.includeTriggers,
+            includeUsers: opts.includeUsers,
+            includeGroups: opts.includeGroups,
+            includeSettings: opts.includeSettings,
+            includeKey: opts.includeKey,
+        };
+    }
+    // Check if two values are different, with special handling for arrays
+    static isDifferent(value1, value2) {
+        if (Array.isArray(value1) && Array.isArray(value2)) {
+            return !arraysEqual(value1, value2);
+        }
+        return value1 !== value2;
+    }
+}

package/esm/src/commands/gitsync-settings/gitsync-settings.js

@@ -0,0 +1,2 @@
+export { pullGitSyncSettings, pushGitSyncSettings } from "./index.js";
+export { default } from "./index.js";

package/esm/src/commands/gitsync-settings/index.js

@@ -0,0 +1,28 @@
+import { Command } from "../../../deps.js";
+import { pullGitSyncSettings } from "./pull.js";
+import { pushGitSyncSettings } from "./push.js";
+const command = new Command()
+    .description("Manage git-sync settings between local wmill.yaml and Windmill backend")
+    .command("pull")
+    .description("Pull git-sync settings from Windmill backend to local wmill.yaml")
+    .option("--repository <repo:string>", "Specify repository path (e.g., u/user/repo)")
+    .option("--default", "Write settings to top-level defaults instead of overrides")
+    .option("--replace", "Replace existing settings (non-interactive mode)")
+    .option("--override", "Add branch-specific override (non-interactive mode)")
+    .option("--diff", "Show differences without applying changes")
+    .option("--json-output", "Output in JSON format")
+    .option("--with-backend-settings <json:string>", "Use provided JSON settings instead of querying backend (for testing)")
+    .option("--yes", "Skip interactive prompts and use default behavior")
+    .option("--promotion <branch:string>", "Use promotionOverrides from the specified branch instead of regular overrides")
+    .action(pullGitSyncSettings)
+    .command("push")
+    .description("Push git-sync settings from local wmill.yaml to Windmill backend")
+    .option("--repository <repo:string>", "Specify repository path (e.g., u/user/repo)")
+    .option("--diff", "Show what would be pushed without applying changes")
+    .option("--json-output", "Output in JSON format")
+    .option("--with-backend-settings <json:string>", "Use provided JSON settings instead of querying backend (for testing)")
+    .option("--yes", "Skip interactive prompts and use default behavior")
+    .option("--promotion <branch:string>", "Use promotionOverrides from the specified branch instead of regular overrides")
+    .action(pushGitSyncSettings);
+export { pullGitSyncSettings, pushGitSyncSettings };
+export default command;

package/esm/src/commands/gitsync-settings/legacySettings.js

@@ -0,0 +1,119 @@
+import * as dntShim from "../../../_dnt.shims.js";
+import { colors, Confirm } from "../../../deps.js";
+import * as wmill from "../../../gen/services.gen.js";
+// Shared migration function for legacy repositories
+export async function handleLegacyRepositoryMigration(selectedRepo, gitSyncSettings, workspace, opts, operationName = "operation") {
+    if (selectedRepo.settings) {
+        return selectedRepo; // Already migrated
+    }
+    // This repository is in legacy format - handle migration
+    if (!gitSyncSettings.include_path || !gitSyncSettings.include_type) {
+        throw new Error(`Repository "${selectedRepo.git_repo_resource_path}" has legacy format but workspace-level include_path or include_type is missing. This indicates corrupted git-sync settings.`);
+    }
+    const workspaceIncludePath = gitSyncSettings.include_path;
+    const workspaceIncludeType = gitSyncSettings.include_type;
+    if (dntShim.Deno.stdout.isTerminal() && !opts.yes) {
+        // Interactive mode - show migration prompt
+        console.log(colors.yellow('\n⚠️  Legacy git-sync settings detected!'));
+        console.log(`\nRepository "${selectedRepo.git_repo_resource_path}" has legacy settings format.`);
+        console.log('The new format allows per-repository filter configuration.');
+        if (operationName === "push") {
+            console.log('This repository must be migrated before pushing settings.\n');
+        }
+        else {
+            console.log('\n');
+        }
+        console.log(colors.bold('Current workspace-level settings:'));
+        console.log(`  Include paths: ${workspaceIncludePath.join(', ')}`);
+        console.log(`  Include types: ${workspaceIncludeType.join(', ')}\n`);
+        // Show what the migration will do
+        let finalIncludeType = [...workspaceIncludeType];
+        if (selectedRepo.exclude_types_override && selectedRepo.exclude_types_override.length > 0) {
+            const originalCount = finalIncludeType.length;
+            finalIncludeType = finalIncludeType.filter(type => !selectedRepo.exclude_types_override.includes(type));
+            const excludedCount = originalCount - finalIncludeType.length;
+            console.log(colors.yellow(`Repository excludes ${excludedCount} types: ${selectedRepo.exclude_types_override.join(', ')}`));
+        }
+        console.log(colors.bold('\nAfter migration, repository will have:'));
+        console.log(`  Include paths: ${workspaceIncludePath.join(', ')}`);
+        console.log(`  Include types: ${finalIncludeType.join(', ')}\n`);
+        const confirm = await Confirm.prompt({
+            message: operationName === "push"
+                ? 'Do you want to migrate this repository before pushing?'
+                : 'Do you want to migrate this repository?',
+            default: true
+        });
+        if (!confirm) {
+            const message = operationName === "push"
+                ? '\n⚠️  Migration skipped. Cannot push to legacy repository.'
+                : '\n⚠️  Migration skipped. You can migrate later via the UI.';
+            console.log(colors.yellow(message));
+            if (operationName === "push") {
+                return null; // Signal to exit push operation
+            }
+            throw new Error('Migration cancelled by user');
+        }
+        // Perform the migration
+        let migratedIncludeType = [...workspaceIncludeType];
+        if (selectedRepo.exclude_types_override && selectedRepo.exclude_types_override.length > 0) {
+            migratedIncludeType = migratedIncludeType.filter(type => !selectedRepo.exclude_types_override.includes(type));
+        }
+        const migratedRepo = {
+            ...selectedRepo,
+            settings: {
+                include_path: [...workspaceIncludePath],
+                include_type: migratedIncludeType,
+                exclude_path: [],
+                extra_include_path: []
+            }
+        };
+        // Remove the old field
+        delete migratedRepo.exclude_types_override;
+        // Update the backend with migrated repository
+        const updatedRepositories = gitSyncSettings.repositories.map((repo) => {
+            if (repo.git_repo_resource_path === selectedRepo.git_repo_resource_path) {
+                return migratedRepo;
+            }
+            return repo;
+        });
+        await wmill.editWorkspaceGitSyncConfig({
+            workspace: workspace.workspaceId,
+            requestBody: {
+                git_sync_settings: {
+                    repositories: updatedRepositories,
+                    // Keep workspace-level settings if other repos are still legacy
+                    ...(gitSyncSettings.repositories.some((r) => r.git_repo_resource_path !== selectedRepo.git_repo_resource_path && !r.settings) && {
+                        include_path: workspaceIncludePath,
+                        include_type: workspaceIncludeType
+                    })
+                }
+            }
+        });
+        console.log(colors.green('\n✓ Repository migration completed successfully!'));
+        if (operationName === "push") {
+            console.log('Now proceeding with push operation...\n');
+        }
+        return migratedRepo;
+    }
+    else {
+        // Non-interactive mode - show error
+        console.error(colors.red('\n❌ Legacy git-sync settings detected!'));
+        console.error(`\nRepository "${selectedRepo.git_repo_resource_path}" has legacy settings format.`);
+        if (operationName === "push") {
+            console.error('This repository must be migrated before pushing settings.');
+        }
+        console.error('Please choose one of the following options:\n');
+        console.error('1. Go to the Windmill UI > Workspace Settings > Git Sync');
+        console.error('   Review and save this repository to migrate to the new format.\n');
+        console.error('2. Run this command in interactive mode (with TTY) to migrate.');
+        console.error(`   Example: wmill gitsync-settings ${operationName}\n`);
+        if (operationName === "push") {
+            console.error('3. Pull settings first to migrate: wmill gitsync-settings pull\n');
+        }
+        else {
+            console.error('3. Push local settings to override backend settings:');
+            console.error('   wmill gitsync-settings push\n');
+        }
+        dntShim.Deno.exit(1);
+    }
+}