windmill-cli 1.586.0 → 1.586.1

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

@@ -1,23 +1,25 @@
 import * as dntShim from "../../../_dnt.shims.js";
 import { requireLogin } from "../../core/auth.js";
 import { fetchVersion, resolveWorkspace } from "../../core/context.js";
-import { colors, Command, Confirm, ensureDir, minimatch, path, log, yamlStringify, yamlParseContent, SEP, } from "../../../deps.js";
+import { colors, Command, Confirm, ensureDir, log, minimatch, path, SEP, yamlParseContent, yamlStringify, } from "../../../deps.js";
 import * as wmill from "../../../gen/services.gen.js";
 import { getTypeStrFromPath, parseFromPath, pushObj, showConflict, showDiff, } from "../../types.js";
 import { downloadZip } from "./pull.js";
-import { exts, findContentFile, findGlobalDeps, findResourceFile, handleScriptMetadata, removeExtensionToPath, } from "../script/script.js";
+import { exts, findContentFile, findResourceFile, handleScriptMetadata, removeExtensionToPath, } from "../script/script.js";
 import { handleFile } from "../script/script.js";
-import { deepEqual, isFileResource } from "../../utils/utils.js";
-import { getEffectiveSettings, validateBranchConfiguration, mergeConfigWithConfigFile, } from "../../core/conf.js";
-import { getSpecificItemsForCurrentBranch, isSpecificItem, getBranchSpecificPath, fromBranchSpecificPath, isCurrentBranchFile, isBranchSpecificFile, } from "../../core/specific_items.js";
+import { deepEqual, isFileResource, isRawAppFile, isWorkspaceDependencies } from "../../utils/utils.js";
+import { getEffectiveSettings, mergeConfigWithConfigFile, validateBranchConfiguration, } from "../../core/conf.js";
+import { fromBranchSpecificPath, getBranchSpecificPath, getSpecificItemsForCurrentBranch, isBranchSpecificFile, isCurrentBranchFile, isSpecificItem, } from "../../core/specific_items.js";
 import { getCurrentGitBranch } from "../../utils/git.js";
 import { removePathPrefix } from "../../types.js";
 import { listSyncCodebases } from "../../utils/codebase.js";
-import { generateFlowLockInternal, generateScriptMetadataInternal, readLockfile, } from "../../utils/metadata.js";
+import { generateScriptMetadataInternal, getRawWorkspaceDependencies, readLockfile, workspaceDependenciesPathToLanguageAndFilename, } from "../../utils/metadata.js";
 import { pushResource } from "../resource/resource.js";
 import { newPathAssigner, } from "../../../windmill-utils-internal/src/path-utils/path-assigner.js";
 import { extractInlineScripts as extractInlineScriptsForFlows } from "../../../windmill-utils-internal/src/inline-scripts/extractor.js";
+import { generateFlowLockInternal } from "../flow/flow_metadata.js";
 import { isExecutionModeAnonymous } from "../app/apps.js";
+import { generateAppLocksInternal } from "../app/app_metadata.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)
@@ -174,16 +176,51 @@ export const yamlOptions = {
     noRefs: true,
     skipInvalid: true,
 };
-export function extractInlineScriptsForApps(rec, pathAssigner) {
+function extractFields(fields) {
+    Object.entries(fields).forEach(([k, v]) => {
+        if (typeof v == "object") {
+            if (v.type == "static") {
+                fields[k] = { value: v.value };
+            }
+            else if (v.type == "javascript") {
+                fields[k] = { expr: v.expr, allowUserResources: v.allowUserResources };
+            }
+            else if (v.type == "user") {
+                fields[k] = undefined;
+            }
+        }
+        // if (k == 'runType') {
+        //   fields["type"] = undefined
+        //   fields["schema"] = undefined
+        // }
+    });
+}
+export function extractFieldsForRawApps(runnables) {
+    Object.values(runnables).forEach((v) => {
+        if (typeof v == "object") {
+            if (v.fields !== undefined) {
+                extractFields(v.fields);
+            }
+        }
+    });
+}
+export function extractInlineScriptsForApps(key, rec, pathAssigner, toId) {
     if (!rec) {
         return [];
     }
     if (typeof rec == "object") {
         return Object.entries(rec).flatMap(([k, v]) => {
-            if (k == "inlineScript" && typeof v == "object") {
+            if (k == 'runType') {
+                rec["type"] = undefined;
+                rec["schema"] = undefined;
+                return [];
+            }
+            else if (k == "inlineScript" && typeof v == "object") {
+                rec["type"] = undefined;
                 const o = v;
-                const name = rec["name"];
-                const [basePath, ext] = pathAssigner.assignPath(name, o["language"]);
+                const name = toId(key ?? "", rec);
+                const [basePathO, ext] = pathAssigner.assignPath(name, o["language"]);
+                const basePath = basePathO.replaceAll(SEP, "/");
                 const r = [];
                 if (o["content"]) {
                     const content = o["content"];
@@ -201,10 +238,11 @@ export function extractInlineScriptsForApps(rec, pathAssigner) {
                         content: lock,
                     });
                 }
+                o.schema = undefined;
                 return r;
             }
             else {
-                return extractInlineScriptsForApps(v, pathAssigner);
+                return extractInlineScriptsForApps(k, v, pathAssigner, toId);
             }
         });
     }
@@ -212,15 +250,19 @@ export function extractInlineScriptsForApps(rec, pathAssigner) {
 }
 function ZipFSElement(zip, useYaml, defaultTs, resourceTypeToFormatExtension, ignoreCodebaseChanges) {
     async function _internal_file(p, f) {
-        const kind = p.endsWith("flow.json")
+        const kind = p.endsWith(".flow.json")
             ? "flow"
-            : p.endsWith("app.json")
+            : p.endsWith(".app.json")
                 ? "app"
-                : p.endsWith("script.json")
-                    ? "script"
-                    : p.endsWith("resource.json")
-                        ? "resource"
-                        : "other";
+                : p.endsWith(".raw_app.json")
+                    ? "raw_app"
+                    : p.endsWith(".script.json")
+                        ? "script"
+                        : p.endsWith(".resource.json")
+                            ? "resource"
+                            : p.startsWith("dependencies/")
+                                ? "dependencies"
+                                : "other";
         const isJson = p.endsWith(".json");
         function transformPath() {
             if (kind == "flow") {
@@ -229,6 +271,12 @@ function ZipFSElement(zip, useYaml, defaultTs, resourceTypeToFormatExtension, ig
             else if (kind == "app") {
                 return p.replace("app.json", "app");
             }
+            else if (kind == "raw_app") {
+                return p.replace("raw_app.json", "raw_app");
+            }
+            else if (kind == "dependencies") {
+                return p;
+            }
             else {
                 return useYaml && isJson ? p.replaceAll(".json", ".yaml") : p;
             }
@@ -236,7 +284,7 @@ function ZipFSElement(zip, useYaml, defaultTs, resourceTypeToFormatExtension, ig
         const finalPath = transformPath();
         const r = [
             {
-                isDirectory: kind == "flow" || kind == "app",
+                isDirectory: kind == "flow" || kind == "app" || kind == "raw_app",
                 path: finalPath,
                 async *getChildren() {
                     if (kind == "flow") {
@@ -288,7 +336,7 @@ function ZipFSElement(zip, useYaml, defaultTs, resourceTypeToFormatExtension, ig
                         }
                         let inlineScripts;
                         try {
-                            inlineScripts = extractInlineScriptsForApps(app?.["value"], newPathAssigner(defaultTs));
+                            inlineScripts = extractInlineScriptsForApps(undefined, app?.["value"], newPathAssigner(defaultTs), (_, val) => val["name"]);
                         }
                         catch (error) {
                             log.error(`Failed to extract inline scripts for app at path: ${p}`);
@@ -319,6 +367,77 @@ function ZipFSElement(zip, useYaml, defaultTs, resourceTypeToFormatExtension, ig
                             },
                         };
                     }
+                    else if (kind == "raw_app") {
+                        let rawApp;
+                        try {
+                            rawApp = JSON.parse(await f.async("text"));
+                        }
+                        catch (error) {
+                            log.error(`Failed to parse app.yaml at path: ${p}`);
+                            throw error;
+                        }
+                        if (rawApp?.["policy"]?.["execution_mode"] == "anonymous") {
+                            rawApp.public = true;
+                        }
+                        // console.log("rawApp", rawApp);
+                        rawApp.policy = undefined;
+                        let inlineScripts;
+                        const value = rawApp?.["value"];
+                        // console.log("FOOB", value?.["runnables"])
+                        extractFieldsForRawApps(value?.["runnables"]);
+                        try {
+                            inlineScripts = extractInlineScriptsForApps(undefined, value, newPathAssigner(defaultTs), (key, val_) => key);
+                        }
+                        catch (error) {
+                            log.error(`Failed to extract inline scripts for raw app at path: ${p}`);
+                            throw error;
+                        }
+                        try {
+                            for (const [filePath, content] of Object.entries(value?.["files"] ?? [])) {
+                                yield {
+                                    isDirectory: false,
+                                    path: path.join(finalPath, filePath.substring(1)),
+                                    async *getChildren() { },
+                                    // deno-lint-ignore require-await
+                                    async getContentText() {
+                                        if (typeof content !== "string") {
+                                            throw new Error(`Content of raw app file ${filePath} is not a string`);
+                                        }
+                                        return content;
+                                    },
+                                };
+                            }
+                        }
+                        catch (error) {
+                            log.error(`Failed to extract files for raw app at path: ${p}`);
+                            throw error;
+                        }
+                        for (const s of inlineScripts) {
+                            yield {
+                                isDirectory: false,
+                                path: path.join(finalPath, "runnables", s.path),
+                                async *getChildren() { },
+                                // deno-lint-ignore require-await
+                                async getContentText() {
+                                    return s.content;
+                                },
+                            };
+                        }
+                        const runnables = value?.["runnables"];
+                        if (runnables) {
+                            rawApp.runnables = runnables;
+                            delete rawApp?.["value"];
+                        }
+                        yield {
+                            isDirectory: false,
+                            path: path.join(finalPath, "raw_app.yaml"),
+                            async *getChildren() { },
+                            // deno-lint-ignore require-await
+                            async getContentText() {
+                                return yamlStringify(rawApp, yamlOptions);
+                            },
+                        };
+                    }
                 },
                 async getContentText() {
                     const content = await f.async("text");
@@ -374,7 +493,7 @@ function ZipFSElement(zip, useYaml, defaultTs, resourceTypeToFormatExtension, ig
                             ? yamlStringify(parsed, yamlOptions)
                             : JSON.stringify(parsed, null, 2);
                     }
-                    return useYaml && isJson
+                    return useYaml && isJson && kind != "dependencies"
                         ? (() => {
                             try {
                                 return yamlStringify(JSON.parse(content), yamlOptions);
@@ -490,16 +609,14 @@ export async function* readDirRecursiveWithIgnore(ignore, root) {
     ];
     while (stack.length > 0) {
         const e = stack.pop();
-        // console.log(e.path);
         yield e;
         for await (const e2 of e.c()) {
             if (e2.isDirectory) {
                 const dirName = e2.path.split(SEP).pop();
-                if (dirName == "node_modules" || dirName?.startsWith(".")) {
+                if (dirName == "node_modules" || dirName == ".claude" || dirName?.startsWith(".")) {
                     continue;
                 }
             }
-            // console.log(e2.path);
             stack.push({
                 path: e2.path,
                 ignored: e.ignored || ignore(e2.path, e2.isDirectory),
@@ -515,12 +632,47 @@ export async function elementsToMap(els, ignore, json, skips, specificItems) {
     const map = {};
     const processedBasePaths = new Set();
     for await (const entry of readDirRecursiveWithIgnore(ignore, els)) {
-        if (entry.isDirectory || entry.ignored)
+        // console.log("FOO", entry.path, entry.ignored, entry.isDirectory)
+        if (entry.isDirectory || entry.ignored) {
             continue;
+        }
         const path = entry.path;
-        if (json && path.endsWith(".yaml") && !isFileResource(path))
-            continue;
-        if (!json && path.endsWith(".json") && !isFileResource(path))
+        if (!isFileResource(path) && !isRawAppFile(path) && !isWorkspaceDependencies(path)) {
+            if (json && path.endsWith(".yaml"))
+                continue;
+            if (!json && path.endsWith(".json"))
+                continue;
+            if (![
+                "json",
+                "yaml",
+                "go",
+                "sh",
+                "ts",
+                "py",
+                "sql",
+                "gql",
+                "ps1",
+                "php",
+                "js",
+                "lock",
+                "rs",
+                "cs",
+                "yml",
+                "nu",
+                "java",
+                "rb",
+                // for related places search: ADD_NEW_LANG
+            ].includes(path.split(".").pop() ?? "")) {
+                continue;
+            }
+        }
+        if (isRawAppFile(path)) {
+            const suffix = path.split(".raw_app" + SEP).pop();
+            if (suffix?.startsWith("dist/") || suffix == "wmill.d.ts" || suffix == "package-lock.json") {
+                continue;
+            }
+        }
+        if (skips.skipResources && isFileResource(path))
             continue;
         const ext = json ? ".json" : ".yaml";
         if (!skips.includeSchedules && path.endsWith(".schedule" + ext))
@@ -534,8 +686,9 @@ export async function elementsToMap(els, ignore, json, skips, specificItems) {
                 path.endsWith(".mqtt_trigger" + ext) ||
                 path.endsWith(".sqs_trigger" + ext) ||
                 path.endsWith(".gcp_trigger" + ext) ||
-                path.endsWith(".email_trigger" + ext)))
+                path.endsWith(".email_trigger" + ext))) {
             continue;
+        }
         if (!skips.includeUsers && path.endsWith(".user" + ext))
             continue;
         if (!skips.includeGroups && path.endsWith(".group" + ext))
@@ -546,8 +699,9 @@ export async function elementsToMap(els, ignore, json, skips, specificItems) {
             continue;
         if (skips.skipResources && path.endsWith(".resource" + ext))
             continue;
-        if (skips.skipResourceTypes && path.endsWith(".resource-type" + ext))
+        if (skips.skipResourceTypes && path.endsWith(".resource-type" + ext)) {
             continue;
+        }
         // Use getTypeStrFromPath for consistent type detection
         try {
             const fileType = getTypeStrFromPath(path);
@@ -561,35 +715,12 @@ export async function elementsToMap(els, ignore, json, skips, specificItems) {
                 continue;
             if (skips.skipFolders && fileType === "folder")
                 continue;
+            if (skips.skipWorkspaceDependencies && fileType === "workspace_dependencies")
+                continue;
         }
         catch {
             // If getTypeStrFromPath can't determine the type, continue processing the file
         }
-        if (skips.skipResources && isFileResource(path))
-            continue;
-        if (![
-            "json",
-            "yaml",
-            "go",
-            "sh",
-            "ts",
-            "py",
-            "sql",
-            "gql",
-            "ps1",
-            "php",
-            "js",
-            "lock",
-            "rs",
-            "cs",
-            "yml",
-            "nu",
-            "java",
-            "rb",
-            // for related places search: ADD_NEW_LANG
-        ].includes(path.split(".").pop() ?? "") &&
-            !isFileResource(path))
-            continue;
         // Handle branch-specific files - skip files for other branches
         if (specificItems && isBranchSpecificFile(path)) {
             const currentBranch = getCurrentGitBranch();
@@ -706,13 +837,16 @@ async function compareDynFSElement(els1, els2, ignore, json, skips, ignoreMetada
             if (skipMetadata) {
                 continue;
             }
+            if (k.startsWith("dependencies/")) {
+                log.info(`Adding workspace dependencies file: ${k}`);
+            }
             changes.push({ name: "added", path: k, content: v });
         }
         else {
             if (m2[k] == v) {
                 continue;
             }
-            else if (k.endsWith(".json")) {
+            else if (k.endsWith(".json") && !isWorkspaceDependencies(k)) {
                 let parsedV, parsedM2;
                 try {
                     parsedV = JSON.parse(v);
@@ -772,7 +906,7 @@ async function compareDynFSElement(els1, els2, ignore, json, skips, ignoreMetada
                 changes.push({ name: "deleted", path: k });
             }
             else if (k?.endsWith(".script.yaml")) {
-                let o = parseYaml(k, m2[k]);
+                const o = parseYaml(k, m2[k]);
                 if (o.codebase != undefined) {
                     remoteCodebase[k] = o.codebase;
                 }
@@ -875,7 +1009,8 @@ const isNotWmillFile = (p, isDirectory) => {
             !p.startsWith("f" + SEP) &&
             !p.startsWith("g" + SEP) &&
             !p.startsWith("users" + SEP) &&
-            !p.startsWith("groups" + SEP));
+            !p.startsWith("groups" + SEP) &&
+            !p.startsWith("dependencies" + SEP));
     }
     try {
         const typ = getTypeStrFromPath(p);
@@ -889,7 +1024,8 @@ const isNotWmillFile = (p, isDirectory) => {
                 !p.startsWith("f" + SEP) &&
                 !p.startsWith("g" + SEP) &&
                 !p.startsWith("users" + SEP) &&
-                !p.startsWith("groups" + SEP));
+                !p.startsWith("groups" + SEP) &&
+                !p.startsWith("dependencies" + SEP));
         }
     }
     catch {
@@ -903,7 +1039,8 @@ export const isWhitelisted = (p) => {
         p == "f" ||
         p == "g" ||
         p == "users" ||
-        p == "groups");
+        p == "groups" ||
+        p == "dependencies");
 };
 export async function ignoreF(wmillconf) {
     let whitelist = undefined;
@@ -950,6 +1087,9 @@ export async function ignoreF(wmillconf) {
                 if (wmillconf.includeKey && fileType === "encryption_key") {
                     return false; // Don't ignore, always include
                 }
+                if (!wmillconf.skipWorkspaceDependencies && fileType === "workspace_dependencies") {
+                    return false; // Don't ignore workspace dependencies (they are always included unless explicitly skipped)
+                }
             }
             catch {
                 // If getTypeStrFromPath can't determine the type, fall through to normal logic
@@ -960,22 +1100,31 @@ 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" + SEP)) {
-            const folder = p.substring(0, p.indexOf(".flow" + SEP)) + ".flow" + SEP;
+        if (p.includes(FLOW_EXT)) {
+            const folder = p.substring(0, p.indexOf(FLOW_EXT)) + FLOW_EXT;
             if (!tracker.flows.includes(folder)) {
                 tracker.flows.push(folder);
             }
         }
-        else if (p.includes(".app" + SEP)) {
-            const folder = p.substring(0, p.indexOf(".app" + SEP)) + ".app" + SEP;
+        else if (p.includes(APP_EXT)) {
+            const folder = p.substring(0, p.indexOf(APP_EXT)) + APP_EXT;
             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;
+            if (!tracker.rawApps.includes(folder)) {
+                tracker.rawApps.push(folder);
+            }
+        }
         else {
             if (!tracker.scripts.includes(p)) {
                 tracker.scripts.push(p);
@@ -1001,6 +1150,7 @@ async function buildTracker(changes) {
         scripts: [],
         flows: [],
         apps: [],
+        rawApps: [],
     };
     for (const change of changes) {
         if (change.name == "added" || change.name == "edited") {
@@ -1045,7 +1195,8 @@ export async function pull(opts) {
     catch {
         // ignore
     }
-    const remote = ZipFSElement((await downloadZip(workspace, opts.plainSecrets, opts.skipVariables, opts.skipResources, opts.skipResourceTypes, opts.skipSecrets, opts.includeSchedules, opts.includeTriggers, opts.includeUsers, opts.includeGroups, opts.includeSettings, opts.includeKey, opts.defaultTs)), !opts.json, opts.defaultTs ?? "bun", resourceTypeToFormatExtension, true);
+    const zipFile = await downloadZip(workspace, opts.plainSecrets, opts.skipVariables, opts.skipResources, opts.skipResourceTypes, opts.skipSecrets, opts.includeSchedules, opts.includeTriggers, opts.includeUsers, opts.includeGroups, opts.includeSettings, opts.includeKey, opts.skipWorkspaceDependencies, opts.defaultTs);
+    const remote = ZipFSElement(zipFile, !opts.json, opts.defaultTs ?? "bun", resourceTypeToFormatExtension, true);
     const local = !opts.stateful
         ? await FSFSElement(dntShim.Deno.cwd(), codebases, true)
         : await FSFSElement(path.join(dntShim.Deno.cwd(), ".wmill"), [], true);
@@ -1195,17 +1346,21 @@ export async function pull(opts) {
         }
         log.info("All local changes pulled, now updating wmill-lock.yaml");
         await readLockfile(); // ensure wmill-lock.yaml exists
-        const globalDeps = await findGlobalDeps();
         const tracker = await buildTracker(changes);
+        const rawWorkspaceDependencies = await getRawWorkspaceDependencies();
         for (const change of tracker.scripts) {
-            await generateScriptMetadataInternal(change, workspace, opts, false, true, globalDeps, codebases, true);
+            await generateScriptMetadataInternal(change, workspace, opts, false, true, rawWorkspaceDependencies, codebases, true);
         }
         for (const change of tracker.flows) {
             log.info(`Updating lock for flow ${change}`);
-            await generateFlowLockInternal(change, false, workspace, opts, true);
+            await generateFlowLockInternal(change, false, workspace, opts, true, false);
         }
         if (tracker.apps.length > 0) {
-            log.info(`Apps ${tracker.apps.join(", ")} scripts were changed but ignoring for now`);
+            log.info(colors.gray(`Apps ${tracker.apps.join(", ")} inline scripts were changed but ignoring metadata regeneration for now`));
+        }
+        for (const change of tracker.rawApps) {
+            log.info(`Updating lock metadata for raw app ${change}`);
+            await generateAppLocksInternal(change, false, workspace, opts, true, true);
         }
         if (opts.jsonOutput) {
             const result = {
@@ -1349,15 +1504,15 @@ export async function push(opts) {
     catch {
         // ignore
     }
-    const remote = ZipFSElement((await downloadZip(workspace, opts.plainSecrets, opts.skipVariables, opts.skipResources, opts.skipResourceTypes, opts.skipSecrets, opts.includeSchedules, opts.includeTriggers, opts.includeUsers, opts.includeGroups, opts.includeSettings, opts.includeKey, opts.defaultTs)), !opts.json, opts.defaultTs ?? "bun", resourceTypeToFormatExtension, false);
+    const remote = ZipFSElement((await downloadZip(workspace, opts.plainSecrets, opts.skipVariables, opts.skipResources, opts.skipResourceTypes, opts.skipSecrets, opts.includeSchedules, opts.includeTriggers, opts.includeUsers, opts.includeGroups, opts.includeSettings, opts.includeKey, opts.skipWorkspaceDependencies, opts.defaultTs)), !opts.json, opts.defaultTs ?? "bun", resourceTypeToFormatExtension, false);
     const local = await FSFSElement(path.join(dntShim.Deno.cwd(), ""), codebases, false);
     const changes = await compareDynFSElement(local, remote, await ignoreF(opts), opts.json ?? false, opts, true, codebases, false, specificItems);
-    const globalDeps = await findGlobalDeps();
+    const rawWorkspaceDependencies = await getRawWorkspaceDependencies();
     const tracker = await buildTracker(changes);
     const staleScripts = [];
     const staleFlows = [];
     for (const change of tracker.scripts) {
-        const stale = await generateScriptMetadataInternal(change, workspace, opts, true, true, globalDeps, codebases, false);
+        const stale = await generateScriptMetadataInternal(change, workspace, opts, true, true, rawWorkspaceDependencies, codebases, false);
         if (stale) {
             staleScripts.push(stale);
         }
@@ -1458,9 +1613,19 @@ export async function push(opts) {
         while (queue.length > 0 || pool.size > 0) {
             // Fill the pool until we reach parallelizationFactor
             while (pool.size < parallelizationFactor && queue.length > 0) {
-                const [_basePath, changes] = queue.shift();
+                let [_basePath, changes] = queue.shift();
                 const promise = (async () => {
                     const alreadySynced = [];
+                    const isRawApp = isRawAppFile(changes[0].path);
+                    if (isRawApp) {
+                        const deleteRawApp = changes.find(change => change.name === "deleted" && change.path.endsWith(".raw_app/raw_app.yaml"));
+                        if (deleteRawApp) {
+                            changes = [deleteRawApp];
+                        }
+                        else {
+                            changes.splice(1, changes.length - 1);
+                        }
+                    }
                     for await (const change of changes) {
                         let stateTarget = undefined;
                         if (stateful) {
@@ -1473,13 +1638,13 @@ export async function push(opts) {
                             }
                         }
                         if (change.name === "edited") {
-                            if (await handleScriptMetadata(change.path, workspace, alreadySynced, opts.message, globalDeps, codebases, opts)) {
+                            if (await handleScriptMetadata(change.path, workspace, alreadySynced, opts.message, rawWorkspaceDependencies, codebases, opts)) {
                                 if (stateTarget) {
                                     await dntShim.Deno.writeTextFile(stateTarget, change.after);
                                 }
                                 continue;
                             }
-                            else if (await handleFile(change.path, workspace, alreadySynced, opts.message, opts, globalDeps, codebases)) {
+                            else if (await handleFile(change.path, workspace, alreadySynced, opts.message, opts, rawWorkspaceDependencies, codebases)) {
                                 if (stateTarget) {
                                     await dntShim.Deno.writeTextFile(stateTarget, change.after);
                                 }
@@ -1527,7 +1692,7 @@ export async function push(opts) {
                                 isFileResource(change.path)) {
                                 continue;
                             }
-                            else if (await handleFile(change.path, workspace, alreadySynced, opts.message, opts, globalDeps, codebases)) {
+                            else if (await handleFile(change.path, workspace, alreadySynced, opts.message, opts, rawWorkspaceDependencies, codebases)) {
                                 continue;
                             }
                             if (stateTarget) {
@@ -1601,6 +1766,14 @@ export async function push(opts) {
                                         path: removeSuffix(target, ".app/app.json"),
                                     });
                                     break;
+                                case "raw_app":
+                                    if (target.endsWith(".raw_app/raw_app.yaml") || target.endsWith(".raw_app/raw_app.json")) {
+                                        await wmill.deleteApp({
+                                            workspace: workspaceId,
+                                            path: removeSuffix(target, ".raw_app/raw_app.json"),
+                                        });
+                                    }
+                                    break;
                                 case "schedule":
                                     await wmill.deleteSchedule({
                                         workspace: workspaceId,
@@ -1688,6 +1861,19 @@ export async function push(opts) {
                                         name: removeSuffix(removePathPrefix(change.path, "groups"), ".group.json"),
                                     });
                                     break;
+                                case "workspace_dependencies":
+                                    const relativePath = removePathPrefix(change.path, "dependencies");
+                                    const res = workspaceDependenciesPathToLanguageAndFilename(change.path);
+                                    if (!res) {
+                                        throw new Error(`Unknown workspace dependencies file format: ${change.path}`);
+                                    }
+                                    const { name, language } = res;
+                                    await wmill.deleteWorkspaceDependencies({
+                                        workspace: workspaceId,
+                                        language,
+                                        name
+                                    });
+                                    break;
                                 default:
                                     break;
                             }
@@ -1758,6 +1944,7 @@ const command = new Command()
     .option("--skip-flows", "Skip syncing flows")
     .option("--skip-apps", "Skip syncing apps")
     .option("--skip-folders", "Skip syncing folders")
+    .option("--skip-workspace-dependencies", "Skip syncing workspace dependencies")
     // .option("--skip-scripts-metadata", "Skip syncing scripts metadata, focus solely on logic")
     .option("--include-schedules", "Include syncing  schedules")
     .option("--include-triggers", "Include syncing triggers")
@@ -1788,6 +1975,7 @@ const command = new Command()
     .option("--skip-flows", "Skip syncing flows")
     .option("--skip-apps", "Skip syncing apps")
     .option("--skip-folders", "Skip syncing folders")
+    .option("--skip-workspace-dependencies", "Skip syncing workspace dependencies")
     // .option("--skip-scripts-metadata", "Skip syncing scripts metadata, focus solely on logic")
     .option("--include-schedules", "Include syncing schedules")
     .option("--include-triggers", "Include syncing triggers")

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

@@ -1,5 +1,5 @@
 import { colors, Input, log, setClient } from "../../../deps.js";
-import { addWorkspace, allWorkspaces, list, removeWorkspace } from "./workspace.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";
@@ -86,14 +86,12 @@ async function createWorkspaceFork(opts, workspaceName, workspaceId = undefined)
         log.error(colors.red(`Failed to create forked workspace: ${error.message}`));
         throw error;
     }
-    await addWorkspace({
-        name: workspaceName,
-        remote: remote,
-        workspaceId: trueWorkspaceId,
-        token: token,
-    }, opts);
     const newBranchName = `${WM_FORK_PREFIX}/${clonedBranchName}/${workspaceId}`;
-    log.info(`Created forked workspace ${trueWorkspaceId}. To start contributing to your fork, create and push edits to the branch \`${newBranchName}\` by using the command:\n\n\t` + colors.white(`git checkout -b ${newBranchName}`) + `\n\nThe changes will then be reflected in your fork if you've setup the git sync workflows correctly.`);
+    log.info(`Created forked workspace ${trueWorkspaceId}. To start contributing to your fork, create and push edits to the branch \`${newBranchName}\` by using the command:
+    
+\t` + colors.white(`git checkout -b ${newBranchName}`) + `
+    
+When doing operations on the forked workspace, it will use the remote setup in gitBranches for the branch it was forked from.`);
 }
 async function deleteWorkspaceFork(opts, name) {
     const orgWorkspaces = await allWorkspaces(opts.configDir);