windmill-cli 1.586.0 → 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) => {
@@ -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/metadata.js

@@ -1,14 +1,11 @@
 // deno-lint-ignore-file no-explicit-any
 import * as dntShim from "../../_dnt.shims.js";
-import { SEP, colors, log, path, yamlParseFile, yamlStringify, } from "../../deps.js";
+import { SEP, colors, log, yamlParseFile, yamlStringify } from "../../deps.js";
 import { defaultScriptMetadata, } from "../../bootstrap/script_bootstrap.js";
-import { languagesWithRawReqsSupport, } from "./script_common.js";
+import { workspaceDependenciesLanguages, } from "./script_common.js";
 import { inferContentTypeFromFilePath } from "./script_common.js";
-import { exts, findGlobalDeps } from "../commands/script/script.js";
-import { FSFSElement, findCodebase, yamlOptions, } from "../commands/sync/sync.js";
-import { generateHash, readInlinePathSync, getHeaders, writeIfChanged, } from "./utils.js";
-import { replaceInlineScripts } from "../../windmill-utils-internal/src/inline-scripts/replacer.js";
-import { extractInlineScripts as extractInlineScriptsForFlows } from "../../windmill-utils-internal/src/inline-scripts/extractor.js";
+import { findCodebase, yamlOptions } from "../commands/sync/sync.js";
+import { generateHash, readInlinePathSync, getHeaders } from "./utils.js";
 import { argSigToJsonSchemaType } from "../../windmill-utils-internal/src/parse/parse-schema.js";
 import { getIsWin } from "./utils.js";
 export class LockfileGenerationError extends Error {
@@ -18,128 +15,68 @@ export class LockfileGenerationError extends Error {
     }
 }
 export async function generateAllMetadata() { }
-function findClosestRawReqs(lang, remotePath, globalDeps) {
-    let bestCandidate = undefined;
-    if (lang) {
-        Object.entries(globalDeps.get(lang) ?? {}).forEach(([k, v]) => {
-            if (remotePath.startsWith(k) &&
-                k.length >= (bestCandidate?.k ?? "").length) {
-                bestCandidate = { k, v };
-            }
-        });
-    }
-    // @ts-ignore
-    return bestCandidate?.v;
-}
-const TOP_HASH = "__flow_hash";
-async function generateFlowHash(rawReqs, folder, defaultTs) {
-    const elems = await FSFSElement(path.join(dntShim.Deno.cwd(), folder), [], true);
-    const hashes = {};
-    for await (const f of elems.getChildren()) {
-        if (exts.some((e) => f.path.endsWith(e))) {
-            let reqs;
-            if (rawReqs) {
-                // Get language name from path
-                const lang = inferContentTypeFromFilePath(f.path, defaultTs);
-                // Get lock for that language
-                [, reqs] =
-                    Object.entries(rawReqs).find(([lang2, _]) => lang == lang2) ?? [];
+export async function getRawWorkspaceDependencies() {
+    const rawWorkspaceDeps = {};
+    try {
+        for await (const entry of dntShim.Deno.readDir("dependencies")) {
+            if (entry.isDirectory)
+                continue;
+            const filePath = `dependencies/${entry.name}`;
+            const content = await dntShim.Deno.readTextFile(filePath);
+            // Find matching language
+            for (const lang of workspaceDependenciesLanguages) {
+                if (entry.name.endsWith(lang.filename)) {
+                    // Check if out of sync
+                    const contentHash = await generateHash(content + filePath);
+                    const isUpToDate = await checkifMetadataUptodate(filePath, contentHash, undefined);
+                    if (!isUpToDate) {
+                        rawWorkspaceDeps[filePath] = content;
+                    }
+                    break;
+                }
             }
-            // Embed lock into hash
-            hashes[f.path] = await generateHash((await f.getContentText()) + (reqs ?? ""));
         }
     }
-    return { ...hashes, [TOP_HASH]: await generateHash(JSON.stringify(hashes)) };
-}
-export async function generateFlowLockInternal(folder, dryRun, workspace, opts, justUpdateMetadataLock, noStaleMessage, useRawReqs) {
-    if (folder.endsWith(SEP)) {
-        folder = folder.substring(0, folder.length - 1);
-    }
-    const remote_path = folder
-        .replaceAll(SEP, "/")
-        .substring(0, folder.length - ".flow".length);
-    if (!justUpdateMetadataLock && !noStaleMessage) {
-        log.info(`Generating lock for flow ${folder} at ${remote_path}`);
-    }
-    let rawReqs = undefined;
-    if (useRawReqs) {
-        // Find all dependency files in the workspace
-        const globalDeps = await findGlobalDeps();
-        // Find closest dependency files for this flow
-        rawReqs = {};
-        // TODO: PERF: Only include raw reqs for the languages that are in the flow
-        languagesWithRawReqsSupport.map((lang) => {
-            const dep = findClosestRawReqs(lang, folder, globalDeps);
-            if (dep) {
-                // @ts-ignore
-                rawReqs[lang.language] = dep;
-            }
-        });
+    catch {
+        // dependencies directory doesn't exist
     }
-    let hashes = await generateFlowHash(rawReqs, folder, opts.defaultTs);
-    const conf = await readLockfile();
-    if (await checkifMetadataUptodate(folder, hashes[TOP_HASH], conf, TOP_HASH)) {
-        if (!noStaleMessage) {
-            log.info(colors.green(`Flow ${remote_path} metadata is up-to-date, skipping`));
+    return rawWorkspaceDeps;
+}
+export function workspaceDependenciesPathToLanguageAndFilename(path) {
+    const relativePath = path.replace("dependencies/", "");
+    for (const { filename, language } of workspaceDependenciesLanguages) {
+        if (relativePath.endsWith(filename)) {
+            return {
+                name: relativePath === filename ? undefined : relativePath.replace("." + filename, ""),
+                language
+            };
         }
-        return;
     }
-    else if (dryRun) {
-        return remote_path;
-    }
-    if (useRawReqs) {
-        log.warn("If using local lockfiles, following redeployments from Web App will inevitably override generated lockfiles by CLI. To maintain your script's lockfiles you will need to redeploy only from CLI. (Behavior is subject to change)");
-        log.info((await blueColor())(`Found raw requirements (${languagesWithRawReqsSupport
-            .map((l) => l.rrFilename)
-            .join("/")}) for ${folder}, using it`));
-    }
-    const flowValue = (await yamlParseFile(folder + SEP + "flow.yaml"));
-    if (!justUpdateMetadataLock) {
-        const changedScripts = [];
-        //find hashes that do not correspond to previous hashes
-        for (const [path, hash] of Object.entries(hashes)) {
-            if (path == TOP_HASH) {
-                continue;
-            }
-            if (!(await checkifMetadataUptodate(folder, hash, conf, path))) {
-                changedScripts.push(path);
-            }
-        }
-        log.info(`Recomputing locks of ${changedScripts.join(", ")} in ${folder}`);
-        await replaceInlineScripts(flowValue.value.modules, async (path) => await dntShim.Deno.readTextFile(folder + SEP + path), log, folder + SEP, SEP, changedScripts);
-        //removeChangedLocks
-        flowValue.value = await updateFlow(workspace, flowValue.value, remote_path, rawReqs);
-        const inlineScripts = extractInlineScriptsForFlows(flowValue.value.modules, {}, SEP, opts.defaultTs);
-        inlineScripts.forEach((s) => {
-            writeIfChanged(dntShim.Deno.cwd() + SEP + folder + SEP + s.path, s.content);
-        });
-        // Overwrite `flow.yaml` with the new lockfile references
-        writeIfChanged(dntShim.Deno.cwd() + SEP + folder + SEP + "flow.yaml", yamlStringify(flowValue));
-    }
-    hashes = await generateFlowHash(rawReqs, folder, opts.defaultTs);
-    await clearGlobalLock(folder);
-    for (const [path, hash] of Object.entries(hashes)) {
-        await updateMetadataGlobalLock(folder, hash, path);
-    }
-    log.info(colors.green(`Flow ${remote_path} lockfiles updated`));
 }
 // on windows, when using powershell, blue is not readable
 export async function blueColor() {
     const isWin = await getIsWin();
     return isWin ? colors.black : colors.blue;
 }
-export async function generateScriptMetadataInternal(scriptPath, workspace, opts, dryRun, noStaleMessage, globalDeps, codebases, justUpdateMetadataLock) {
+export async function generateScriptMetadataInternal(scriptPath, workspace, opts, dryRun, noStaleMessage, rawWorkspaceDependencies, codebases, justUpdateMetadataLock) {
     const remotePath = scriptPath
         .substring(0, scriptPath.indexOf("."))
         .replaceAll(SEP, "/");
     const language = inferContentTypeFromFilePath(scriptPath, opts.defaultTs);
+    // Filter workspace dependencies to only include those matching the script's language
+    const filteredRawWorkspaceDependencies = {};
+    for (const [depPath, depContent] of Object.entries(rawWorkspaceDependencies)) {
+        const depInfo = workspaceDependenciesPathToLanguageAndFilename(depPath);
+        if (depInfo && depInfo.language === language) {
+            filteredRawWorkspaceDependencies[depPath] = depContent;
+        }
+    }
     const metadataWithType = await parseMetadataFile(remotePath, undefined);
     // read script content
     const scriptContent = await dntShim.Deno.readTextFile(scriptPath);
     const metadataContent = await dntShim.Deno.readTextFile(metadataWithType.path);
-    const rrLang = languagesWithRawReqsSupport.find((l) => language == l.language);
-    const rawReqs = findClosestRawReqs(rrLang, scriptPath, globalDeps);
-    let hash = await generateScriptHash(rawReqs, scriptContent, metadataContent);
+    // Note: rawWorkspaceDependencies are now passed in as parameter instead of being searched hierarchically
+    let hash = await generateScriptHash(filteredRawWorkspaceDependencies, scriptContent, metadataContent);
     if (await checkifMetadataUptodate(remotePath, hash, undefined)) {
         if (!noStaleMessage) {
             log.info(colors.green(`Script ${remotePath} metadata is up-to-date, skipping`));
@@ -159,7 +96,7 @@ export async function generateScriptMetadataInternal(scriptPath, workspace, opts
     if (!opts.schemaOnly && !justUpdateMetadataLock) {
         const hasCodebase = findCodebase(scriptPath, codebases) != undefined;
         if (!hasCodebase) {
-            await updateScriptLock(workspace, scriptContent, language, remotePath, metadataParsedContent, rawReqs);
+            await updateScriptLock(workspace, scriptContent, language, remotePath, metadataParsedContent, filteredRawWorkspaceDependencies);
         }
         else {
             metadataParsedContent.lock = "";
@@ -176,7 +113,7 @@ export async function generateScriptMetadataInternal(scriptPath, workspace, opts
         newMetadataContent = JSON.stringify(metadataParsedContent);
     }
     const metadataContentUsedForHash = newMetadataContent;
-    hash = await generateScriptHash(rawReqs, scriptContent, metadataContentUsedForHash);
+    hash = await generateScriptHash(filteredRawWorkspaceDependencies, scriptContent, metadataContentUsedForHash);
     await updateMetadataGlobalLock(remotePath, hash);
     if (!justUpdateMetadataLock) {
         await dntShim.Deno.writeTextFile(metaPath, newMetadataContent);
@@ -200,15 +137,16 @@ export async function updateScriptSchema(scriptContent, language, metadataConten
         delete metadataContent.no_main_func;
     }
 }
-async function updateScriptLock(workspace, scriptContent, language, remotePath, metadataContent, rawDeps) {
-    if (!(languagesWithRawReqsSupport.some((l) => l.language == language) ||
+async function updateScriptLock(workspace, scriptContent, language, remotePath, metadataContent, rawWorkspaceDependencies) {
+    if (!(workspaceDependenciesLanguages.some((l) => l.language == language) ||
         language == "deno" ||
         language == "rust" ||
         language == "ansible")) {
         return;
     }
-    if (rawDeps) {
-        log.info(`Generating script lock for ${remotePath} with raw deps`);
+    if (Object.keys(rawWorkspaceDependencies).length > 0) {
+        const dependencyPaths = Object.keys(rawWorkspaceDependencies).join(', ');
+        log.info(`Generating script lock for ${remotePath} with raw workspace dependencies: ${dependencyPaths}`);
     }
     // generate the script lock running a dependency job in Windmill and update it inplace
     // TODO: update this once the client is released
@@ -228,7 +166,8 @@ async function updateScriptLock(workspace, scriptContent, language, remotePath,
                     script_path: remotePath,
                 },
             ],
-            raw_deps: rawDeps,
+            raw_workspace_dependencies: Object.keys(rawWorkspaceDependencies).length > 0
+                ? rawWorkspaceDependencies : null,
             entrypoint: remotePath,
         }),
     });
@@ -267,65 +206,6 @@ async function updateScriptLock(workspace, scriptContent, language, remotePath,
         throw new LockfileGenerationError(`Failed to generate lockfile:${rawResponse.statusText}, ${responseText}, ${e}`);
     }
 }
-export async function updateFlow(workspace, flow_value, remotePath, rawDeps) {
-    let rawResponse;
-    if (rawDeps != undefined) {
-        log.info(colors.blue("Using raw requirements for flow dependencies"));
-        // generate the script lock running a dependency job in Windmill and update it inplace
-        const extraHeaders = getHeaders();
-        rawResponse = await fetch(`${workspace.remote}api/w/${workspace.workspaceId}/jobs/run/flow_dependencies`, {
-            method: "POST",
-            headers: {
-                Cookie: `token=${workspace.token}`,
-                "Content-Type": "application/json",
-                ...extraHeaders,
-            },
-            body: JSON.stringify({
-                flow_value,
-                path: remotePath,
-                use_local_lockfiles: true,
-                raw_deps: rawDeps,
-            }),
-        });
-    }
-    else {
-        // Standard dependency resolution on the server
-        const extraHeaders = getHeaders();
-        rawResponse = await fetch(`${workspace.remote}api/w/${workspace.workspaceId}/jobs/run/flow_dependencies`, {
-            method: "POST",
-            headers: {
-                Cookie: `token=${workspace.token}`,
-                "Content-Type": "application/json",
-                ...extraHeaders,
-            },
-            body: JSON.stringify({
-                flow_value,
-                path: remotePath,
-            }),
-        });
-    }
-    let responseText = "reading response failed";
-    try {
-        const res = (await rawResponse.json());
-        if (rawResponse.status != 200) {
-            const msg = res?.["error"]?.["message"];
-            if (msg) {
-                throw new LockfileGenerationError(`Failed to generate lockfile: ${msg}`);
-            }
-            throw new LockfileGenerationError(`Failed to generate lockfile: ${rawResponse.statusText}, ${responseText}`);
-        }
-        return res.updated_flow_value;
-    }
-    catch (e) {
-        try {
-            responseText = await rawResponse.text();
-        }
-        catch {
-            responseText = "";
-        }
-        throw new Error(`Failed to generate lockfile. Status was: ${rawResponse.statusText}, ${responseText}, ${e}`);
-    }
-}
 ////////////////////////////////////////////////////////////////////////////////////////////
 // below functions copied from Windmill's FE inferArgs function. TODO: refactor           //
 ////////////////////////////////////////////////////////////////////////////////////////////
@@ -550,7 +430,7 @@ export async function parseMetadataFile(scriptPath, generateMetadataIfMissing) {
             if (generateMetadataIfMissing) {
                 log.info((await blueColor())(`Generating lockfile and schema for ${metadataFilePath}`));
                 try {
-                    await generateScriptMetadataInternal(generateMetadataIfMissing.path, generateMetadataIfMissing.workspaceRemote, generateMetadataIfMissing, false, false, generateMetadataIfMissing.globalDeps, generateMetadataIfMissing.codebases, false);
+                    await generateScriptMetadataInternal(generateMetadataIfMissing.path, generateMetadataIfMissing.workspaceRemote, generateMetadataIfMissing, false, false, generateMetadataIfMissing.rawWorkspaceDependencies, generateMetadataIfMissing.codebases, false);
                     scriptInitialMetadata = (await yamlParseFile(metadataFilePath));
                     if (!generateMetadataIfMissing.schemaOnly) {
                         replaceLock(scriptInitialMetadata);
@@ -612,8 +492,8 @@ export async function checkifMetadataUptodate(path, hash, conf, subpath) {
         return current == hash;
     }
 }
-export async function generateScriptHash(rawReqs, scriptContent, newMetadataContent) {
-    return await generateHash((rawReqs ?? "") + scriptContent + newMetadataContent);
+export async function generateScriptHash(rawWorkspaceDependencies, scriptContent, newMetadataContent) {
+    return await generateHash(JSON.stringify(rawWorkspaceDependencies) + scriptContent + newMetadataContent);
 }
 export async function clearGlobalLock(path) {
     const conf = await readLockfile();

package/esm/src/utils/script_common.js

@@ -1,8 +1,8 @@
-export const languagesWithRawReqsSupport = [
-    { language: "bun", rrFilename: "package.json" },
-    { language: "python3", rrFilename: "requirements.txt" },
-    { language: "php", rrFilename: "composer.json" },
-    { language: "go", rrFilename: "go.mod" },
+export const workspaceDependenciesLanguages = [
+    { language: "bun", filename: "package.json" },
+    { language: "python3", filename: "requirements.in" },
+    { language: "php", filename: "composer.json" },
+    { language: "go", filename: "go.mod" },
 ];
 export function inferContentTypeFromFilePath(contentPath, defaultTs) {
     if (contentPath.endsWith(".py")) {