windmill-cli 1.600.1 → 1.601.0

package/esm/gen/core/OpenAPI.js

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

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

@@ -13,6 +13,7 @@ import { newPathAssigner, newRawAppPathAssigner, } from "../../../windmill-utils
 import { mergeConfigWithConfigFile } from "../../core/conf.js";
 import { resolveWorkspace } from "../../core/context.js";
 import { requireLogin } from "../../core/auth.js";
+import { getNonDottedPaths } from "../../utils/resource_folders.js";
 const TOP_HASH = "__app_hash";
 export const APP_BACKEND_FOLDER = "backend";
 /**
@@ -26,8 +27,13 @@ async function generateAppHash(rawReqs, folder, rawApp, defaultTs) {
     try {
         const elems = await FSFSElement(runnablesFolder, [], true);
         for await (const f of elems.getChildren()) {
-            if (!rawApp && !f.path.includes(".inline_script.")) {
-                continue;
+            // For normal apps, skip non-script files (metadata files like app.yaml)
+            // For raw apps, all files in backend/ are scripts
+            if (!rawApp) {
+                const isMetadataFile = f.path.endsWith("app.yaml") || f.path.endsWith("app.json");
+                if (isMetadataFile) {
+                    continue;
+                }
             }
             if (exts.some((e) => f.path.endsWith(e))) {
                 // Embed lock into hash
@@ -252,7 +258,7 @@ async function updateRawAppRunnables(workspace, runnables, remotePath, appFolder
  * 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 pathAssigner = newPathAssigner(defaultTs, { skipInlineScriptSuffix: getNonDottedPaths() });
     const processor = async (inlineScript, context) => {
         const language = inlineScript.language;
         const content = inlineScript.content;

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

@@ -17,6 +17,7 @@ import { replaceInlineScripts } from "./app.js";
 import { APP_BACKEND_FOLDER, inferRunnableSchemaFromFile, } from "./app_metadata.js";
 import { loadRunnablesFromBackend } from "./raw_apps.js";
 import { regenerateAgentDocs } from "./generate_agents.js";
+import { hasFolderSuffix, getFolderSuffix } from "../../utils/resource_folders.js";
 const DEFAULT_PORT = 4000;
 const DEFAULT_HOST = "localhost";
 // HTML template with live reload and SQL migration modal
@@ -277,17 +278,17 @@ async function dev(opts) {
     // Validate that we're in a .raw_app folder
     const cwd = process.cwd();
     const currentDirName = path.basename(cwd);
-    if (!currentDirName.endsWith(".raw_app")) {
-        log.error(colors.red(`Error: The dev command must be run inside a .raw_app folder.\n` +
+    if (!hasFolderSuffix(currentDirName, "raw_app")) {
+        log.error(colors.red(`Error: The dev command must be run inside a ${getFolderSuffix("raw_app")} folder.\n` +
             `Current directory: ${currentDirName}\n` +
-            `Please navigate to a folder ending with '.raw_app' before running this command.`));
+            `Please navigate to a folder ending with '${getFolderSuffix("raw_app")}' before running this command.`));
         dntShim.Deno.exit(1);
     }
     // Check for raw_app.yaml
     const rawAppPath = path.join(cwd, "raw_app.yaml");
     if (!fs.existsSync(rawAppPath)) {
         log.error(colors.red(`Error: raw_app.yaml not found in current directory.\n` +
-            `The dev command must be run in a .raw_app folder containing a raw_app.yaml file.`));
+            `The dev command must be run in a ${getFolderSuffix("raw_app")} folder containing a raw_app.yaml file.`));
         dntShim.Deno.exit(1);
     }
     // Resolve workspace and authenticate

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

@@ -7,6 +7,7 @@ import { Command, colors, log, yamlParseFile } from "../../../deps.js";
 import { createBundle } from "./bundle.js";
 import { APP_BACKEND_FOLDER } from "./app_metadata.js";
 import { loadRunnablesFromBackend } from "./raw_apps.js";
+import { hasFolderSuffix, getFolderSuffix } from "../../utils/resource_folders.js";
 /**
  * Validates the structure of raw_app.yaml
  */
@@ -81,8 +82,8 @@ async function lintRawApp(appDir, opts) {
     const warnings = [];
     // Check if we're in a .raw_app folder
     const currentDirName = path.basename(appDir);
-    if (!currentDirName.endsWith(".raw_app")) {
-        errors.push(`Not a raw app folder: '${currentDirName}' does not end with '.raw_app'`);
+    if (!hasFolderSuffix(currentDirName, "raw_app")) {
+        errors.push(`Not a raw app folder: '${currentDirName}' does not end with '${getFolderSuffix("raw_app")}'`);
         return { valid: false, errors, warnings };
     }
     // Check if raw_app.yaml exists

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

@@ -5,6 +5,7 @@ import { resolveWorkspace } from "../../core/context.js";
 import { requireLogin } from "../../core/auth.js";
 import * as wmill from "../../../gen/services.gen.js";
 import path from "node:path";
+import { buildFolderPath } from "../../utils/resource_folders.js";
 // Framework templates - adapted from frontend/src/routes/(root)/(logged)/apps_raw/add/templates.ts
 const reactIndex = `
 import React from 'react'
@@ -393,7 +394,7 @@ CREATE SCHEMA IF NOT EXISTS ${schemaName};
         log.info(colors.gray("You can configure datatables in Workspace Settings > Windmill Data Tables"));
     }
     // Create the directory structure - preserve full path (e.g., f/foobar/x/y becomes f/foobar/x/y.raw_app)
-    const folderName = `${appPath}.raw_app`;
+    const folderName = buildFolderPath(appPath, "raw_app");
     const appDir = path.join(dntShim.Deno.cwd(), folderName);
     // Check if directory already exists
     try {

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

@@ -9,6 +9,7 @@ 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);
@@ -35,9 +36,10 @@ async function dev(opts) {
             }, 100);
         }
     }
-    const DOT_FLOW_SEP = ".flow" + SEP;
+    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(DOT_FLOW_SEP + "flow.yaml")));
+        const paths = pathsToLoad.filter((path) => exts.some((ext) => path.endsWith(ext) || path.endsWith(flowFolderSuffix + flowMetadataFile)));
         if (paths.length == 0) {
             return;
         }
@@ -46,7 +48,7 @@ async function dev(opts) {
             const typ = getTypeStrFromPath(cpath);
             log.info("Detected change in " + cpath + " (" + typ + ")");
             if (typ == "flow") {
-                const localPath = cpath.split(DOT_FLOW_SEP)[0] + DOT_FLOW_SEP;
+                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 = {

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

@@ -7,6 +7,7 @@ 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);
@@ -23,9 +24,7 @@ export async function generateFlowLockInternal(folder, dryRun, workspace, opts,
     if (folder.endsWith(SEP)) {
         folder = folder.substring(0, folder.length - 1);
     }
-    const remote_path = folder
-        .replaceAll(SEP, "/")
-        .substring(0, folder.length - ".flow".length);
+    const remote_path = extractNameFromFolder(folder.replaceAll(SEP, "/"), "flow");
     if (!justUpdateMetadataLock && !noStaleMessage) {
         log.info(`Generating lock for flow ${folder} at ${remote_path}`);
     }

package/esm/src/commands/init/init.js

@@ -34,6 +34,7 @@ async function initAction(opts) {
         else {
             initialConfig.gitBranches = {};
         }
+        initialConfig.nonDottedPaths = true;
         await dntShim.Deno.writeTextFile("wmill.yaml", yamlStringify(initialConfig));
         log.info(colors.green("wmill.yaml created with default settings"));
         // Create lock file

package/esm/src/commands/script/script.js

@@ -17,15 +17,27 @@ import { mergeConfigWithConfigFile, readConfigFile, } from "../../core/conf.js";
 import { listSyncCodebases } from "../../utils/codebase.js";
 import fs from "node:fs";
 import { execSync } from "node:child_process";
+import { isRawAppBackendPath as isRawAppBackendPathInternal, isAppInlineScriptPath as isAppInlineScriptPathInternal, isFlowInlineScriptPath as isFlowInlineScriptPathInternal, isFlowPath, isAppPath, } from "../../utils/resource_folders.js";
 /**
  * Checks if a path is inside a raw app backend folder.
  * Matches patterns like: .../myApp.raw_app/backend/...
  */
 export function isRawAppBackendPath(filePath) {
-    // Normalize path separators for consistent matching
-    const normalizedPath = filePath.replaceAll(SEP, "/");
-    // Check if path contains pattern: *.raw_app/backend/
-    return /\.raw_app\/backend\//.test(normalizedPath);
+    return isRawAppBackendPathInternal(filePath);
+}
+/**
+ * Checks if a path is inside a normal app folder (inline script).
+ * Matches patterns like: .../myApp.app/... or .../myApp__app/...
+ */
+export function isAppInlineScriptPath(filePath) {
+    return isAppInlineScriptPathInternal(filePath);
+}
+/**
+ * Checks if a path is inside a flow folder (inline script).
+ * Matches patterns like: .../myFlow.flow/... or .../myFlow__flow/...
+ */
+export function isFlowInlineScriptPath(filePath) {
+    return isFlowInlineScriptPathInternal(filePath);
 }
 async function push(opts, filePath) {
     opts = await mergeConfigWithConfigFile(opts);
@@ -89,7 +101,8 @@ export async function handleScriptMetadata(path, workspace, alreadySynced, messa
     }
 }
 export async function handleFile(path, workspace, alreadySynced, message, opts, rawWorkspaceDependencies, codebases) {
-    if (!path.includes(".inline_script.") &&
+    if (!isAppInlineScriptPath(path) &&
+        !isFlowInlineScriptPath(path) &&
         !isRawAppBackendPath(path) &&
         exts.some((exts) => path.endsWith(exts))) {
         if (alreadySynced.includes(path)) {
@@ -736,8 +749,8 @@ async function generateMetadata(opts, scriptPath) {
         const elems = await elementsToMap(await FSFSElement(dntShim.Deno.cwd(), codebases, false), (p, isD) => {
             return ((!isD && !exts.some((ext) => p.endsWith(ext))) ||
                 ignore(p, isD) ||
-                p.includes(".flow" + SEP) ||
-                p.includes(".app" + SEP));
+                isFlowPath(p) ||
+                isAppPath(p));
         }, false, {});
         let hasAny = false;
         log.info("Generating metadata for all stale scripts:");

package/esm/src/commands/sync/sync.js

@@ -20,6 +20,7 @@ import { extractInlineScripts as extractInlineScriptsForFlows } from "../../../w
 import { generateFlowLockInternal } from "../flow/flow_metadata.js";
 import { isExecutionModeAnonymous } from "../app/app.js";
 import { APP_BACKEND_FOLDER, generateAppLocksInternal, } from "../app/app_metadata.js";
+import { isFlowPath, isAppPath, isRawAppPath, extractFolderPath, isFlowMetadataFile, isAppMetadataFile, isRawAppMetadataFile, isRawAppFolderMetadataFile, getDeleteSuffix, transformJsonPathToDir, getFolderSuffix, getNonDottedPaths, } from "../../utils/resource_folders.js";
 // Merge CLI options with effective settings, preserving CLI flags as overrides
 function mergeCliWithEffectiveOptions(cliOpts, effectiveOpts) {
     // overlay CLI options on top (undefined cliOpts won't override effectiveOpts)
@@ -567,11 +568,11 @@ export function extractInlineScriptsForApps(key, rec, pathAssigner, toId, remove
 }
 function ZipFSElement(zip, useYaml, defaultTs, resourceTypeToFormatExtension, ignoreCodebaseChanges) {
     async function _internal_file(p, f) {
-        const kind = p.endsWith(".flow.json")
+        const kind = isFlowMetadataFile(p)
             ? "flow"
-            : p.endsWith(".app.json")
+            : isAppMetadataFile(p)
                 ? "app"
-                : p.endsWith(".raw_app.json")
+                : isRawAppMetadataFile(p)
                     ? "raw_app"
                     : p.endsWith(".script.json")
                         ? "script"
@@ -583,13 +584,13 @@ function ZipFSElement(zip, useYaml, defaultTs, resourceTypeToFormatExtension, ig
         const isJson = p.endsWith(".json");
         function transformPath() {
             if (kind == "flow") {
-                return p.replace("flow.json", "flow");
+                return transformJsonPathToDir(p, "flow");
             }
             else if (kind == "app") {
-                return p.replace("app.json", "app");
+                return transformJsonPathToDir(p, "app");
             }
             else if (kind == "raw_app") {
-                return p.replace("raw_app.json", "raw_app");
+                return transformJsonPathToDir(p, "raw_app");
             }
             else if (kind == "dependencies") {
                 return p;
@@ -615,7 +616,8 @@ function ZipFSElement(zip, useYaml, defaultTs, resourceTypeToFormatExtension, ig
                         }
                         let inlineScripts;
                         try {
-                            inlineScripts = extractInlineScriptsForFlows(flow.value.modules, {}, SEP, defaultTs);
+                            inlineScripts = extractInlineScriptsForFlows(flow.value.modules, {}, SEP, defaultTs, undefined, // pathAssigner - let it create one
+                            { skipInlineScriptSuffix: getNonDottedPaths() });
                         }
                         catch (error) {
                             log.error(`Failed to extract inline scripts for flow at path: ${p}`);
@@ -653,7 +655,7 @@ function ZipFSElement(zip, useYaml, defaultTs, resourceTypeToFormatExtension, ig
                         }
                         let inlineScripts;
                         try {
-                            inlineScripts = extractInlineScriptsForApps(undefined, app?.["value"], newPathAssigner(defaultTs), (_, val) => val["name"], false);
+                            inlineScripts = extractInlineScriptsForApps(undefined, app?.["value"], newPathAssigner(defaultTs, { skipInlineScriptSuffix: getNonDottedPaths() }), (_, val) => val["name"], false);
                         }
                         catch (error) {
                             log.error(`Failed to extract inline scripts for app at path: ${p}`);
@@ -1053,7 +1055,7 @@ export async function elementsToMap(els, ignore, json, skips, specificItems) {
             }
         }
         if (isRawAppFile(path)) {
-            const suffix = path.split(".raw_app" + SEP).pop();
+            const suffix = path.split(getFolderSuffix("raw_app") + SEP).pop();
             if (suffix?.startsWith("dist/") ||
                 suffix == "wmill.d.ts" ||
                 suffix == "package-lock.json" ||
@@ -1498,27 +1500,24 @@ export async function ignoreF(wmillconf) {
                 (!isDirectory && whitelist != undefined && !whitelist.approve(p))));
     };
 }
-const FLOW_EXT = ".flow" + SEP;
-const APP_EXT = ".app" + SEP;
-const RAW_APP_EXT = ".raw_app" + SEP;
 // deno-lint-ignore no-inner-declarations
 async function addToChangedIfNotExists(p, tracker) {
     const isScript = exts.some((e) => p.endsWith(e));
     if (isScript) {
-        if (p.includes(FLOW_EXT)) {
-            const folder = p.substring(0, p.indexOf(FLOW_EXT)) + FLOW_EXT;
+        if (isFlowPath(p)) {
+            const folder = extractFolderPath(p, "flow");
             if (!tracker.flows.includes(folder)) {
                 tracker.flows.push(folder);
             }
         }
-        else if (p.includes(APP_EXT)) {
-            const folder = p.substring(0, p.indexOf(APP_EXT)) + APP_EXT;
+        else if (isAppPath(p)) {
+            const folder = extractFolderPath(p, "app");
             if (!tracker.apps.includes(folder)) {
                 tracker.apps.push(folder);
             }
         }
-        else if (p.includes(RAW_APP_EXT)) {
-            const folder = p.substring(0, p.indexOf(RAW_APP_EXT)) + RAW_APP_EXT;
+        else if (isRawAppPath(p)) {
+            const folder = extractFolderPath(p, "raw_app");
             if (!tracker.rawApps.includes(folder)) {
                 tracker.rawApps.push(folder);
             }
@@ -2040,7 +2039,7 @@ export async function push(opts) {
                     const isRawApp = isRawAppFile(changes[0].path);
                     if (isRawApp) {
                         const deleteRawApp = changes.find((change) => change.name === "deleted" &&
-                            change.path.endsWith(".raw_app/raw_app.yaml"));
+                            isRawAppFolderMetadataFile(change.path));
                         if (deleteRawApp) {
                             changes = [deleteRawApp];
                         }
@@ -2178,21 +2177,20 @@ export async function push(opts) {
                                 case "flow":
                                     await wmill.deleteFlowByPath({
                                         workspace: workspaceId,
-                                        path: removeSuffix(target, ".flow/flow.json"),
+                                        path: removeSuffix(target, getDeleteSuffix("flow", "json")),
                                     });
                                     break;
                                 case "app":
                                     await wmill.deleteApp({
                                         workspace: workspaceId,
-                                        path: removeSuffix(target, ".app/app.json"),
+                                        path: removeSuffix(target, getDeleteSuffix("app", "json")),
                                     });
                                     break;
                                 case "raw_app":
-                                    if (target.endsWith(".raw_app/raw_app.yaml") ||
-                                        target.endsWith(".raw_app/raw_app.json")) {
+                                    if (isRawAppFolderMetadataFile(target)) {
                                         await wmill.deleteApp({
                                             workspace: workspaceId,
-                                            path: removeSuffix(target, ".raw_app/raw_app.json"),
+                                            path: removeSuffix(target, getDeleteSuffix("raw_app", "json")),
                                         });
                                     }
                                     break;

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

@@ -2,7 +2,7 @@ import { colors, Input, log, setClient } from "../../../deps.js";
 import { allWorkspaces, list, removeWorkspace } from "./workspace.js";
 import * as wmill from "../../../gen/services.gen.js";
 import { getCurrentGitBranch, getOriginalBranchForWorkspaceForks, isGitRepository } from "../../utils/git.js";
-import { WM_FORK_PREFIX } from "../../main.js";
+import { WM_FORK_PREFIX } from "../../core/constants.js";
 import { tryResolveBranchWorkspace } from "../../core/context.js";
 // NOTE: This import will work after regenerating the API client
 // Run ./gen_wm_client.sh to regenerate after backend changes

package/esm/src/core/conf.js

@@ -4,6 +4,7 @@ import { getCurrentGitBranch, getOriginalBranchForWorkspaceForks, isGitRepositor
 import { join, dirname, resolve, relative } from "node:path";
 import { existsSync } from "node:fs";
 import { execSync } from "node:child_process";
+import { setNonDottedPaths } from "../utils/resource_folders.js";
 export let showDiffs = false;
 export function setShowDiffs(value) {
     showDiffs = value;
@@ -143,6 +144,8 @@ export async function readConfigFile() {
         if (conf?.defaultTs == undefined) {
             log.warn("No defaultTs defined in your wmill.yaml. Using 'bun' as default.");
         }
+        // Initialize global nonDottedPaths setting from config
+        setNonDottedPaths(conf?.nonDottedPaths ?? false);
         return typeof conf == "object" ? conf : {};
     }
     catch (e) {
@@ -191,6 +194,7 @@ export const DEFAULT_SYNC_OPTIONS = {
     includeSettings: false,
     includeKey: false,
     skipWorkspaceDependencies: false,
+    nonDottedPaths: false,
 };
 export async function mergeConfigWithConfigFile(opts) {
     const configFile = await readConfigFile();

package/esm/src/core/constants.js

@@ -0,0 +1,5 @@
+/**
+ * Shared constants used across the CLI.
+ * This file should have minimal imports to avoid circular dependencies.
+ */
+export const WM_FORK_PREFIX = "wm-fork";

package/esm/src/core/context.js

@@ -7,7 +7,7 @@ import { getActiveWorkspace, getWorkspaceByName, allWorkspaces, addWorkspace, }
 import { getLastUsedProfile, setLastUsedProfile } from "./branch-profiles.js";
 import { readConfigFile } from "./conf.js";
 import { getCurrentGitBranch, getOriginalBranchForWorkspaceForks, getWorkspaceIdForWorkspaceForkFromBranchName, isGitRepository, } from "../utils/git.js";
-import { WM_FORK_PREFIX } from "../main.js";
+import { WM_FORK_PREFIX } from "./constants.js";
 // Helper function to select from multiple matching profiles
 async function selectFromMultipleProfiles(profiles, baseUrl, workspaceId, context, configDir) {
     if (profiles.length === 1) {

package/esm/src/main.js

@@ -40,8 +40,9 @@ export { flow, app, script, workspace, resource, resourceType, user, variable, h
 //     console.error(JSON.stringify(event.error, null, 4));
 //   }
 // });
-export const VERSION = "1.600.1";
-export const WM_FORK_PREFIX = "wm-fork";
+export const VERSION = "1.601.0";
+// Re-exported from constants.ts to maintain backwards compatibility
+export { WM_FORK_PREFIX } from "./core/constants.js";
 const command = new Command()
     .name("wmill")
     .action(() => log.info(`Welcome to Windmill CLI ${VERSION}. Use -h for help.`))

package/esm/src/types.js

@@ -17,6 +17,7 @@ import { pushWorkspaceDependencies } from "./commands/dependencies/dependencies.
 import { pushWorkspaceSettings, pushWorkspaceKey } from "./core/settings.js";
 import { pushTrigger } from "./commands/trigger/trigger.js";
 import { pushRawApp } from "./commands/app/raw_apps.js";
+import { isFlowPath, isAppPath, isRawAppPath, extractResourceName, buildFolderPath, } from "./utils/resource_folders.js";
 export const TRIGGER_TYPES = [
     "http",
     "websocket",
@@ -93,12 +94,12 @@ export function showConflict(path, local, remote) {
 export async function pushObj(workspace, p, befObj, newObj, plainSecrets, alreadySynced, message, originalLocalPath) {
     const typeEnding = getTypeStrFromPath(p);
     if (typeEnding === "app") {
-        const appName = p.split(".app" + SEP)[0];
-        await pushApp(workspace, appName, appName + ".app", message);
+        const appName = extractResourceName(p, "app");
+        await pushApp(workspace, appName, buildFolderPath(appName, "app"), message);
     }
     else if (typeEnding === "raw_app") {
-        const rawAppName = p.split(".raw_app" + SEP)[0];
-        await pushRawApp(workspace, rawAppName, rawAppName + ".raw_app", message);
+        const rawAppName = extractResourceName(p, "raw_app");
+        await pushRawApp(workspace, rawAppName, buildFolderPath(rawAppName, "raw_app"), message);
     }
     else if (typeEnding === "folder") {
         await pushFolder(workspace, p, befObj, newObj);
@@ -107,8 +108,8 @@ export async function pushObj(workspace, p, befObj, newObj, plainSecrets, alread
         await pushVariable(workspace, p, befObj, newObj, plainSecrets);
     }
     else if (typeEnding === "flow") {
-        const flowName = p.split(".flow" + SEP)[0];
-        await pushFlow(workspace, flowName, flowName + ".flow", message);
+        const flowName = extractResourceName(p, "flow");
+        await pushFlow(workspace, flowName, buildFolderPath(flowName, "flow"), message);
     }
     else if (typeEnding === "resource") {
         if (!alreadySynced.includes(p)) {
@@ -189,13 +190,13 @@ export function parseFromFile(p) {
     }
 }
 export function getTypeStrFromPath(p) {
-    if (p.includes(".flow" + SEP)) {
+    if (isFlowPath(p)) {
         return "flow";
     }
-    if (p.includes(".app" + SEP)) {
+    if (isAppPath(p)) {
         return "app";
     }
-    if (p.includes(".raw_app" + SEP)) {
+    if (isRawAppPath(p)) {
         return "raw_app";
     }
     if (p.startsWith("dependencies" + SEP)) {

package/esm/src/utils/git.js

@@ -1,6 +1,6 @@
 import { log } from "../../deps.js";
 import { execSync } from "node:child_process";
-import { WM_FORK_PREFIX } from "../main.js";
+import { WM_FORK_PREFIX } from "../core/constants.js";
 export function getCurrentGitBranch() {
     try {
         const result = execSync("git rev-parse --abbrev-ref HEAD", {