windmill-cli 1.586.0 → 1.586.2

package/esm/deps.js

@@ -12,16 +12,16 @@ export { NpmProvider } from "./deps/jsr.io/@windmill-labs/cliffy-command/1.0.0-r
 export { Provider } from "./deps/jsr.io/@windmill-labs/cliffy-command/1.0.0-rc.5/upgrade/mod.js";
 export { CompletionsCommand } from "./deps/jsr.io/@windmill-labs/cliffy-command/1.0.0-rc.5/completions/mod.js";
 // std
-export { ensureDir } from "./deps/jsr.io/@std/fs/1.0.20/mod.js";
-export { SEPARATOR as SEP } from "./deps/jsr.io/@std/path/1.1.3/mod.js";
-export * as path from "./deps/jsr.io/@std/path/1.1.3/mod.js";
+export { ensureDir } from "./deps/jsr.io/@std/fs/1.0.16/mod.js";
+export { SEPARATOR as SEP } from "./deps/jsr.io/@std/path/1.0.8/mod.js";
+export * as path from "./deps/jsr.io/@std/path/1.0.8/mod.js";
 export { encodeHex } from "./deps/jsr.io/@std/encoding/1.0.4/mod.js";
 export { writeAllSync } from "./deps/jsr.io/@std/io/0.225.2/write_all.js";
 export { copy } from "./deps/jsr.io/@std/io/0.225.2/copy.js";
 export { readAll } from "./deps/jsr.io/@std/io/0.225.2/read_all.js";
 export * as log from "./deps/jsr.io/@std/log/0.224.14/mod.js";
-export { stringify as yamlStringify } from "./deps/jsr.io/@std/yaml/1.0.10/mod.js";
-import { parse as yamlParse } from "./deps/jsr.io/@std/yaml/1.0.10/mod.js";
+export { stringify as yamlStringify } from "./deps/jsr.io/@std/yaml/1.0.5/mod.js";
+import { parse as yamlParse } from "./deps/jsr.io/@std/yaml/1.0.5/mod.js";
 export async function yamlParseFile(path, options = {}) {
     try {
         return yamlParse(await dntShim.Deno.readTextFile(path), options);
@@ -48,7 +48,7 @@ export { WebSocketServer, WebSocket } from "ws";
 export * as getPort from "get-port";
 export * as open from "open";
 export * as esMain from "es-main";
-export * as windmillUtils from "@windmill-labs/shared-utils";
+export * as windmillUtils from "./deps/jsr.io/@windmill-labs/shared-utils/1.0.10/lib.es.js";
 import { OpenAPI } from "./gen/index.js";
 export function setClient(token, baseUrl) {
     if (baseUrl === undefined) {

package/esm/gen/services.gen.js

@@ -1485,6 +1485,43 @@ export const rebuildDependencyMap = (data) => {
         }
     });
 };
+/**
+ * get dependents of an imported path
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.importedPath The imported path to get dependents for
+ * @returns DependencyDependent list of dependents
+ * @throws ApiError
+ */
+export const getDependents = (data) => {
+    return __request(OpenAPI, {
+        method: 'GET',
+        url: '/w/{workspace}/workspaces/get_dependents/{imported_path}',
+        path: {
+            workspace: data.workspace,
+            imported_path: data.importedPath
+        }
+    });
+};
+/**
+ * get dependents amounts for multiple imported paths
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.requestBody List of imported paths to get dependents counts for
+ * @returns DependentsAmount list of dependents amounts
+ * @throws ApiError
+ */
+export const getDependentsAmounts = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/w/{workspace}/workspaces/get_dependents_amounts',
+        path: {
+            workspace: data.workspace
+        },
+        body: data.requestBody,
+        mediaType: 'application/json'
+    });
+};
 /**
  * get dependency map
  * @param data The data for the request.
@@ -3681,6 +3718,107 @@ export const isDefaultTagsPerWorkspace = () => {
         url: '/workers/is_default_tags_per_workspace'
     });
 };
+/**
+ * create workspace dependencies
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.requestBody New workspace dependencies
+ * @returns string workspace dependencies created
+ * @throws ApiError
+ */
+export const createWorkspaceDependencies = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/w/{workspace}/workspace_dependencies/create',
+        path: {
+            workspace: data.workspace
+        },
+        body: data.requestBody,
+        mediaType: 'application/json'
+    });
+};
+/**
+ * archive workspace dependencies (require admin)
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.language
+ * @param data.name
+ * @returns unknown result
+ * @throws ApiError
+ */
+export const archiveWorkspaceDependencies = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/w/{workspace}/workspace_dependencies/archive/{language}',
+        path: {
+            workspace: data.workspace,
+            language: data.language
+        },
+        query: {
+            name: data.name
+        }
+    });
+};
+/**
+ * delete workspace dependencies (require admin)
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.language
+ * @param data.name
+ * @returns unknown result
+ * @throws ApiError
+ */
+export const deleteWorkspaceDependencies = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/w/{workspace}/workspace_dependencies/delete/{language}',
+        path: {
+            workspace: data.workspace,
+            language: data.language
+        },
+        query: {
+            name: data.name
+        }
+    });
+};
+/**
+ * list all workspace dependencies
+ * @param data The data for the request.
+ * @param data.workspace
+ * @returns WorkspaceDependencies All workspace dependencies
+ * @throws ApiError
+ */
+export const listWorkspaceDependencies = (data) => {
+    return __request(OpenAPI, {
+        method: 'GET',
+        url: '/w/{workspace}/workspace_dependencies/list',
+        path: {
+            workspace: data.workspace
+        }
+    });
+};
+/**
+ * get latest workspace dependencies by language and name
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.language
+ * @param data.name
+ * @returns WorkspaceDependencies Latest workspace dependencies
+ * @throws ApiError
+ */
+export const getLatestWorkspaceDependencies = (data) => {
+    return __request(OpenAPI, {
+        method: 'GET',
+        url: '/w/{workspace}/workspace_dependencies/get_latest/{language}',
+        path: {
+            workspace: data.workspace,
+            language: data.language
+        },
+        query: {
+            name: data.name
+        }
+    });
+};
 /**
  * archive script by path
  * @param data The data for the request.

package/esm/src/commands/app/app_metadata.js

@@ -0,0 +1,287 @@
+// deno-lint-ignore-file no-explicit-any
+import * as dntShim from "../../../_dnt.shims.js";
+import path from "node:path";
+import { SEP, colors, log, yamlParseFile, yamlStringify, } from "../../../deps.js";
+import { checkifMetadataUptodate, blueColor, clearGlobalLock, updateMetadataGlobalLock, inferSchema, getRawWorkspaceDependencies, } from "../../utils/metadata.js";
+import { workspaceDependenciesLanguages } from "../../utils/script_common.js";
+import { inferContentTypeFromFilePath, } from "../../utils/script_common.js";
+import { generateHash, getHeaders, writeIfChanged } from "../../utils/utils.js";
+import { exts } from "../script/script.js";
+import { FSFSElement, yamlOptions } from "../sync/sync.js";
+import { replaceInlineScripts } from "./apps.js";
+import { newPathAssigner, } from "../../../windmill-utils-internal/src/path-utils/path-assigner.js";
+const TOP_HASH = "__app_hash";
+/**
+ * Generates a hash for all inline scripts in an app directory
+ */
+async function generateAppHash(rawReqs, folder, defaultTs) {
+    const runnablesFolder = path.join(folder, "runnables");
+    const hashes = {};
+    try {
+        const elems = await FSFSElement(runnablesFolder, [], true);
+        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) ?? [];
+                }
+                // Embed lock into hash
+                const relativePath = f.path.replace(runnablesFolder + SEP, "");
+                hashes[relativePath] = await generateHash((await f.getContentText()) + (reqs ?? ""));
+            }
+        }
+    }
+    catch (error) {
+        // If runnables folder doesn't exist, that's okay
+        if (error.name !== "NotFound") {
+            throw error;
+        }
+    }
+    return { ...hashes, [TOP_HASH]: await generateHash(JSON.stringify(hashes)) };
+}
+/**
+ * Updates locks for inline scripts in an app
+ */
+export async function generateAppLocksInternal(appFolder, dryRun, workspace, opts, justUpdateMetadataLock, noStaleMessage) {
+    if (appFolder.endsWith(SEP)) {
+        appFolder = appFolder.substring(0, appFolder.length - 1);
+    }
+    const remote_path = appFolder.replaceAll(SEP, "/");
+    if (!justUpdateMetadataLock && !noStaleMessage) {
+        log.info(`Generating locks for app ${appFolder} at ${remote_path}`);
+    }
+    const rawWorkspaceDependencies = await getRawWorkspaceDependencies();
+    let hashes = await generateAppHash(rawWorkspaceDependencies, appFolder, opts.defaultTs);
+    const conf = await import("../../utils/metadata.js").then((m) => m.readLockfile());
+    if (await checkifMetadataUptodate(appFolder, hashes[TOP_HASH], conf, TOP_HASH)) {
+        if (!noStaleMessage) {
+            log.info(colors.green(`App ${remote_path} metadata is up-to-date, skipping`));
+        }
+        return;
+    }
+    else if (dryRun) {
+        return remote_path;
+    }
+    if (Object.keys(rawWorkspaceDependencies).length > 0) {
+        log.info((await blueColor())(`Found workspace dependencies (${workspaceDependenciesLanguages
+            .map((l) => l.filename)
+            .join("/")}) for ${appFolder}, using them`));
+    }
+    // Read the app file
+    const appFilePath = path.join(appFolder, "raw_app.yaml");
+    const appFile = (await yamlParseFile(appFilePath));
+    if (!justUpdateMetadataLock) {
+        const changedScripts = [];
+        // Find hashes that do not correspond to previous hashes
+        for (const [scriptPath, hash] of Object.entries(hashes)) {
+            if (scriptPath == TOP_HASH) {
+                continue;
+            }
+            if (!(await checkifMetadataUptodate(appFolder, hash, conf, scriptPath))) {
+                changedScripts.push(scriptPath);
+            }
+        }
+        if (changedScripts.length > 0) {
+            log.info(`Recomputing locks of ${changedScripts.join(", ")} in ${appFolder}`);
+            const runnablesPath = path.join(appFolder, "runnables") + SEP;
+            // Replace inline scripts for changed runnables
+            await replaceInlineScripts(appFile.runnables, runnablesPath);
+            // Update the app runnables with new locks
+            appFile.runnables = await updateAppRunnables(workspace, appFile.runnables, remote_path, appFolder, rawWorkspaceDependencies, opts.defaultTs);
+            // Write the updated app file
+            writeIfChanged(appFilePath, yamlStringify(appFile, yamlOptions));
+        }
+        else {
+            log.info(colors.gray(`No scripts changed in ${appFolder}`));
+        }
+    }
+    // Regenerate hashes after updates
+    hashes = await generateAppHash(rawWorkspaceDependencies, appFolder, opts.defaultTs);
+    await clearGlobalLock(appFolder);
+    for (const [scriptPath, hash] of Object.entries(hashes)) {
+        await updateMetadataGlobalLock(appFolder, hash, scriptPath);
+    }
+    log.info(colors.green(`App ${remote_path} lockfiles updated`));
+}
+/**
+ * Updates locks for all runnables in an app, generating locks inline script by inline script
+ * Also writes content and locks back to the runnables folder
+ */
+async function updateAppRunnables(workspace, runnables, remotePath, appFolder, rawDeps, defaultTs = "bun") {
+    const updatedRunnables = { ...runnables };
+    const runnablesFolder = path.join(appFolder, "runnables");
+    // Ensure runnables folder exists
+    try {
+        await dntShim.Deno.mkdir(runnablesFolder, { recursive: true });
+    }
+    catch {
+        // Folder may already exist
+    }
+    const pathAssigner = newPathAssigner(defaultTs);
+    for (const [runnableId, runnable] of Object.entries(runnables)) {
+        // Only process inline scripts (runnableByName with inlineScript)
+        if (runnable?.type !== "runnableByName" || !runnable?.inlineScript) {
+            continue;
+        }
+        const inlineScript = runnable.inlineScript;
+        const language = inlineScript.language;
+        const content = inlineScript.content;
+        if (!content || !language) {
+            continue;
+        }
+        // Skip if content is still an !inline reference (should have been replaced by replaceInlineScripts)
+        if (typeof content === "string" && content.startsWith("!inline ")) {
+            log.warn(colors.yellow(`Runnable ${runnableId} content is still an !inline reference, skipping`));
+            continue;
+        }
+        // Skip frontend scripts - they don't need locks
+        if (language === "frontend") {
+            continue;
+        }
+        // Find raw deps for this language if available
+        const langRawDeps = rawDeps?.[language];
+        log.info(colors.gray(`Generating lock for runnable ${runnableId} (${language})${langRawDeps ? " with raw deps" : ""}`));
+        try {
+            const lock = await generateInlineScriptLock(workspace, content, language, `${remotePath}/${runnableId}`, langRawDeps);
+            // Determine file extension for this language
+            const [basePathO, ext] = pathAssigner.assignPath(runnable.name, language);
+            const basePath = basePathO.replaceAll(SEP, "/");
+            const contentPath = path.join(runnablesFolder, `${basePath}${ext}`);
+            const lockPath = path.join(runnablesFolder, `${basePath}lock`);
+            // Write content to file
+            writeIfChanged(contentPath, content);
+            // Write lock to file if it exists
+            if (lock && lock !== "") {
+                writeIfChanged(lockPath, lock);
+            }
+            // Update the runnable with !inline references (preserve existing schema)
+            const inlineContentRef = `!inline ${basePath}${ext}`;
+            const inlineLockRef = lock && lock !== "" ? `!inline ${basePath}lock` : "";
+            updatedRunnables[runnableId] = {
+                ...runnable,
+                inlineScript: {
+                    ...inlineScript,
+                    content: inlineContentRef,
+                    lock: inlineLockRef,
+                },
+            };
+            log.info(colors.gray(`  Written ${basePath}${ext}${lock ? ` and ${basePath}lock` : ""}`));
+        }
+        catch (error) {
+            log.error(colors.red(`Failed to generate lock for runnable ${runnableId}: ${error.message}`));
+            // Continue with other runnables even if one fails
+        }
+    }
+    return updatedRunnables;
+}
+/**
+ * Generates a lock for a single inline script using the dependencies endpoint
+ */
+async function generateInlineScriptLock(workspace, content, language, scriptPath, rawDeps) {
+    const extraHeaders = getHeaders();
+    const rawResponse = await fetch(`${workspace.remote}api/w/${workspace.workspaceId}/jobs/run/dependencies`, {
+        method: "POST",
+        headers: {
+            Cookie: `token=${workspace.token}`,
+            "Content-Type": "application/json",
+            ...extraHeaders,
+        },
+        body: JSON.stringify({
+            raw_scripts: [
+                {
+                    raw_code: content,
+                    language: language,
+                    script_path: scriptPath,
+                },
+            ],
+            raw_deps: rawDeps,
+            entrypoint: scriptPath,
+        }),
+    });
+    if (!rawResponse.ok) {
+        const text = await rawResponse.text();
+        throw new Error(`Dependency generation failed: ${rawResponse.status} ${rawResponse.statusText}\n${text}`);
+    }
+    let responseText = "reading response failed";
+    try {
+        responseText = await rawResponse.text();
+        const response = JSON.parse(responseText);
+        const lock = response.lock;
+        if (lock === undefined) {
+            if (response?.["error"]?.["message"]) {
+                throw new Error(`Failed to generate lockfile: ${response?.["error"]?.["message"]}`);
+            }
+            throw new Error(`Failed to generate lockfile: ${JSON.stringify(response, null, 2)}`);
+        }
+        return lock ?? "";
+    }
+    catch (e) {
+        throw new Error(`Failed to parse dependency response: ${rawResponse.statusText}, ${responseText}, ${e.message}`);
+    }
+}
+/**
+ * Infers schema for a single runnable from its file content.
+ * Used by dev server to update schema in memory (for wmill.d.ts generation).
+ * Does NOT write to raw_app.yaml - schema is kept in memory only.
+ *
+ * @param appFolder - The folder containing the raw app
+ * @param runnableFilePath - The path to the changed runnable file (relative to runnables folder)
+ * @returns The runnable ID and inferred schema, or undefined if inference failed/not applicable
+ */
+export async function inferRunnableSchemaFromFile(appFolder, runnableFilePath) {
+    // Extract runnable ID from file path (e.g., "myRunnable.inline_script.ts" -> "myRunnable")
+    const fileName = path.basename(runnableFilePath);
+    // Skip lock files
+    if (fileName.endsWith(".lock")) {
+        return undefined;
+    }
+    // Match pattern: {runnableId}.inline_script.{ext}
+    const match = fileName.match(/^(.+)\.inline_script\.[^.]+$/);
+    if (!match) {
+        return undefined;
+    }
+    const runnableId = match[1];
+    // Read the app file to get the language
+    const appFilePath = path.join(appFolder, "raw_app.yaml");
+    const appFile = (await yamlParseFile(appFilePath));
+    if (!appFile.runnables?.[runnableId]) {
+        log.warn(colors.yellow(`Runnable ${runnableId} not found in raw_app.yaml`));
+        return undefined;
+    }
+    const runnable = appFile.runnables[runnableId];
+    // Only process inline scripts
+    if (!runnable?.inlineScript) {
+        return undefined;
+    }
+    const inlineScript = runnable.inlineScript;
+    const language = inlineScript.language;
+    // Read the actual content from the file
+    const fullFilePath = path.join(appFolder, "runnables", runnableFilePath);
+    let content;
+    try {
+        content = await dntShim.Deno.readTextFile(fullFilePath);
+    }
+    catch {
+        log.warn(colors.yellow(`Could not read file: ${fullFilePath}`));
+        return undefined;
+    }
+    // Infer schema from script content
+    const currentSchema = inlineScript.schema;
+    const remotePath = appFolder.replaceAll(SEP, "/");
+    try {
+        const schemaResult = await inferSchema(language, content, currentSchema, `${remotePath}/${runnableId}`);
+        log.info(colors.green(`  Inferred schema for ${runnableId}`));
+        return {
+            runnableId: runnableId,
+            schema: schemaResult.schema,
+        };
+    }
+    catch (schemaError) {
+        log.warn(colors.yellow(`Failed to infer schema for ${runnableId}: ${schemaError.message}`));
+        return undefined;
+    }
+}

package/esm/src/commands/app/apps.js

@@ -5,7 +5,57 @@ import { colors, Command, log, SEP, Table, windmillUtils, yamlParseFile, } from
 import * as wmill from "../../../gen/services.gen.js";
 import { isSuperset } from "../../types.js";
 import { readInlinePathSync } from "../../utils/utils.js";
+import devCommand from "./dev.js";
 const alreadySynced = [];
+function respecializeFields(fields) {
+    Object.entries(fields).forEach(([k, v]) => {
+        if (typeof v == "object") {
+            if (v.value !== undefined) {
+                fields[k] = { value: v.value, type: "static" };
+            }
+            else if (v.expr !== undefined) {
+                fields[k] = { expr: v.expr, allowUserResources: v.allowUserResources, type: "javascript" };
+            }
+        }
+    });
+}
+export function repopulateFields(runnables) {
+    Object.values(runnables).forEach((v) => {
+        if (typeof v == "object") {
+            if (v.fields !== undefined) {
+                respecializeFields(v.fields);
+            }
+        }
+    });
+}
+export function replaceInlineScripts(rec, localPath) {
+    if (!rec) {
+        return;
+    }
+    if (typeof rec == "object") {
+        return Object.entries(rec).flatMap(([k, v]) => {
+            if (k == 'runType') {
+                rec["type"] = 'path';
+            }
+            else if (k == "inlineScript" && typeof v == "object") {
+                rec["type"] = 'inline';
+                const o = v;
+                if (o["content"] && o["content"].startsWith("!inline")) {
+                    const basePath = localPath + o["content"].split(" ")[1];
+                    o["content"] = readInlinePathSync(basePath);
+                }
+                if (o["lock"] && o["lock"].startsWith("!inline")) {
+                    const basePath = localPath + o["lock"].split(" ")[1];
+                    o["lock"] = readInlinePathSync(basePath);
+                }
+            }
+            else {
+                replaceInlineScripts(v, localPath);
+            }
+        });
+    }
+    return [];
+}
 export function isExecutionModeAnonymous(app) {
     return app?.["policy"]?.["execution_mode"] == "anonymous";
 }
@@ -38,34 +88,8 @@ export async function pushApp(workspace, remotePath, localPath, message) {
     }
     const path = localPath + "app.yaml";
     const localApp = (await yamlParseFile(path));
-    function replaceInlineScripts(rec) {
-        if (!rec) {
-            return;
-        }
-        if (typeof rec == "object") {
-            return Object.entries(rec).flatMap(([k, v]) => {
-                if (k == "inlineScript" && typeof v == "object") {
-                    const o = v;
-                    if (o["content"] && o["content"].startsWith("!inline")) {
-                        const basePath = localPath + o["content"].split(" ")[1];
-                        o["content"] = readInlinePathSync(basePath);
-                    }
-                    if (o["lock"] && o["lock"].startsWith("!inline")) {
-                        const basePath = localPath + o["lock"].split(" ")[1];
-                        o["lock"] = readInlinePathSync(basePath);
-                    }
-                }
-                else {
-                    replaceInlineScripts(v);
-                }
-            });
-        }
-        return [];
-    }
-    replaceInlineScripts(localApp.value);
-    // console.log(localApp, localApp?.["policy"]);
-    await generatingPolicy(localApp, remotePath, localApp?.["public"] ?? (localApp.policy ? isExecutionModeAnonymous(localApp) : false));
-    // console.log(localApp, localApp?.["policy"]);
+    replaceInlineScripts(localApp.value, localPath);
+    await generatingPolicy(localApp, remotePath, localApp?.["public"] ?? false);
     if (app) {
         if (isSuperset(localApp, app)) {
             log.info(colors.green(`App ${remotePath} is up to date`));
@@ -93,7 +117,7 @@ export async function pushApp(workspace, remotePath, localPath, message) {
         });
     }
 }
-async function generatingPolicy(app, path, publicApp) {
+export async function generatingPolicy(app, path, publicApp) {
     log.info(colors.gray(`Generating fresh policy for app ${path}...`));
     try {
         app.policy = await windmillUtils.updatePolicy(app.value, undefined);
@@ -137,12 +161,22 @@ async function push(opts, filePath, remotePath) {
     const workspace = await resolveWorkspace(opts);
     await requireLogin(opts);
     await pushApp(workspace.workspaceId, remotePath, filePath);
-    log.info(colors.bold.underline.green("Flow pushed"));
+    log.info(colors.bold.underline.green("App pushed"));
 }
 const command = new Command()
     .description("app related commands")
     .action(list)
     .command("push", "push a local app ")
     .arguments("<file_path:string> <remote_path:string>")
-    .action(push);
+    .action(push)
+    .command("dev", devCommand)
+    .command("generate-locks", "re-generate the lockfiles for app runnables inline scripts that have changed")
+    .arguments("[app_folder:string]")
+    .option("--yes", "Skip confirmation prompt")
+    .option("--dry-run", "Perform a dry run without making changes")
+    .option("--default-ts <runtime:string>", "Default TypeScript runtime (bun or deno)")
+    .action(async (opts, appFolder) => {
+    const { generateLocksCommand } = await import("./raw_apps.js");
+    await generateLocksCommand(opts, appFolder);
+});
 export default command;