windmill-cli 1.641.0 → 1.643.0

package/esm/src/commands/dev/dev.js

@@ -1,146 +0,0 @@
-import * as dntShim from "../../../_dnt.shims.js";
-import { Command, SEP, WebSocketServer, express, getPort, http, log, open, yamlParseFile, } from "../../../deps.js";
-import { getTypeStrFromPath } from "../../types.js";
-import { ignoreF } from "../sync/sync.js";
-import { requireLogin } from "../../core/auth.js";
-import { resolveWorkspace } from "../../core/context.js";
-import { mergeConfigWithConfigFile, readConfigFile, } from "../../core/conf.js";
-import { exts, removeExtensionToPath } from "../script/script.js";
-import { inferContentTypeFromFilePath } from "../../utils/script_common.js";
-import { replaceInlineScripts } from "../../../windmill-utils-internal/src/inline-scripts/replacer.js";
-import { parseMetadataFile } from "../../utils/metadata.js";
-import { getFolderSuffixWithSep, getMetadataFileName, extractFolderPath, } from "../../utils/resource_folders.js";
-const PORT = 3001;
-async function dev(opts) {
-    const workspace = await resolveWorkspace(opts);
-    await requireLogin(opts);
-    log.info("Started dev mode");
-    const conf = await readConfigFile();
-    let currentLastEdit = undefined;
-    const watcher = dntShim.Deno.watchFs(".");
-    const base = await dntShim.Deno.realPath(".");
-    opts = await mergeConfigWithConfigFile(opts);
-    const ignore = await ignoreF(opts);
-    const changesTimeouts = {};
-    async function watchChanges() {
-        for await (const event of watcher) {
-            // console.log(">>>> event", event);
-            const key = event.paths.join(",");
-            if (changesTimeouts[key]) {
-                clearTimeout(changesTimeouts[key]);
-            }
-            // @ts-ignore
-            changesTimeouts[key] = setTimeout(async () => {
-                delete changesTimeouts[key];
-                await loadPaths(event.paths);
-            }, 100);
-        }
-    }
-    const flowFolderSuffix = getFolderSuffixWithSep("flow");
-    const flowMetadataFile = getMetadataFileName("flow", "yaml");
-    async function loadPaths(pathsToLoad) {
-        const paths = pathsToLoad.filter((path) => exts.some((ext) => path.endsWith(ext) || path.endsWith(flowFolderSuffix + flowMetadataFile)));
-        if (paths.length == 0) {
-            return;
-        }
-        const cpath = (await dntShim.Deno.realPath(paths[0])).replace(base + SEP, "");
-        if (!ignore(cpath, false)) {
-            const typ = getTypeStrFromPath(cpath);
-            log.info("Detected change in " + cpath + " (" + typ + ")");
-            if (typ == "flow") {
-                const localPath = extractFolderPath(cpath, "flow");
-                const localFlow = (await yamlParseFile(localPath + "flow.yaml"));
-                await replaceInlineScripts(localFlow.value.modules, async (path) => await dntShim.Deno.readTextFile(localPath + path), log, localPath, SEP, undefined);
-                currentLastEdit = {
-                    type: "flow",
-                    flow: localFlow,
-                    uriPath: localPath,
-                };
-                log.info("Updated " + localPath);
-                broadcastChanges(currentLastEdit);
-            }
-            else if (typ == "script") {
-                const content = await dntShim.Deno.readTextFile(cpath);
-                const splitted = cpath.split(".");
-                const wmPath = splitted[0];
-                const lang = inferContentTypeFromFilePath(cpath, conf.defaultTs);
-                const typed = (await parseMetadataFile(removeExtensionToPath(cpath), undefined))?.payload;
-                currentLastEdit = {
-                    type: "script",
-                    content,
-                    path: wmPath,
-                    language: lang,
-                    tag: typed?.tag,
-                    lock: typed?.lock,
-                };
-                log.info("Updated " + wmPath);
-                broadcastChanges(currentLastEdit);
-            }
-        }
-    }
-    const connectedClients = new Set();
-    // Function to send a message to all connected clients
-    function broadcastChanges(lastEdit) {
-        for (const client of connectedClients.values()) {
-            client.send(JSON.stringify(lastEdit));
-        }
-    }
-    async function startApp() {
-        const app = express.default();
-        const server = http.createServer(app);
-        const wss = new WebSocketServer({ server });
-        // WebSocket server event listeners
-        wss.on("connection", (ws) => {
-            connectedClients.add(ws);
-            console.log("New client connected");
-            ws.on("open", () => {
-                if (currentLastEdit) {
-                    broadcastChanges(currentLastEdit);
-                }
-            });
-            ws.on("close", () => {
-                connectedClients.delete(ws);
-                console.log("Client disconnected");
-            });
-            ws.on("message", (message) => {
-                let data;
-                try {
-                    data = JSON.parse(message.toString());
-                }
-                catch (e) {
-                    console.log("Received invalid JSON: " + message + " " + e);
-                    return;
-                }
-                if (data.type === "load") {
-                    loadPaths([data.path]);
-                }
-            });
-        });
-        // Start the server
-        const port = await getPort.default({ port: 3001 });
-        const url = `${workspace.remote}dev?workspace=${workspace.workspaceId}&local=true&wm_token=${workspace.token}` +
-            (port === PORT ? "" : `&port=${port}`);
-        console.log(`Go to ${url}`);
-        try {
-            open.openApp(open.apps.browser, { arguments: [url] }).catch((error) => {
-                console.error(`Failed to open browser, please navigate to ${url}, error: ${error}`);
-            });
-            console.log("Opened browser for you");
-        }
-        catch (error) {
-            console.error(`Failed to open browser, please navigate to ${url}, ${error}`);
-        }
-        console.log("Dev server will automatically point to the last script edited locally");
-        server.listen(port, () => {
-            console.log(`Server listening on port ${port}`);
-        });
-    }
-    await Promise.all([startApp(), watchChanges()]);
-    console.log("Stopped dev mode");
-}
-const command = new Command()
-    .description("Launch a dev server that will spawn a webserver with HMR")
-    .option("--includes <pattern...:string>", "Filter paths givena glob pattern or path")
-    // deno-lint-ignore no-explicit-any
-    .action(dev);
-export default command;

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

@@ -1,290 +0,0 @@
-// 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 { mergeConfigWithConfigFile } from "../../core/conf.js";
-import { FSFSElement, elementsToMap, ignoreF } from "../sync/sync.js";
-import { replaceInlineScripts } from "../../../windmill-utils-internal/src/inline-scripts/replacer.js";
-import { generateFlowLockInternal } from "./flow_metadata.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(JSON.stringify(jobInfo.result ?? {}, null, 2));
-}
-async function preview(opts, flowPath) {
-    const workspace = await resolveWorkspace(opts);
-    await requireLogin(opts);
-    // Normalize path - ensure it's a directory path to a .flow folder
-    if (!flowPath.endsWith(".flow") && !flowPath.endsWith(".flow" + SEP)) {
-        // Check if it's a flow.yaml file
-        if (flowPath.endsWith("flow.yaml") || flowPath.endsWith("flow.json")) {
-            flowPath = flowPath.substring(0, flowPath.lastIndexOf(SEP));
-        }
-        else {
-            throw new Error("Flow path must be a .flow directory or a flow.yaml file");
-        }
-    }
-    if (!flowPath.endsWith(SEP)) {
-        flowPath += SEP;
-    }
-    // Read and parse the flow definition
-    const localFlow = (await yamlParseFile(flowPath + "flow.yaml"));
-    // Replace inline scripts with their actual content
-    await replaceInlineScripts(localFlow.value.modules, async (path) => await dntShim.Deno.readTextFile(flowPath + path), log, flowPath, SEP);
-    const input = opts.data ? await resolve(opts.data) : {};
-    if (!opts.silent) {
-        log.info(colors.yellow(`Running flow preview for ${flowPath}...`));
-    }
-    log.debug(`Flow value: ${JSON.stringify(localFlow.value, null, 2)}`);
-    // Run the flow preview
-    let result;
-    try {
-        result = await wmill.runFlowPreviewAndWaitResult({
-            workspace: workspace.workspaceId,
-            requestBody: {
-                value: localFlow.value,
-                path: flowPath.substring(0, flowPath.indexOf(".flow")).replaceAll(SEP, "/"),
-                args: input,
-            },
-        });
-    }
-    catch (e) {
-        if (e.body) {
-            log.error(`Flow preview failed: ${JSON.stringify(e.body)}`);
-        }
-        throw e;
-    }
-    if (opts.silent) {
-        console.log(JSON.stringify(result, null, 2));
-    }
-    else {
-        log.info(colors.bold.underline.green("Flow preview completed"));
-        log.info(JSON.stringify(result, null, 2));
-    }
-}
-async function generateLocks(opts, folder) {
-    const workspace = await resolveWorkspace(opts);
-    await requireLogin(opts);
-    opts = await mergeConfigWithConfigFile(opts);
-    if (folder) {
-        // read script metadata file
-        await generateFlowLockInternal(folder, false, workspace, opts);
-    }
-    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);
-            if (candidate) {
-                hasAny = true;
-                log.info(colors.yellow.bold(`~ ${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);
-        }
-    }
-}
-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("preview", "preview a local flow without deploying it. Runs the flow definition from local files.")
-    .arguments("<flow_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 output anything other then the final output. Useful for scripting.")
-    .action(preview)
-    .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("-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/flow/flow_metadata.js

@@ -1,156 +0,0 @@
-import * as dntShim from "../../../_dnt.shims.js";
-import { SEP, colors, log, path, yamlParseFile, yamlStringify, } from "../../../deps.js";
-import { readLockfile, checkifMetadataUptodate, blueColor, clearGlobalLock, updateMetadataGlobalLock, LockfileGenerationError, getRawWorkspaceDependencies, normalizeLockPath, filterWorkspaceDependenciesForScripts, } from "../../utils/metadata.js";
-import { extractInlineScripts as extractInlineScriptsForFlows } from "../../../windmill-utils-internal/src/inline-scripts/extractor.js";
-import { generateHash, getHeaders, writeIfChanged } from "../../utils/utils.js";
-import { exts } from "../script/script.js";
-import { FSFSElement } from "../sync/sync.js";
-import { replaceInlineScripts } from "../../../windmill-utils-internal/src/inline-scripts/replacer.js";
-import { workspaceDependenciesLanguages } from "../../utils/script_common.js";
-import { extractNameFromFolder } from "../../utils/resource_folders.js";
-const TOP_HASH = "__flow_hash";
-async function generateFlowHash(rawWorkspaceDependencies, 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))) {
-            // Embed workspace dependencies into hash
-            // Normalize path to ensure OS-independent hashing
-            const normalizedPath = normalizeLockPath(f.path);
-            hashes[normalizedPath] = await generateHash((await f.getContentText()) + JSON.stringify(rawWorkspaceDependencies));
-        }
-    }
-    return { ...hashes, [TOP_HASH]: await generateHash(JSON.stringify(hashes)) };
-}
-export async function generateFlowLockInternal(folder, dryRun, workspace, opts, justUpdateMetadataLock, noStaleMessage) {
-    if (folder.endsWith(SEP)) {
-        folder = folder.substring(0, folder.length - 1);
-    }
-    const remote_path = extractNameFromFolder(folder.replaceAll(SEP, "/"), "flow");
-    if (!justUpdateMetadataLock && !noStaleMessage) {
-        log.info(`Generating lock for flow ${folder} at ${remote_path}`);
-    }
-    // Always get out-of-sync workspace dependencies
-    const rawWorkspaceDependencies = await getRawWorkspaceDependencies();
-    const flowValue = (await yamlParseFile(folder + SEP + "flow.yaml"));
-    // Filter workspace dependencies based on inline scripts' languages and annotations
-    const filteredDeps = await filterWorkspaceDependenciesForFlow(flowValue.value, rawWorkspaceDependencies, folder);
-    let hashes = await generateFlowHash(filteredDeps, 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;
-    }
-    else if (dryRun) {
-        return remote_path;
-    }
-    if (Object.keys(filteredDeps).length > 0) {
-        log.info((await blueColor())(`Found workspace dependencies (${workspaceDependenciesLanguages
-            .map((l) => l.filename)
-            .join("/")}) for ${folder}, using them`));
-    }
-    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
-        // (path: string, newPath: string) => Deno.renameSync(path, newPath),
-        // (path: string) => Deno.removeSync(path)
-        );
-        //removeChangedLocks
-        flowValue.value = await updateFlow(workspace, flowValue.value, remote_path, filteredDeps);
-        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(filteredDeps, 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`));
-}
-/**
- * Filters raw workspace dependencies for a flow by extracting all inline scripts,
- * filtering deps for each based on language and annotations, then computing the union.
- */
-async function filterWorkspaceDependenciesForFlow(flowValue, rawWorkspaceDependencies, folder) {
-    const inlineScripts = extractInlineScriptsForFlows(structuredClone(flowValue.modules), {}, SEP, undefined);
-    // Filter out lock files and map to common interface
-    const scripts = inlineScripts
-        .filter(s => !s.is_lock)
-        .map(s => ({ content: s.content, language: s.language }));
-    return await filterWorkspaceDependenciesForScripts(scripts, rawWorkspaceDependencies, folder, SEP);
-}
-export async function updateFlow(workspace, flow_value, remotePath, rawWorkspaceDependencies) {
-    let rawResponse;
-    if (Object.keys(rawWorkspaceDependencies).length > 0) {
-        log.info(colors.blue("Using raw workspace dependencies 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_workspace_dependencies: rawWorkspaceDependencies,
-            }),
-        });
-    }
-    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}`);
-    }
-}