windmill-cli 1.518.1 → 1.518.3

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

@@ -0,0 +1,129 @@
+import { colors, log } from "../../../deps.js";
+import { deepEqual, selectRepository } from "../../utils/utils.js";
+import { DEFAULT_SYNC_OPTIONS } from "../../core/conf.js";
+import { GIT_SYNC_FIELDS } from "./types.js";
+import { GitSyncSettingsConverter } from "./converter.js";
+// Helper for consistent output handling between JSON and regular modes
+export function outputResult(opts, result) {
+    if (opts.jsonOutput) {
+        console.log(JSON.stringify(result));
+    }
+    else if (result.success && result.message) {
+        log.info(colors.green(result.message));
+    }
+    else if (!result.success && result.error) {
+        log.error(colors.red(result.error));
+    }
+}
+// Helper to normalize repository path by removing $res: prefix
+export function normalizeRepoPath(path) {
+    return path.replace(/^\$res:/, "");
+}
+// Helper to get or create branch configuration
+export function getOrCreateBranchConfig(config, branchName) {
+    if (!config.git_branches) {
+        config.git_branches = {};
+    }
+    if (!config.git_branches[branchName]) {
+        config.git_branches[branchName] = {};
+    }
+    return {
+        config,
+        branchKey: branchName
+    };
+}
+// Helper to apply backend settings to branch configuration
+export function applyBackendSettingsToBranch(config, branchName, backendSettings) {
+    const { config: updatedConfig } = getOrCreateBranchConfig(config, branchName);
+    // Get the base settings (top-level + defaults) to compare against
+    const { git_branches, ...topLevelSettings } = config;
+    const baseSettings = { ...DEFAULT_SYNC_OPTIONS, ...topLevelSettings };
+    // Only store fields that differ from the base settings
+    Object.keys(backendSettings).forEach(key => {
+        if (key !== 'git_branches' && backendSettings[key] !== undefined) {
+            const backendValue = backendSettings[key];
+            const baseValue = baseSettings[key];
+            // Only store if different from base
+            const isDifferent = GitSyncSettingsConverter.isDifferent(backendValue, baseValue);
+            if (isDifferent) {
+                if (!updatedConfig.git_branches[branchName].overrides) {
+                    updatedConfig.git_branches[branchName].overrides = {};
+                }
+                updatedConfig.git_branches[branchName].overrides[key] = backendValue;
+            }
+        }
+    });
+    return updatedConfig;
+}
+// Select repository interactively if multiple exist
+export async function selectAndLogRepository(repositories, repository, suppressLogs) {
+    let selectedRepo;
+    if (repository) {
+        const found = repositories.find((r) => r.git_repo_resource_path === repository ||
+            r.git_repo_resource_path === `$res:${repository}`);
+        if (!found) {
+            throw new Error(`Repository ${repository} not found`);
+        }
+        selectedRepo = found;
+        const repoPath = selectedRepo.git_repo_resource_path.replace(/^\$res:/, "");
+        if (!suppressLogs) {
+            log.info(colors.cyan(`Using repository: ${colors.bold(repoPath)}`));
+        }
+    }
+    else {
+        selectedRepo = await selectRepository(repositories);
+    }
+    return selectedRepo;
+}
+// Generate structured diff showing field changes
+export function generateStructuredDiff(current, backend) {
+    const diff = {};
+    // Get all unique keys from both objects
+    const allKeys = new Set([...Object.keys(current), ...Object.keys(backend)]);
+    for (const key of allKeys) {
+        const currentValue = current[key];
+        const backendValue = backend[key];
+        if (!deepEqual(currentValue, backendValue)) {
+            diff[key] = {
+                from: currentValue,
+                to: backendValue,
+            };
+        }
+    }
+    return diff;
+}
+// Helper to generate changes between two SyncOptions objects (normalizes automatically)
+export function generateChanges(current, new_) {
+    const changes = {};
+    // Normalize both inputs for consistent comparison
+    const normalizedCurrent = GitSyncSettingsConverter.normalize(current);
+    const normalizedNew = GitSyncSettingsConverter.normalize(new_);
+    for (const field of GIT_SYNC_FIELDS) {
+        const currentValue = normalizedCurrent[field];
+        const newValue = normalizedNew[field];
+        if (!deepEqual(currentValue, newValue)) {
+            changes[field] = {
+                from: currentValue,
+                to: newValue,
+            };
+        }
+    }
+    return changes;
+}
+// Helper to display changes in human-readable format
+export function displayChanges(changes) {
+    for (const [field, change] of Object.entries(changes)) {
+        if (Array.isArray(change.from) ||
+            Array.isArray(change.to)) {
+            console.log(colors.yellow(`  ${field}:`));
+            console.log(colors.red(`    - ${JSON.stringify(change.from)}`));
+            console.log(colors.green(`    + ${JSON.stringify(change.to)}`));
+        }
+        else {
+            console.log(colors.yellow(`  ${field}: `) +
+                colors.red(`${change.from}`) +
+                " → " +
+                colors.green(`${change.to}`));
+        }
+    }
+}

package/esm/src/commands/hub/hub.js

@@ -0,0 +1,65 @@
+// deno-lint-ignore-file no-explicit-any
+import { Command, log } from "../../../deps.js";
+import * as wmill from "../../../gen/services.gen.js";
+import { requireLogin } from "../../core/auth.js";
+import { resolveWorkspace } from "../../core/context.js";
+import { pushResourceType } from "../resource-type/resource-type.js";
+import { deepEqual } from "../../utils/utils.js";
+const DEFAULT_HUB_BASE_URL = "https://hub.windmill.dev";
+export async function pull(opts) {
+    const workspace = await resolveWorkspace(opts);
+    if (workspace.workspaceId !== "admins") {
+        log.info("Should only sync to admins workspace, but current is not admins.");
+        return;
+    }
+    const userInfo = await requireLogin(opts);
+    const uid = (await wmill.getGlobal({
+        key: "uid",
+    }));
+    const hubBaseUrl = (await wmill.getGlobal({
+        key: "hub_base_url",
+    })) ?? DEFAULT_HUB_BASE_URL;
+    const headers = {
+        Accept: "application/json",
+        "X-email": userInfo.email,
+    };
+    if (uid) {
+        headers["X-uid"] = uid;
+    }
+    let list = await fetch(hubBaseUrl + "/resource_types/list", {
+        headers,
+    }).then((r) => r.json());
+    if (list && list.length === 0 && hubBaseUrl !== DEFAULT_HUB_BASE_URL) {
+        list = await fetch(DEFAULT_HUB_BASE_URL + "/resource_types/list", {
+            headers,
+        }).then((r) => r.json());
+    }
+    const resourceTypes = await wmill.listResourceType({
+        workspace: workspace.workspaceId,
+    });
+    for (const x of list) {
+        try {
+            x.schema = JSON.parse(x.schema);
+        }
+        catch (e) {
+            log.info("failed to parse schema for " + x.name);
+            continue;
+        }
+        if (resourceTypes.find((y) => y.name === x.name &&
+            typeof y.schema !== "string" &&
+            deepEqual(y.schema, x.schema) &&
+            y.description === x.description)) {
+            log.info("skipping " + x.name + " (same as current)");
+            continue;
+        }
+        log.info("syncing " + x.name);
+        await pushResourceType(workspace.workspaceId, x.name + ".resource-type.json", undefined, x);
+    }
+}
+const command = new Command()
+    .name("hub")
+    .description("Hub related commands. EXPERIMENTAL. INTERNAL USE ONLY.")
+    .command("pull")
+    .description("pull any supported definitions. EXPERIMENTAL.")
+    .action(pull);
+export default command;

package/esm/src/commands/init/init.js

@@ -0,0 +1,214 @@
+import * as dntShim from "../../../_dnt.shims.js";
+import { colors, Command, log, yamlStringify, Confirm, } from "../../../deps.js";
+import { readLockfile } from "../../utils/metadata.js";
+import { SCRIPT_GUIDANCE } from "../../guidance/script_guidance.js";
+import { FLOW_GUIDANCE } from "../../guidance/flow_guidance.js";
+/**
+ * Bootstrap a windmill project with a wmill.yaml file
+ */
+async function initAction(opts) {
+    if (await dntShim.Deno.stat("wmill.yaml").catch(() => null)) {
+        log.error(colors.red("wmill.yaml already exists"));
+    }
+    else {
+        // Import DEFAULT_SYNC_OPTIONS from conf.ts
+        const { DEFAULT_SYNC_OPTIONS } = await import("../../core/conf.js");
+        // Create initial config with defaults
+        const initialConfig = { ...DEFAULT_SYNC_OPTIONS };
+        // Add branch structure
+        const { isGitRepository, getCurrentGitBranch } = await import("../../utils/git.js");
+        if (isGitRepository()) {
+            const currentBranch = getCurrentGitBranch();
+            if (currentBranch) {
+                initialConfig.git_branches = {
+                    [currentBranch]: { overrides: {} },
+                };
+            }
+            else {
+                initialConfig.git_branches = {};
+            }
+        }
+        else {
+            initialConfig.git_branches = {};
+        }
+        await dntShim.Deno.writeTextFile("wmill.yaml", yamlStringify(initialConfig));
+        log.info(colors.green("wmill.yaml created with default settings"));
+        // Create lock file
+        await readLockfile();
+        // Offer to bind workspace profile to current branch
+        if (isGitRepository()) {
+            const { getActiveWorkspace } = await import("../workspace/workspace.js");
+            const activeWorkspace = await getActiveWorkspace(opts);
+            const currentBranch = getCurrentGitBranch();
+            if (activeWorkspace && currentBranch) {
+                // Determine binding behavior based on flags
+                const shouldBind = opts.bindProfile === true;
+                const shouldPrompt = opts.bindProfile === undefined &&
+                    dntShim.Deno.stdin.isTerminal() &&
+                    !opts.useDefault;
+                const shouldSkip = opts.bindProfile === false ||
+                    opts.useDefault ||
+                    (!dntShim.Deno.stdin.isTerminal() && opts.bindProfile === undefined);
+                if (shouldSkip) {
+                    return;
+                }
+                // Show workspace info if we're binding or prompting
+                if (shouldBind || shouldPrompt) {
+                    log.info(colors.yellow(`\nCurrent Git branch: ${colors.bold(currentBranch)}`));
+                    log.info(colors.yellow(`Active workspace profile: ${colors.bold(activeWorkspace.name)}`));
+                    log.info(colors.yellow(`  ${activeWorkspace.workspaceId} on ${activeWorkspace.remote}`));
+                }
+                if (shouldBind ||
+                    (shouldPrompt &&
+                        (await Confirm.prompt({
+                            message: "Bind workspace profile to current Git branch?",
+                            default: true,
+                        })))) {
+                    // Update the config with workspace binding
+                    const currentConfig = await import("../../core/conf.js").then((m) => m.readConfigFile());
+                    if (!currentConfig.git_branches) {
+                        currentConfig.git_branches = {};
+                    }
+                    if (!currentConfig.git_branches[currentBranch]) {
+                        currentConfig.git_branches[currentBranch] = { overrides: {} };
+                    }
+                    currentConfig.git_branches[currentBranch].baseUrl =
+                        activeWorkspace.remote;
+                    currentConfig.git_branches[currentBranch].workspaceId =
+                        activeWorkspace.workspaceId;
+                    await dntShim.Deno.writeTextFile("wmill.yaml", yamlStringify(currentConfig));
+                    log.info(colors.green(`✓ Bound branch '${currentBranch}' to workspace '${activeWorkspace.name}'`));
+                }
+            }
+        }
+        // Check for backend git-sync settings unless --use-default is specified
+        if (!opts.useDefault) {
+            try {
+                const { requireLogin } = await import("../../core/auth.js");
+                const { resolveWorkspace } = await import("../../core/context.js");
+                // Check if user has workspace configured
+                const { getActiveWorkspace } = await import("../workspace/workspace.js");
+                const activeWorkspace = await getActiveWorkspace(opts);
+                if (!activeWorkspace) {
+                    log.info("No workspace configured. Using default settings.");
+                    log.info("You can configure a workspace later with 'wmill workspace add'");
+                    return;
+                }
+                await requireLogin(opts);
+                const workspace = await resolveWorkspace(opts);
+                const wmill = await import("../../../gen/services.gen.js");
+                const settings = await wmill.getSettings({
+                    workspace: workspace.workspaceId,
+                });
+                if (settings.git_sync?.repositories &&
+                    settings.git_sync.repositories.length > 0) {
+                    let useBackendSettings = opts.useBackend;
+                    // If repository is specified, implicitly use backend settings
+                    if (opts.repository && !opts.useDefault) {
+                        useBackendSettings = true;
+                    }
+                    if (useBackendSettings === undefined) {
+                        // Interactive prompt
+                        const { Select } = await import("../../../deps.js");
+                        const choice = await Select.prompt({
+                            message: "Git-sync settings found on backend. What would you like to do?",
+                            options: [
+                                {
+                                    name: "Use backend git-sync settings",
+                                    value: "backend",
+                                },
+                                {
+                                    name: "Use default settings",
+                                    value: "default",
+                                },
+                                {
+                                    name: "Cancel",
+                                    value: "cancel",
+                                },
+                            ],
+                        });
+                        if (choice === "cancel") {
+                            // Clean up the created files
+                            try {
+                                await dntShim.Deno.remove("wmill.yaml");
+                                await dntShim.Deno.remove("wmill-lock.yaml");
+                            }
+                            catch (e) {
+                                // Ignore cleanup errors
+                            }
+                            log.info("Init cancelled");
+                            dntShim.Deno.exit(0);
+                        }
+                        useBackendSettings = choice === "backend";
+                    }
+                    if (useBackendSettings) {
+                        log.info("Applying git-sync settings from backend...");
+                        // Import and run the pull git-sync settings logic
+                        const { pullGitSyncSettings } = await import("../gitsync-settings/gitsync-settings.js");
+                        await pullGitSyncSettings({
+                            ...opts,
+                            repository: opts.repository,
+                            jsonOutput: false,
+                            diff: false,
+                            replace: true, // Auto-replace when using backend settings during init
+                        });
+                        log.info(colors.green("Git-sync settings applied from backend"));
+                    }
+                }
+            }
+            catch (error) {
+                // If there's an error checking backend settings, just continue with defaults
+                log.warn(`Could not check backend for git-sync settings: ${error.message}`);
+                log.info("Continuing with default settings");
+            }
+        }
+    }
+    // Create .cursor/rules directory and files with SCRIPT_GUIDANCE content
+    try {
+        const scriptGuidanceContent = SCRIPT_GUIDANCE;
+        const flowGuidanceContent = FLOW_GUIDANCE;
+        // Create .cursor/rules directory
+        await dntShim.Deno.mkdir(".cursor/rules", { recursive: true });
+        // Create windmill.mdc file
+        if (!(await dntShim.Deno.stat(".cursor/rules/script.mdc").catch(() => null))) {
+            await dntShim.Deno.writeTextFile(".cursor/rules/script.mdc", scriptGuidanceContent);
+            log.info(colors.green("Created .cursor/rules/script.mdc"));
+        }
+        if (!(await dntShim.Deno.stat(".cursor/rules/flow.mdc").catch(() => null))) {
+            await dntShim.Deno.writeTextFile(".cursor/rules/flow.mdc", flowGuidanceContent);
+            log.info(colors.green("Created .cursor/rules/flow.mdc"));
+        }
+        // Create CLAUDE.md file
+        if (!(await dntShim.Deno.stat("CLAUDE.md").catch(() => null))) {
+            await dntShim.Deno.writeTextFile("CLAUDE.md", `
+                        # Claude
+
+                        You are a helpful assistant that can help with Windmill scripts and flows creation.
+
+                        ## Script Guidance
+                        ${scriptGuidanceContent}
+
+                        ## Flow Guidance
+                        ${flowGuidanceContent}
+                    `);
+            log.info(colors.green("Created CLAUDE.md"));
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            log.warn(`Could not create guidance files: ${error.message}`);
+        }
+        else {
+            log.warn(`Could not create guidance files: ${error}`);
+        }
+    }
+}
+const command = new Command()
+    .description("Bootstrap a windmill project with a wmill.yaml file")
+    .option("--use-default", "Use default settings without checking backend")
+    .option("--use-backend", "Use backend git-sync settings if available")
+    .option("--repository <repo:string>", "Specify repository path (e.g., u/user/repo) when using backend settings")
+    .option("--bind-profile", "Automatically bind active workspace profile to current Git branch")
+    .option("--no-bind-profile", "Skip workspace profile binding prompt")
+    .action(initAction);
+export default command;