windmill-cli 1.585.1 → 1.586.1

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

@@ -1,8 +1,8 @@
 // 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 { 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 { colors, Command, Confirm, Input, log, setClient, Table, } from "../../../deps.js";
 import { requireLogin } from "../../core/auth.js";
 import { createWorkspaceFork, deleteWorkspaceFork } from "./fork.js";
 import * as wmill from "../../../gen/services.gen.js";
@@ -87,6 +87,8 @@ async function switchC(opts, workspaceName) {
         return;
     }
     await setActiveWorkspace(workspaceName, opts.configDir);
+    const workspace = await getWorkspaceByName(workspaceName, opts.configDir);
+    log.info(colors.green.bold(`Switched to workspace ${workspaceName} (${workspace?.workspaceId} on ${workspace?.remote})`));
     return;
 }
 export async function setActiveWorkspace(workspaceName, configDirOverride) {
@@ -185,10 +187,11 @@ export async function addWorkspace(workspace, opts) {
     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);
+    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) {
+        if (nameConflict.remote === workspace.remote &&
+            nameConflict.workspaceId === workspace.workspaceId) {
             log.info(colors.yellow(`Updating token for existing workspace "${workspace.name}"`));
         }
         else {

package/esm/src/core/conf.js

@@ -20,6 +20,7 @@ function getGitRepoRoot() {
         return null;
     }
 }
+export const GLOBAL_CONFIG_OPT = { noCdToRoot: false };
 function findWmillYaml() {
     const startDir = resolve(dntShim.Deno.cwd());
     const isInGitRepo = isGitRepository();
@@ -50,7 +51,9 @@ function findWmillYaml() {
         currentDir = parentDir;
     }
     // If wmill.yaml was found in a parent directory, warn the user and change working directory
-    if (foundPath && resolve(dirname(foundPath)) !== resolve(startDir)) {
+    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}`);
@@ -187,6 +190,7 @@ export const DEFAULT_SYNC_OPTIONS = {
     includeGroups: false,
     includeSettings: false,
     includeKey: false,
+    skipWorkspaceDependencies: false,
 };
 export async function mergeConfigWithConfigFile(opts) {
     const configFile = await readConfigFile();

package/esm/src/core/context.js

@@ -45,6 +45,54 @@ async function selectFromMultipleProfiles(profiles, baseUrl, workspaceId, contex
     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)
@@ -79,6 +127,7 @@ export async function tryResolveBranchWorkspace(opts) {
     const originalBranchIfForked = getOriginalBranchForWorkspaceForks(rawBranch);
     const workspaceIdIfForked = getWorkspaceIdForWorkspaceForkFromBranchName(rawBranch);
     if (originalBranchIfForked) {
+        log.info(`Using original branch \`${originalBranchIfForked}\` for finding workspace profile from gitBranches section in wmill.yaml`);
         currentBranch = originalBranchIfForked;
     }
     else {
@@ -91,11 +140,8 @@ export async function tryResolveBranchWorkspace(opts) {
     if (!branchConfig?.baseUrl || !branchConfig?.workspaceId) {
         return undefined;
     }
+    log.info(`Using branch configuration for branch \`${currentBranch}\` set in gitBranches`);
     let { baseUrl, workspaceId } = branchConfig;
-    if (workspaceIdIfForked) {
-        workspaceId = workspaceIdIfForked;
-        log.info(`Inferred workspace id \`${workspaceId}\` from branch name because this is a workspace fork branch (\`${rawBranch}\`). `);
-    }
     let normalizedBaseUrl;
     try {
         normalizedBaseUrl = new URL(baseUrl).toString();
@@ -109,54 +155,13 @@ export async function tryResolveBranchWorkspace(opts) {
     const matchingProfiles = allProfiles.filter(w => w.remote === normalizedBaseUrl && w.workspaceId === workspaceId);
     if (matchingProfiles.length === 0) {
         // No matching profile exists - prompt to create one
-        if (!originalBranchIfForked) {
-            log.info(colors.yellow(`\nNo workspace profile found for branch '${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;
+        return await createWorkspaceProfileInteractively(normalizedBaseUrl, workspaceId, currentBranch, opts, { rawBranch, 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}'`));
+        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
@@ -174,6 +179,11 @@ export async function tryResolveBranchWorkspace(opts) {
         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) {

package/esm/src/main.js

@@ -30,6 +30,7 @@ import { pull, push } from "./commands/sync/sync.js";
 import { add as workspaceAdd } from "./commands/workspace/workspace.js";
 import workers from "./commands/workers/workers.js";
 import queues from "./commands/queues/queues.js";
+import dependencies from "./commands/dependencies/dependencies.js";
 import init from "./commands/init/init.js";
 export { flow, app, script, workspace, resource, resourceType, user, variable, hub, folder, schedule, trigger, sync, gitsyncSettings, instance, dev, hubPull, pull, push, workspaceAdd, };
 // addEventListener("error", (event) => {
@@ -38,7 +39,7 @@ export { flow, app, script, workspace, resource, resourceType, user, variable, h
 //     console.error(JSON.stringify(event.error, null, 4));
 //   }
 // });
-export const VERSION = "1.585.1";
+export const VERSION = "1.586.0";
 export const WM_FORK_PREFIX = "wm-fork";
 const command = new Command()
     .name("wmill")
@@ -73,6 +74,7 @@ const command = new Command()
     .command("worker-groups", workerGroups)
     .command("workers", workers)
     .command("queues", queues)
+    .command("dependencies", dependencies)
     .command("version --version", "Show version information")
     .action(async (opts) => {
     console.log("CLI version: " + VERSION);

package/esm/src/types.js

@@ -1,6 +1,6 @@
 // deno-lint-ignore-file no-explicit-any
 import * as dntShim from "../_dnt.shims.js";
-import { Diff, SEP, colors, log, path, yamlParseContent, yamlStringify, } from "../deps.js";
+import { colors, Diff, log, path, SEP, yamlParseContent, yamlStringify, } from "../deps.js";
 import { pushApp } from "./commands/app/apps.js";
 import { pushFolder } from "./commands/folder/folder.js";
 import { pushFlow } from "./commands/flow/flow.js";
@@ -9,22 +9,24 @@ import { pushResourceType } from "./commands/resource-type/resource-type.js";
 import { pushVariable } from "./commands/variable/variable.js";
 import { yamlOptions } from "./commands/sync/sync.js";
 import { showDiffs } from "./core/conf.js";
-import { deepEqual, isFileResource } from "./utils/utils.js";
+import { deepEqual, isFileResource, isWorkspaceDependencies } from "./utils/utils.js";
 import { pushSchedule } from "./commands/schedule/schedule.js";
 import { pushWorkspaceUser } from "./commands/user/user.js";
 import { pushGroup } from "./commands/user/user.js";
+import { pushWorkspaceDependencies } from "./commands/dependencies/dependencies.js";
 import { pushWorkspaceSettings, pushWorkspaceKey } from "./core/settings.js";
 import { pushTrigger } from "./commands/trigger/trigger.js";
+import { pushRawApp } from "./commands/app/raw_apps.js";
 export const TRIGGER_TYPES = [
-    'http',
-    'websocket',
-    'kafka',
-    'nats',
-    'postgres',
-    'mqtt',
-    'sqs',
-    'gcp',
-    'email',
+    "http",
+    "websocket",
+    "kafka",
+    "nats",
+    "postgres",
+    "mqtt",
+    "sqs",
+    "gcp",
+    "email",
 ];
 export function isSuperset(subset, superset) {
     return Object.keys(subset).every((key) => {
@@ -94,6 +96,10 @@ export async function pushObj(workspace, p, befObj, newObj, plainSecrets, alread
         const appName = p.split(".app" + SEP)[0];
         await pushApp(workspace, appName, appName + ".app", message);
     }
+    else if (typeEnding === "raw_app") {
+        const rawAppName = p.split(".raw_app" + SEP)[0];
+        await pushRawApp(workspace, rawAppName, rawAppName + ".raw_app", message);
+    }
     else if (typeEnding === "folder") {
         await pushFolder(workspace, p, befObj, newObj);
     }
@@ -149,6 +155,9 @@ export async function pushObj(workspace, p, befObj, newObj, plainSecrets, alread
     else if (typeEnding === "group") {
         await pushGroup(workspace, p, befObj, newObj);
     }
+    else if (typeEnding === "workspace_dependencies") {
+        await pushWorkspaceDependencies(workspace, p, befObj, newObj);
+    }
     else if (typeEnding === "settings") {
         await pushWorkspaceSettings(workspace, p, befObj, newObj);
     }
@@ -160,11 +169,13 @@ export async function pushObj(workspace, p, befObj, newObj, plainSecrets, alread
     }
 }
 export function parseFromPath(p, content) {
-    return p.endsWith(".yaml")
-        ? yamlParseContent(p, content)
-        : p.endsWith(".json")
-            ? JSON.parse(content)
-            : content;
+    return isWorkspaceDependencies(p)
+        ? content
+        : p.endsWith(".yaml")
+            ? yamlParseContent(p, content)
+            : p.endsWith(".json")
+                ? JSON.parse(content)
+                : content;
 }
 export function parseFromFile(p) {
     if (p.endsWith(".json")) {
@@ -184,6 +195,12 @@ export function getTypeStrFromPath(p) {
     if (p.includes(".app" + SEP)) {
         return "app";
     }
+    if (p.includes(".raw_app" + SEP)) {
+        return "raw_app";
+    }
+    if (p.startsWith("dependencies" + SEP)) {
+        return "workspace_dependencies";
+    }
     const parsed = path.parse(p);
     if (parsed.ext == ".go" ||
         parsed.ext == ".ts" ||

package/esm/src/utils/codebase.js

@@ -4,24 +4,33 @@ export function listSyncCodebases(options) {
     const res = [];
     const nb_codebase = options?.codebases?.length ?? 0;
     if (nb_codebase > 0) {
-        log.info(`Found ${nb_codebase} codebases: ${options?.codebases?.map((c) => c.relative_path).join(", ")}`);
+        log.info(`Found ${nb_codebase} codebases: ${options?.codebases
+            ?.map((c) => c.relative_path)
+            .join(", ")}`);
     }
     for (const codebase of options?.codebases ?? []) {
         let _digest = undefined;
         let alreadyPrinted = false;
+        let hasAssets = false;
         const getDigest = async (forceTar) => {
-            if (_digest == undefined || forceTar) {
+            if (_digest == undefined) {
                 _digest = await digestDir(codebase.relative_path, JSON.stringify(codebase));
-                if (forceTar || (Array.isArray(codebase.assets) && codebase.assets.length > 0)) {
-                    _digest += ".tar";
+                if (codebase.format == "esm") {
+                    _digest += ".esm";
                 }
                 if (!alreadyPrinted) {
                     alreadyPrinted = true;
                     log.info(`Codebase ${codebase.relative_path}, digest: ${_digest}`);
                 }
+                hasAssets =
+                    Array.isArray(codebase.assets) && codebase.assets.length > 0;
+            }
+            if (forceTar || hasAssets) {
+                return _digest + ".tar";
+            }
+            else {
                 return _digest;
             }
-            return _digest;
         };
         res.push({ ...codebase, getDigest });
     }