windmill-cli 1.588.0 → 1.589.1

package/esm/gen/core/OpenAPI.js

@@ -32,7 +32,7 @@ export const OpenAPI = {
     PASSWORD: undefined,
     TOKEN: getEnv("WM_TOKEN"),
     USERNAME: undefined,
-    VERSION: '1.588.0',
+    VERSION: '1.589.1',
     WITH_CREDENTIALS: true,
     interceptors: {
         request: new Interceptors(),

package/esm/gen/services.gen.js

@@ -4924,18 +4924,16 @@ export const listFlowPathsFromWorkspaceRunnable = (data) => {
  * @param data The data for the request.
  * @param data.workspace
  * @param data.version
- * @param data.path
  * @returns Flow flow details
  * @throws ApiError
  */
 export const getFlowVersion = (data) => {
     return __request(OpenAPI, {
         method: 'GET',
-        url: '/w/{workspace}/flows/get/v/{version}/p/{path}',
+        url: '/w/{workspace}/flows/get/v/{version}',
         path: {
             workspace: data.workspace,
-            version: data.version,
-            path: data.path
+            version: data.version
         }
     });
 };
@@ -4944,7 +4942,6 @@ export const getFlowVersion = (data) => {
  * @param data The data for the request.
  * @param data.workspace
  * @param data.version
- * @param data.path
  * @param data.requestBody Flow deployment message
  * @returns string success
  * @throws ApiError
@@ -4952,11 +4949,10 @@ export const getFlowVersion = (data) => {
 export const updateFlowHistory = (data) => {
     return __request(OpenAPI, {
         method: 'POST',
-        url: '/w/{workspace}/flows/history_update/v/{version}/p/{path}',
+        url: '/w/{workspace}/flows/history_update/v/{version}',
         path: {
             workspace: data.workspace,
-            version: data.version,
-            path: data.path
+            version: data.version
         },
         body: data.requestBody,
         mediaType: 'application/json'
@@ -10308,6 +10304,17 @@ export const listBlacklistedAgentTokens = (data = {}) => {
         }
     });
 };
+/**
+ * get minimum worker version across all workers
+ * @returns string minimum worker version
+ * @throws ApiError
+ */
+export const getMinVersion = () => {
+    return __request(OpenAPI, {
+        method: 'GET',
+        url: '/agent_workers/get_min_version'
+    });
+};
 /**
  * get granular acls
  * @param data The data for the request.

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

@@ -3,35 +3,35 @@ 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 { workspaceDependenciesLanguages, } 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";
+import { mergeConfigWithConfigFile } from "../../core/conf.js";
+import { resolveWorkspace } from "../../core/context.js";
+import { requireLogin } from "../../core/auth.js";
 const TOP_HASH = "__app_hash";
+export const APP_BACKEND_FOLDER = "backend";
 /**
  * Generates a hash for all inline scripts in an app directory
  */
-async function generateAppHash(rawReqs, folder, defaultTs) {
-    const runnablesFolder = path.join(folder, "runnables");
+async function generateAppHash(rawReqs, folder, rawApp, defaultTs) {
+    const runnablesFolder = rawApp
+        ? path.join(folder, APP_BACKEND_FOLDER)
+        : folder;
     const hashes = {};
     try {
         const elems = await FSFSElement(runnablesFolder, [], true);
         for await (const f of elems.getChildren()) {
+            if (!rawApp && !f.path.includes(".inline_script.")) {
+                continue;
+            }
             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 ?? ""));
+                hashes[relativePath] = await generateHash((await f.getContentText()) + JSON.stringify(rawReqs));
             }
         }
     }
@@ -46,7 +46,7 @@ async function generateAppHash(rawReqs, folder, defaultTs) {
 /**
  * Updates locks for inline scripts in an app
  */
-export async function generateAppLocksInternal(appFolder, dryRun, workspace, opts, justUpdateMetadataLock, noStaleMessage) {
+export async function generateAppLocksInternal(appFolder, rawApp, dryRun, workspace, opts, justUpdateMetadataLock, noStaleMessage) {
     if (appFolder.endsWith(SEP)) {
         appFolder = appFolder.substring(0, appFolder.length - 1);
     }
@@ -55,7 +55,7 @@ export async function generateAppLocksInternal(appFolder, dryRun, workspace, opt
         log.info(`Generating locks for app ${appFolder} at ${remote_path}`);
     }
     const rawWorkspaceDependencies = await getRawWorkspaceDependencies();
-    let hashes = await generateAppHash(rawWorkspaceDependencies, appFolder, opts.defaultTs);
+    let hashes = await generateAppHash(rawWorkspaceDependencies, appFolder, rawApp, 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) {
@@ -72,7 +72,7 @@ export async function generateAppLocksInternal(appFolder, dryRun, workspace, opt
             .join("/")}) for ${appFolder}, using them`));
     }
     // Read the app file
-    const appFilePath = path.join(appFolder, "raw_app.yaml");
+    const appFilePath = path.join(appFolder, rawApp ? "raw_app.yaml" : "app.yaml");
     const appFile = (await yamlParseFile(appFilePath));
     if (!justUpdateMetadataLock) {
         const changedScripts = [];
@@ -87,11 +87,21 @@ export async function generateAppLocksInternal(appFolder, dryRun, workspace, opt
         }
         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);
+            if (rawApp) {
+                const runnablesPath = path.join(appFolder, APP_BACKEND_FOLDER) + SEP;
+                const rawAppFile = appFile;
+                // Replace inline scripts for changed runnables
+                replaceInlineScripts(rawAppFile.runnables, runnablesPath, false);
+                // Update the app runnables with new locks
+                rawAppFile.runnables = await updateRawAppRunnables(workspace, rawAppFile.runnables, remote_path, appFolder, rawWorkspaceDependencies, opts.defaultTs);
+            }
+            else {
+                const normalAppFile = appFile;
+                // Replace inline scripts for normal apps
+                replaceInlineScripts(normalAppFile.value, appFolder + SEP, false);
+                // Update the app value with new locks
+                normalAppFile.value = await updateAppInlineScripts(workspace, normalAppFile.value, remote_path, appFolder, rawWorkspaceDependencies, opts.defaultTs);
+            }
             // Write the updated app file
             writeIfChanged(appFilePath, yamlStringify(appFile, yamlOptions));
         }
@@ -100,7 +110,7 @@ export async function generateAppLocksInternal(appFolder, dryRun, workspace, opt
         }
     }
     // Regenerate hashes after updates
-    hashes = await generateAppHash(rawWorkspaceDependencies, appFolder, opts.defaultTs);
+    hashes = await generateAppHash(rawWorkspaceDependencies, appFolder, rawApp, opts.defaultTs);
     await clearGlobalLock(appFolder);
     for (const [scriptPath, hash] of Object.entries(hashes)) {
         await updateMetadataGlobalLock(appFolder, hash, scriptPath);
@@ -108,12 +118,45 @@ export async function generateAppLocksInternal(appFolder, dryRun, workspace, opt
     log.info(colors.green(`App ${remote_path} lockfiles updated`));
 }
 /**
- * Updates locks for all runnables in an app, generating locks inline script by inline script
+ * Traverses an app structure (either app.value for normal apps or app.runnables for raw apps)
+ * and processes all inline scripts found, returning the updated structure
+ */
+async function traverseAndProcessInlineScripts(obj, processor, currentPath = []) {
+    if (!obj || typeof obj !== "object") {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return await Promise.all(obj.map((item, index) => traverseAndProcessInlineScripts(item, processor, [
+            ...currentPath,
+            `[${index}]`,
+        ])));
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (key === "inlineScript" && typeof value === "object") {
+            // Found an inline script - process it
+            result[key] = await processor(value, {
+                path: currentPath,
+                parentKey: key,
+                parentObject: obj,
+            });
+        }
+        else {
+            // Recursively process nested objects
+            result[key] = await traverseAndProcessInlineScripts(value, processor, [
+                ...currentPath,
+                key,
+            ]);
+        }
+    }
+    return result;
+}
+/**
+ * Updates locks for all runnables in a raw 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");
+async function updateRawAppRunnables(workspace, runnables, remotePath, appFolder, rawDeps, defaultTs = "bun") {
+    const runnablesFolder = path.join(appFolder, APP_BACKEND_FOLDER);
     // Ensure runnables folder exists
     try {
         await dntShim.Deno.mkdir(runnablesFolder, { recursive: true });
@@ -122,31 +165,36 @@ async function updateAppRunnables(workspace, runnables, remotePath, appFolder, r
         // Folder may already exist
     }
     const pathAssigner = newPathAssigner(defaultTs);
+    // Process each runnable
+    const updatedRunnables = {};
     for (const [runnableId, runnable] of Object.entries(runnables)) {
         // Only process inline scripts (runnableByName with inlineScript)
         if (runnable?.type !== "runnableByName" || !runnable?.inlineScript) {
+            updatedRunnables[runnableId] = runnable;
             continue;
         }
         const inlineScript = runnable.inlineScript;
         const language = inlineScript.language;
         const content = inlineScript.content;
         if (!content || !language) {
+            updatedRunnables[runnableId] = runnable;
             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`));
+            updatedRunnables[runnableId] = runnable;
             continue;
         }
         // Skip frontend scripts - they don't need locks
         if (language === "frontend") {
+            updatedRunnables[runnableId] = runnable;
             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" : ""}`));
+        log.info(colors.gray(`Generating lock for runnable ${runnableId} (${language})
+        }`));
         try {
-            const lock = await generateInlineScriptLock(workspace, content, language, `${remotePath}/${runnableId}`, langRawDeps);
+            const lock = await generateInlineScriptLock(workspace, content, language, `${remotePath}/${runnableId}`, rawDeps);
             // Determine file extension for this language
             const [basePathO, ext] = pathAssigner.assignPath(runnable.name, language);
             const basePath = basePathO.replaceAll(SEP, "/");
@@ -174,14 +222,72 @@ async function updateAppRunnables(workspace, runnables, remotePath, appFolder, r
         catch (error) {
             log.error(colors.red(`Failed to generate lock for runnable ${runnableId}: ${error.message}`));
             // Continue with other runnables even if one fails
+            updatedRunnables[runnableId] = runnable;
         }
     }
     return updatedRunnables;
 }
+/**
+ * Updates locks for all inline scripts in a normal app, similar to updateRawAppRunnables
+ * but for the app.value structure instead of app.runnables
+ */
+async function updateAppInlineScripts(workspace, appValue, remotePath, appFolder, rawDeps, defaultTs = "bun") {
+    const pathAssigner = newPathAssigner(defaultTs);
+    const processor = async (inlineScript, context) => {
+        const language = inlineScript.language;
+        const content = inlineScript.content;
+        if (!content || !language) {
+            return inlineScript;
+        }
+        // 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(`Inline script at ${context.path.join(".")} is still an !inline reference, skipping`));
+            return inlineScript;
+        }
+        // Skip frontend scripts - they don't need locks
+        if (language === "frontend") {
+            return inlineScript;
+        }
+        // Get the name from the parent object (following extractInlineScriptsForApps pattern)
+        // For normal apps, the name is stored in the component's "name" property
+        const scriptName = context.parentObject?.["name"] || "unnamed";
+        const scriptPath = `${remotePath}/${context.path.join("/")}`;
+        log.info(colors.gray(`Generating lock for inline script "${scriptName}" at ${context.path.join(".")} (${language})`));
+        try {
+            const lock = await generateInlineScriptLock(workspace, content, language, scriptPath, rawDeps);
+            // Determine file extension for this language (following extractInlineScriptsForApps pattern)
+            const [basePathO, ext] = pathAssigner.assignPath(scriptName, language);
+            const basePath = basePathO.replaceAll(SEP, "/");
+            const contentPath = path.join(appFolder, `${basePath}${ext}`);
+            const lockPath = path.join(appFolder, `${basePath}lock`);
+            // Write content to file
+            writeIfChanged(contentPath, content);
+            // Write lock to file if it exists
+            if (lock && lock !== "") {
+                writeIfChanged(lockPath, lock);
+            }
+            // Update the inline script with !inline references
+            const inlineContentRef = `!inline ${basePath}${ext}`;
+            const inlineLockRef = lock && lock !== "" ? `!inline ${basePath}lock` : "";
+            log.info(colors.gray(`  Written ${basePath}${ext}${lock ? ` and ${basePath}lock` : ""}`));
+            return {
+                ...inlineScript,
+                content: inlineContentRef,
+                lock: inlineLockRef,
+            };
+        }
+        catch (error) {
+            log.error(colors.red(`Failed to generate lock for inline script at ${context.path.join(".")}: ${error.message}`));
+            // Return original on error
+            return inlineScript;
+        }
+    };
+    return await traverseAndProcessInlineScripts(appValue, processor);
+}
 /**
  * Generates a lock for a single inline script using the dependencies endpoint
  */
-async function generateInlineScriptLock(workspace, content, language, scriptPath, rawDeps) {
+async function generateInlineScriptLock(workspace, content, language, scriptPath, rawWorkspaceDependencies) {
     const extraHeaders = getHeaders();
     const rawResponse = await fetch(`${workspace.remote}api/w/${workspace.workspaceId}/jobs/run/dependencies`, {
         method: "POST",
@@ -198,7 +304,10 @@ async function generateInlineScriptLock(workspace, content, language, scriptPath
                     script_path: scriptPath,
                 },
             ],
-            raw_deps: rawDeps,
+            raw_workspace_dependencies: rawWorkspaceDependencies &&
+                Object.keys(rawWorkspaceDependencies).length > 0
+                ? rawWorkspaceDependencies
+                : null,
             entrypoint: scriptPath,
         }),
     });
@@ -260,7 +369,7 @@ export async function inferRunnableSchemaFromFile(appFolder, runnableFilePath) {
     const inlineScript = runnable.inlineScript;
     const language = inlineScript.language;
     // Read the actual content from the file
-    const fullFilePath = path.join(appFolder, "runnables", runnableFilePath);
+    const fullFilePath = path.join(appFolder, APP_BACKEND_FOLDER, runnableFilePath);
     let content;
     try {
         content = await dntShim.Deno.readTextFile(fullFilePath);
@@ -285,3 +394,85 @@ export async function inferRunnableSchemaFromFile(appFolder, runnableFilePath) {
         return undefined;
     }
 }
+function getAppFolders(elems, extension) {
+    return Object.keys(elems)
+        .filter((p) => p.endsWith(SEP + extension))
+        .map((p) => p.substring(0, p.length - (SEP + extension).length));
+}
+export async function generateLocksCommand(opts, appPath) {
+    const { generateAppLocksInternal } = await import("./app_metadata.js");
+    const { elementsToMap, FSFSElement } = await import("../sync/sync.js");
+    const { ignoreF } = await import("../sync/sync.js");
+    const { Confirm } = await import("../../../deps.js");
+    if (appPath == "") {
+        appPath = undefined;
+    }
+    const workspace = await resolveWorkspace(opts);
+    await requireLogin(opts);
+    opts = await mergeConfigWithConfigFile(opts);
+    if (appPath) {
+        //TODO: Generate metadata for a specific raw app but handle normal apps to
+        throw new Error("Not implemented");
+        // Generate metadata for a specific app
+        // await generateAppLocksInternal(
+        //   appPath,
+        //   true,
+        //   false,
+        //   workspace,
+        //   opts,
+        //   false,
+        //   false
+        // );
+    }
+    else {
+        // Generate metadata for all apps
+        const ignore = await ignoreF(opts);
+        const elems = await elementsToMap(await FSFSElement(dntShim.Deno.cwd(), [], true), (p, isD) => {
+            return (ignore(p, isD) ||
+                (!isD &&
+                    !p.endsWith(SEP + "raw_app.yaml") &&
+                    !p.endsWith(SEP + "app.yaml")));
+        }, false, {});
+        const rawAppFolders = getAppFolders(elems, "raw_app.yaml");
+        const appFolders = getAppFolders(elems, "app.yaml");
+        let hasAny = false;
+        log.info(`Checking metadata for all apps (${appFolders.length}) and raw apps (${rawAppFolders.length})`);
+        for (const appFolder of rawAppFolders) {
+            const candidate = await generateAppLocksInternal(appFolder, true, true, workspace, opts, false, true);
+            if (candidate) {
+                hasAny = true;
+                log.info(colors.green(`+ ${candidate}`));
+            }
+        }
+        for (const appFolder of appFolders) {
+            const candidate = await generateAppLocksInternal(appFolder, false, true, workspace, opts, false, true);
+            if (candidate) {
+                hasAny = true;
+                log.info(colors.green(`+ ${candidate}`));
+            }
+        }
+        if (hasAny) {
+            if (opts.dryRun) {
+                log.info(colors.gray(`Dry run complete.`));
+                return;
+            }
+            if (!opts.yes &&
+                !(await Confirm.prompt({
+                    message: "Update the metadata of the above apps?",
+                    default: true,
+                }))) {
+                return;
+            }
+        }
+        else {
+            log.info(colors.green.bold("No metadata to update"));
+            return;
+        }
+        for (const appFolder of rawAppFolders) {
+            await generateAppLocksInternal(appFolder, true, false, workspace, opts, false, true);
+        }
+        for (const appFolder of appFolders) {
+            await generateAppLocksInternal(appFolder, false, false, workspace, opts, false, true);
+        }
+    }
+}

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

@@ -6,7 +6,7 @@ import * as wmill from "../../../gen/services.gen.js";
 import { isSuperset } from "../../types.js";
 import { readInlinePathSync } from "../../utils/utils.js";
 import devCommand from "./dev.js";
-import { isVersionsGeq15851 } from "../sync/global.js";
+import { isVersionsGeq1585 } from "../sync/global.js";
 const alreadySynced = [];
 function respecializeFields(fields) {
     Object.entries(fields).forEach(([k, v]) => {
@@ -33,20 +33,30 @@ export function repopulateFields(runnables) {
         }
     });
 }
-export function replaceInlineScripts(rec, localPath) {
+export function replaceInlineScripts(rec, localPath, addType) {
     if (!rec) {
         return;
     }
     if (typeof rec == "object") {
         return Object.entries(rec).flatMap(([k, v]) => {
             if (k == "runType") {
-                if (isVersionsGeq15851()) {
-                    rec["type"] = "path";
+                if (addType) {
+                    if (isVersionsGeq1585()) {
+                        rec["type"] = "path";
+                    }
+                    else {
+                        rec["type"] = "runnableByPath";
+                    }
                 }
             }
             else if (k == "inlineScript" && typeof v == "object") {
-                if (isVersionsGeq15851()) {
-                    rec["type"] = "inline";
+                if (addType) {
+                    if (isVersionsGeq1585()) {
+                        rec["type"] = "inline";
+                    }
+                    else {
+                        rec["type"] = "runnableByName";
+                    }
                 }
                 const o = v;
                 if (o["content"] && o["content"].startsWith("!inline")) {
@@ -59,7 +69,7 @@ export function replaceInlineScripts(rec, localPath) {
                 }
             }
             else {
-                replaceInlineScripts(v, localPath);
+                replaceInlineScripts(v, localPath, addType);
             }
         });
     }
@@ -97,7 +107,7 @@ export async function pushApp(workspace, remotePath, localPath, message) {
     }
     const path = localPath + "app.yaml";
     const localApp = (await yamlParseFile(path));
-    replaceInlineScripts(localApp.value, localPath);
+    replaceInlineScripts(localApp.value, localPath, true);
     await generatingPolicy(localApp, remotePath, localApp?.["public"] ??
         localApp?.["policy"]?.["execution_mode"] == "anonymous");
     if (app) {
@@ -186,7 +196,7 @@ const command = new Command()
     .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");
+    const { generateLocksCommand } = await import("./app_metadata.js");
     await generateLocksCommand(opts, appFolder);
 });
 export default command;

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

@@ -1,20 +1,20 @@
 // deno-lint-ignore-file no-explicit-any
 import * as dntShim from "../../../_dnt.shims.js";
-import { Command, colors, log, getPort, open, windmillUtils, yamlParseFile, } from "../../../deps.js";
+import { Command, colors, log, getPort, open, windmillUtils, yamlParseFile, SEP, } from "../../../deps.js";
 import * as http from "node:http";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import process from "node:process";
 import { writeFileSync } from "node:fs";
 import { WebSocketServer } from "ws";
-import { getDevBuildOptions, ensureNodeModules, createFrameworkPlugins, detectFrameworks } from "./bundle.js";
+import { getDevBuildOptions, ensureNodeModules, createFrameworkPlugins, detectFrameworks, } from "./bundle.js";
 import { wmillTsDev as wmillTs } from "./wmillTsDev.js";
 import * as wmill from "../../../gen/services.gen.js";
 import { resolveWorkspace } from "../../core/context.js";
 import { requireLogin } from "../../core/auth.js";
 import { GLOBAL_CONFIG_OPT } from "../../core/conf.js";
 import { replaceInlineScripts } from "./apps.js";
-import { inferRunnableSchemaFromFile } from "./app_metadata.js";
+import { APP_BACKEND_FOLDER, inferRunnableSchemaFromFile, } from "./app_metadata.js";
 const DEFAULT_PORT = 4000;
 const DEFAULT_HOST = "localhost";
 // HTML template with live reload
@@ -96,7 +96,7 @@ async function dev(opts) {
     const shouldOpen = opts.open ?? true;
     // Detect frameworks to determine default entry point
     const frameworks = detectFrameworks(process.cwd());
-    const defaultEntry = (frameworks.svelte || frameworks.vue) ? "index.ts" : "index.tsx";
+    const defaultEntry = frameworks.svelte || frameworks.vue ? "index.ts" : "index.tsx";
     const entryPoint = opts.entry ?? defaultEntry;
     // Verify entry point exists
     if (!fs.existsSync(entryPoint)) {
@@ -177,7 +177,7 @@ async function dev(opts) {
     // Initial build
     await ctx.rebuild();
     // Watch runnables folder for changes
-    const runnablesPath = path.join(process.cwd(), "runnables");
+    const runnablesPath = path.join(process.cwd(), APP_BACKEND_FOLDER);
     let runnablesWatcher;
     if (fs.existsSync(runnablesPath)) {
         log.info(colors.blue(`👁️  Watching runnables folder at: ${runnablesPath}\n`));
@@ -498,7 +498,7 @@ async function loadRunnables() {
     try {
         const localPath = process.cwd();
         const rawApp = (await yamlParseFile(path.join(localPath, "raw_app.yaml")));
-        replaceInlineScripts(rawApp.runnables, path.join(localPath, "runnables/"));
+        replaceInlineScripts(rawApp.runnables, path.join(localPath, APP_BACKEND_FOLDER) + SEP, true);
         return rawApp?.runnables ?? {};
     }
     catch (error) {
@@ -525,7 +525,8 @@ async function executeRunnable(runnable, workspace, appPath, runnableId, args) {
             }
         }
     }
-    if ((runnable.type === "inline" || runnable.type === "runnableByName") && runnable.inlineScript) {
+    if ((runnable.type === "inline" || runnable.type === "runnableByName") &&
+        runnable.inlineScript) {
         const inlineScript = runnable.inlineScript;
         if (inlineScript.id !== undefined) {
             requestBody.id = inlineScript.id;
@@ -538,7 +539,8 @@ async function executeRunnable(runnable, workspace, appPath, runnableId, args) {
             cache_ttl: inlineScript.cache_ttl,
         };
     }
-    else if ((runnable.type === "path" || runnable.type === "runnableByPath") && runnable.path) {
+    else if ((runnable.type === "path" || runnable.type === "runnableByPath") &&
+        runnable.path) {
         const runType = runnable.runType ?? "script";
         requestBody.path =
             runType !== "hubscript"