@superblocksteam/vite-plugin-file-sync 2.0.74 → 2.0.75-next.3

package/dist/file-system-manager.js

@@ -1,15 +1,13 @@
 import fs from "fs/promises";
-import path from "node:path";
+import nodePath from "node:path";
 import * as t from "@babel/types";
 import { PROCESSED_TRANSACTIONS_ATTRIBUTE, ROOT_WIDGET_ATTRIBUTE, SOURCE_ID_ATTRIBUTE, WIDGET_DISABLE_DND, } from "@superblocksteam/library-shared";
 import { addTracingToMethods, TracedEventEmitter, } from "@superblocksteam/shared";
 import { readAppApiYamlFile, writeApiFiles, } from "@superblocksteam/util";
 import { glob } from "glob";
 import { isEqual, debounce } from "lodash-es";
+import { normalizePath } from "vite";
 import yaml from "yaml";
-import { Paths } from "./ai-service/const.js";
-import { YamlToApiBuilderTransformer } from "./ai-service/transform/api-builder/to-sdk-transformer.js";
-import { applyFileTransformations, renderPath, } from "./ai-service/transform/shared.js";
 import { generateJSXAttribute } from "./codegen.js";
 import { ComponentsManager } from "./components-manager.js";
 import { addLegacyCustomComponentVariables, modifyLegacyCustomComponentElements, modifyLegacyCustomComponentImports, } from "./custom-components.js";
@@ -116,13 +114,13 @@ export class FileSystemManager extends TracedEventEmitter {
         if (!this.rootDir) {
             throw new Error("Root directory not set");
         }
-        return path.join(this.rootDir, "App.tsx");
+        return nodePath.join(this.rootDir, "App.tsx");
     }
     get rootScopeFilePath() {
         if (!this.rootDir) {
             throw new Error("Root directory not set");
         }
-        return path.join(this.rootDir, SCOPE_FILE);
+        return nodePath.join(this.rootDir, SCOPE_FILE);
     }
     // MARK: core setup/init
     async watch(watcher, rootPath) {
@@ -130,7 +128,7 @@ export class FileSystemManager extends TracedEventEmitter {
         this.rootDir = rootPath;
         this.watcher = watcher;
         // APIs and pages are in the pages subfolder
-        const fileNames = await readFiles(path.join(rootPath));
+        const fileNames = await readFiles(nodePath.join(rootPath));
         // this reads all files excluding ignore list in the root path. Should we read all files in pages and add root.tsx and App.tsx instead?
         const tsxFiles = fileNames.filter((f) => f.endsWith(".tsx") && !f.includes(`${getLegacyComponentsFolder()}/`));
         const yamlFiles = fileNames.filter((f) => f.endsWith(".yaml"));
@@ -168,7 +166,7 @@ export class FileSystemManager extends TracedEventEmitter {
             // We only want to load the typescript files here, before the source tracker is initialized
             // API setup needs to be deferred until we've parsed the scope files (which is done in the source tracker)
             if (type === "tsx" || type === "ts") {
-                this.tsFiles[path] = content;
+                this.tsFiles[normalizePath(path)] = content;
             }
         });
         try {
@@ -287,21 +285,22 @@ export class FileSystemManager extends TracedEventEmitter {
         if (!this.sourceTracker) {
             throw new Error("Source tracker not initialized");
         }
+        const normalizedPath = normalizePath(filePath);
         const files = this.sourceTracker.getCurrentFiles();
-        if (!files[filePath]) {
-            throw new Error("File not found in source tracker " + filePath);
+        if (!files[normalizedPath]) {
+            throw new Error("File not found in source tracker " + normalizedPath);
         }
-        let ast = files[filePath].ast;
+        let ast = files[normalizedPath].ast;
         if (!ast) {
-            throw new Error("No AST found for file in source tracker " + filePath);
+            throw new Error("No AST found for file in source tracker " + normalizedPath);
         }
-        if (filePath in this.tsFiles &&
-            this.tsFiles[filePath] &&
-            files[filePath].code !== this.tsFiles[filePath]) {
+        if (normalizedPath in this.tsFiles &&
+            this.tsFiles[normalizedPath] &&
+            files[normalizedPath].code !== this.tsFiles[normalizedPath]) {
             getLogger().error("File code mismatch in source tracker, this should never happen: " +
                 filePath);
-            await this.handleNonVisualChangeByDeletingIds(filePath, this.tsFiles[filePath]);
-            const newAst = this.sourceTracker.getCurrentFiles()[filePath]?.ast;
+            await this.handleNonVisualChangeByDeletingIds(filePath, this.tsFiles[normalizedPath]);
+            const newAst = this.sourceTracker.getCurrentFiles()[normalizedPath]?.ast;
             if (!newAst) {
                 throw new Error("No AST found for file in source tracker after mismatch:" + filePath);
             }
@@ -456,46 +455,49 @@ export class FileSystemManager extends TracedEventEmitter {
             return;
         }
         const fileType = SUPPORTED_FILETYPES.find((f) => filePath.endsWith(f.extension));
+        // Normalize both paths for comparison (Windows compatibility)
+        const normalizedFilePath = normalizePath(filePath);
+        const normalizedRootPath = normalizePath(rootPath);
         // Only handle files we care about and that are in our root path
-        if (!fileType || !filePath.startsWith(rootPath)) {
+        if (!fileType || !normalizedFilePath.startsWith(normalizedRootPath)) {
             return;
         }
         // Queue the operation based on the event type
         switch (event) {
             case "add": {
-                const file = await readFile(filePath);
+                const file = await readFile(normalizedFilePath);
                 if (typeof file !== "string")
                     return;
                 switch (fileType.type) {
                     case "api":
                     case "python-api-step":
                     case "js-api-step": {
-                        await this.processApiFileUpdates(filePath, fileType);
+                        await this.processApiFileUpdates(normalizedFilePath, fileType);
                         break;
                     }
                     case "ts":
                     case "tsx":
-                        if (!(filePath in this.tsFiles)) {
-                            this.tsFiles[filePath] = file;
-                            await this.handleNonVisualChangeByDeletingIds(filePath, file);
-                            this.emit("fileChanged", filePath, file, true);
+                        if (!(normalizedFilePath in this.tsFiles)) {
+                            this.tsFiles[normalizedFilePath] = file;
+                            await this.handleNonVisualChangeByDeletingIds(normalizedFilePath, file);
+                            this.emit("fileChanged", normalizedFilePath, file, true);
                             return;
                         }
                 }
                 break;
             }
             case "change": {
-                const fileType = SUPPORTED_FILETYPES.find((f) => filePath.endsWith(f.extension));
-                if (!fileType || !filePath.startsWith(rootPath)) {
+                const fileType = SUPPORTED_FILETYPES.find((f) => normalizedFilePath.endsWith(f.extension));
+                if (!fileType || !normalizedFilePath.startsWith(rootPath)) {
                     return;
                 }
-                const data = await readFile(filePath);
+                const data = await readFile(normalizedFilePath);
                 if (typeof data !== "string")
                     return;
                 // Handle router file changes
-                if (this.routerFilePath && filePath === this.routerFilePath) {
+                if (this.routerFilePath && normalizedFilePath === this.routerFilePath) {
                     logger.info("Router file changed, emitting routerChange event");
-                    this.emit("routerChange", filePath);
+                    this.emit("routerChange", normalizedFilePath);
                     return;
                 }
                 switch (fileType.type) {
@@ -503,17 +505,18 @@ export class FileSystemManager extends TracedEventEmitter {
                     case "tsx":
                     case "scope":
                         {
-                            if (!(filePath in this.tsFiles && this.tsFiles[filePath] === data)) {
-                                logger.info(`File changed: ${filePath} updating AST tracker`);
-                                this.tsFiles[filePath] = data;
+                            if (!(normalizedFilePath in this.tsFiles &&
+                                this.tsFiles[normalizedFilePath] === data)) {
+                                logger.info(`File changed: ${normalizedFilePath} updating AST tracker`);
+                                this.tsFiles[normalizedFilePath] = data;
                                 // only update the source tracker if the file is different
-                                await this.handleNonVisualChangeByDeletingIds(filePath, data);
-                                this.emit("fileChanged", filePath, data, true);
+                                await this.handleNonVisualChangeByDeletingIds(normalizedFilePath, data);
+                                this.emit("fileChanged", normalizedFilePath, data, true);
                             }
                             else {
-                                logger.info(`File unchanged from last tracked state: ${filePath}`);
-                                this.emit("fileChanged", filePath, data, false);
-                                this.sourceTracker?.updateFileContents(filePath, data);
+                                logger.info(`File unchanged from last tracked state: ${normalizedFilePath}`);
+                                this.emit("fileChanged", normalizedFilePath, data, false);
+                                this.sourceTracker?.updateFileContents(normalizedFilePath, data);
                             }
                         }
                         break;
@@ -521,16 +524,17 @@ export class FileSystemManager extends TracedEventEmitter {
                     case "python-api-step":
                     case "js-api-step":
                         {
-                            await this.processApiFileUpdates(filePath, fileType);
+                            await this.processApiFileUpdates(normalizedFilePath, fileType);
                         }
                         break;
                 }
                 break;
             }
             case "unlink": {
-                if (filePath in this.tsFiles) {
-                    await this.deleteTsFile(filePath);
-                    if (this.routerFilePath && filePath === this.routerFilePath) {
+                if (normalizedFilePath in this.tsFiles) {
+                    await this.deleteTsFile(normalizedFilePath);
+                    if (this.routerFilePath &&
+                        normalizedFilePath === this.routerFilePath) {
                         logger.warn("Router file was deleted, attempting to find new router file");
                         try {
                             this.routerFilePath = await findRouterFile(rootPath);
@@ -544,18 +548,19 @@ export class FileSystemManager extends TracedEventEmitter {
                         }
                     }
                 }
-                else if (filePath in this.apiFiles) {
-                    await this.removeApiData(filePath);
+                else if (normalizedFilePath in this.apiFiles) {
+                    await this.removeApiData(normalizedFilePath);
                 }
                 break;
             }
         }
     };
     async deleteTsFile(filePath) {
-        delete this.tsFiles[filePath];
-        this.sourceTracker?.removeFile(filePath);
-        if (isPageFilePath(filePath)) {
-            this.emit("deletePage", filePath);
+        const normalizedPath = normalizePath(filePath);
+        delete this.tsFiles[normalizedPath];
+        this.sourceTracker?.removeFile(normalizedPath);
+        if (isPageFilePath(normalizedPath)) {
+            this.emit("deletePage", normalizedPath);
         }
     }
     getTsFilePaths() {
@@ -571,65 +576,14 @@ export class FileSystemManager extends TracedEventEmitter {
     setTemplateRenderer(templateRenderer) {
         this.templateRenderer = templateRenderer;
     }
-    /**
-     * Generate TypeScript source from YAML and write to scratch directory
-     * This is called when YAML changes (e.g., UI edits) to keep TS in sync.
-     */
-    syncTsFromYaml = debounce((apiName) => {
-        return this.fsOperationQueue.enqueue(() => this._syncTsFromYaml(apiName));
-    }, 250, { leading: true, trailing: true, maxWait: 500 });
-    async _syncTsFromYaml(apiName) {
-        const logger = getLogger();
-        // Skip if we don't have templateRenderer
-        if (!this.templateRenderer || !this.rootDir) {
-            logger.warn(`Skipping YAML→TS sync for ${apiName}: templateRenderer or rootDir not available`);
-            return;
-        }
-        logger.info(`Starting YAML→TS sync for: ${apiName}`);
-        try {
-            const yamlPath = renderPath(Paths.ApiYamls, { apiName });
-            logger.debug(`Syncing TS source from YAML for API: ${apiName}`);
-            // Create file artifact for transformation
-            const yamlArtifact = {
-                type: "file",
-                filePath: yamlPath,
-                content: "", // Transformer just needs the path
-            };
-            // Transform YAML to TS
-            const outputs = await applyFileTransformations([yamlArtifact], [
-                new YamlToApiBuilderTransformer({
-                    appRootDirPath: this.rootDir,
-                    entityNames: [], // Empty for now, could be enhanced later
-                    skipCleanup: true,
-                    templateRenderer: this.templateRenderer,
-                }),
-            ]);
-            const tsArtifact = outputs[0];
-            if (!tsArtifact) {
-                logger.warn(`No TS artifact generated for ${apiName}`);
-                return;
-            }
-            logger.debug(`Generated TS source for ${apiName}, writing to scratch`, tsArtifact.content);
-            // Write to scratch directory
-            const apiTsFilePath = `${renderPath(Paths.GeneratedApis, { apiName })}.ts`;
-            const scratchPath = renderPath(Paths.Scratch, { path: apiTsFilePath });
-            const fullPath = path.join(this.rootDir, scratchPath);
-            await fs.mkdir(path.dirname(fullPath), { recursive: true });
-            await fs.writeFile(fullPath, tsArtifact.content, { encoding: "utf-8" });
-            logger.info(`✓ Synced TS source to scratch for ${apiName}`);
-        }
-        catch (error) {
-            logger.error(`Failed to sync TS from YAML for ${apiName}`, getErrorMeta(error));
-            // Don't throw - sync failure shouldn't break the API update
-        }
-    }
     // MARK: fs read/write
     async writeFile(path, content, kind) {
         getLogger().info(`Writing file: ${path}, kind: ${kind ?? "other"}`);
         switch (kind) {
             case "ts": {
                 // happens eagerly regardless of error - possible desync
-                this.tsFiles[path] = content;
+                const normalizedPath = normalizePath(path);
+                this.tsFiles[normalizedPath] = content;
                 // TODO(george): as an optimization, we could update the memory snapshot of the file that SyncService is holding
                 await this.fsOperationQueue.enqueue(async () => {
                     const dir = path.substring(0, path.lastIndexOf("/"));
@@ -641,7 +595,8 @@ export class FileSystemManager extends TracedEventEmitter {
                 break;
             }
             case "api": {
-                const currentApiFile = this.apiFiles[path];
+                const normalizedPath = normalizePath(path);
+                const currentApiFile = this.apiFiles[normalizedPath];
                 const apiPb = yaml.parse(content);
                 // We don't need ID, organization, or trigger data in code-mode APIs
                 if (apiPb.metadata) {
@@ -655,14 +610,15 @@ export class FileSystemManager extends TracedEventEmitter {
                 const scopeId = getScopeIdFromName("App");
                 // Update in-memory state before writing to disk (similar to TS files)
                 // This allows the file watcher to detect no change and skip duplicate events
-                this.apiFiles[path] = {
+                this.apiFiles[normalizedPath] = {
                     apiPb: yaml.parse(JSON.stringify(apiPb)),
                     stepPathMap,
                     scopeId,
                 };
                 // TODO(george): as an optimization, we could update the memory snapshot of the file that SyncService is holding
+                const apiDir = nodePath.dirname(path);
                 await this.fsOperationQueue.enqueue(async () => {
-                    await writeApiFiles({ apiPb }, "api", path.split("/").slice(0, -1).join("/"), false, [], [], { extractLargeSourceFiles: true, minLinesForExtraction: 1 }, new Set(Object.keys(this.apiFiles)), stepPathMap);
+                    await writeApiFiles({ apiPb }, "api", apiDir, false, [], [], { extractLargeSourceFiles: true, minLinesForExtraction: 1 }, new Set(Object.keys(this.apiFiles)), stepPathMap);
                 });
                 break;
             }
@@ -679,7 +635,7 @@ export class FileSystemManager extends TracedEventEmitter {
         }
     }
     readFile(path) {
-        return this.tsFiles[path];
+        return this.tsFiles[normalizePath(path)];
     }
     async setFileContents(path, contents) {
         const logger = getLogger();
@@ -704,14 +660,15 @@ export class FileSystemManager extends TracedEventEmitter {
     }
     getLocalBindingEntities(path) {
         const logger = getLogger();
+        const normalizedPath = normalizePath(path);
         const files = this.sourceTracker?.getCurrentFiles();
-        if (!files || !files[path]) {
-            logger.warn(`File not found in source tracker for local binding entities: ${path}`);
+        if (!files || !files[normalizedPath]) {
+            logger.warn(`File not found in source tracker for local binding entities: ${normalizedPath}`);
             return [];
         }
-        const ast = files[path].ast;
+        const ast = files[normalizedPath].ast;
         if (!ast) {
-            logger.warn(`No AST found for file in source tracker for local binding entities: ${path}`);
+            logger.warn(`No AST found for file in source tracker for local binding entities: ${normalizedPath}`);
             return [];
         }
         const localBindingEntities = new Set();
@@ -730,7 +687,7 @@ export class FileSystemManager extends TracedEventEmitter {
         return Array.from(localBindingEntities);
     }
     getPageRootNodes(filePath) {
-        const scopeFilePath = path.join(path.dirname(filePath), "index.tsx");
+        const scopeFilePath = normalizePath(nodePath.join(nodePath.dirname(filePath), "index.tsx"));
         return this.getRootNodesForFile(scopeFilePath);
     }
     getAppRootNodes() {
@@ -750,8 +707,8 @@ export class FileSystemManager extends TracedEventEmitter {
             let resolvedPath = await getFullImportPath(localPath);
             // Fallback: manually resolve relative paths if Vite resolver fails
             if (!resolvedPath && localPath.startsWith(".")) {
-                const currentDir = path.dirname(filePath);
-                const potentialPath = path.resolve(currentDir, localPath);
+                const currentDir = nodePath.dirname(filePath);
+                const potentialPath = nodePath.resolve(currentDir, localPath);
                 // Try with different extensions
                 const extensions = [
                     "/index.tsx",
@@ -781,22 +738,24 @@ export class FileSystemManager extends TracedEventEmitter {
         return importedFiles;
     }
     async getRootNodesForFile(filePath) {
-        const currentFile = this.sourceTracker?.getCurrentFiles()[filePath];
+        const normalizedPath = normalizePath(filePath);
+        const currentFile = this.sourceTracker?.getCurrentFiles()[normalizedPath];
         if (!currentFile) {
             return undefined;
         }
         const allFiles = this.sourceTracker?.getCurrentFiles() ?? {};
         // Collect all imported files recursively (including transitive imports)
-        const importedNamesToFiles = await this.collectAllImports(filePath, allFiles);
+        const importedNamesToFiles = await this.collectAllImports(normalizedPath, allFiles);
         // Get roots from imported files (custom components)
         const importedRoots = Object.entries(importedNamesToFiles).flatMap(([filePath, file]) => getRootNodes(filePath, file));
         // Get roots from the current file
-        const roots = getRootNodes(filePath, currentFile);
+        const roots = getRootNodes(normalizedPath, currentFile);
         return [...roots, ...importedRoots];
     }
     getScope(filePath, fallback) {
         // Since we no longer use scope.ts files, generate scope info from file path. Pages retain page scope, everything else is App.
-        const scopeName = getScopeNameFromPath(filePath);
+        const normalizedPath = normalizePath(filePath);
+        const scopeName = getScopeNameFromPath(normalizedPath);
         if (!scopeName) {
             if (fallback) {
                 return {
@@ -972,8 +931,8 @@ export class FileSystemManager extends TracedEventEmitter {
         if (!this.rootDir) {
             throw new Error("Root directory not set");
         }
-        // no leading slash
-        return path.relative(path.join(this.rootDir, PAGES_DIRECTORY), filePath);
+        // no leading slash, normalize to forward slashes for routes (Windows compatibility)
+        return normalizePath(nodePath.relative(nodePath.join(this.rootDir, PAGES_DIRECTORY), filePath));
     }
     // MARK: API operations
     handleUpdateApi = async (payload) => {
@@ -990,7 +949,8 @@ export class FileSystemManager extends TracedEventEmitter {
             throw new Error("Root directory not set");
         }
         const apiFilePath = getApiFilePath(this.rootDir, apiName);
-        const apiDir = path.dirname(apiFilePath);
+        const normalizedApiFilePath = normalizePath(apiFilePath);
+        const apiDir = nodePath.dirname(normalizedApiFilePath);
         try {
             const stats = await fs.stat(apiDir);
             if (!stats.isDirectory()) {
@@ -1017,11 +977,12 @@ export class FileSystemManager extends TracedEventEmitter {
         const deletedApis = [];
         for (const { apiName } of apis) {
             const apiFilePath = getApiFilePath(rootDir, apiName);
-            const api = this.apiFiles[apiFilePath];
+            const normalizedApiFilePath = normalizePath(apiFilePath);
+            const api = this.apiFiles[normalizedApiFilePath];
             if (!api || !this.sourceTracker) {
                 continue;
             }
-            const apiDir = path.dirname(apiFilePath);
+            const apiDir = nodePath.dirname(apiFilePath);
             try {
                 await this.fsOperationQueue.enqueue(async () => {
                     const stats = await fs.stat(apiDir);
@@ -1029,7 +990,7 @@ export class FileSystemManager extends TracedEventEmitter {
                         await fs.rmdir(apiDir, { recursive: true });
                     }
                 });
-                delete this.apiFiles[apiFilePath];
+                delete this.apiFiles[normalizedApiFilePath];
                 const scopeId = this.sourceTracker.deleteApi({
                     apiName,
                 });
@@ -1054,15 +1015,16 @@ export class FileSystemManager extends TracedEventEmitter {
         if (!this.rootDir) {
             throw new Error("Root directory not set");
         }
-        const existingApiFolder = path.join(this.rootDir, "apis", oldName);
-        const newApiFolder = path.join(this.rootDir, "apis", newName);
-        const apiFilePath = path.join(existingApiFolder, "api.yaml");
-        const apiDef = this.apiFiles[apiFilePath];
+        const existingApiFolder = nodePath.join(this.rootDir, "apis", oldName);
+        const newApiFolder = nodePath.join(this.rootDir, "apis", newName);
+        const apiFilePath = nodePath.join(existingApiFolder, "api.yaml");
+        const normalizedApiFilePath = normalizePath(apiFilePath);
+        const apiDef = this.apiFiles[normalizedApiFilePath];
         if (!apiDef) {
             throw new Error(`API ${oldName} not found`);
         }
         const otherAPIs = structuredClone(Object.keys(this.apiFiles)
-            .filter((path) => path !== apiFilePath)
+            .filter((path) => path !== normalizedApiFilePath)
             .map((path) => ({
             api: { apiPb: this.apiFiles[path]?.apiPb },
             filePath: path,
@@ -1077,9 +1039,9 @@ export class FileSystemManager extends TracedEventEmitter {
         apiDef.apiPb.metadata.name = newName;
         await fs.rename(existingApiFolder, newApiFolder);
         const scopeId = getScopeIdFromName("App");
-        delete this.apiFiles[apiFilePath];
+        delete this.apiFiles[normalizedApiFilePath];
         // not waiting because we are queueing the write further down
-        void this.writeFile(path.join(newApiFolder, "api.yaml"), yaml.stringify(apiDef.apiPb), "api");
+        void this.writeFile(nodePath.join(newApiFolder, "api.yaml"), yaml.stringify(apiDef.apiPb), "api");
         this.watcher?.add(existingApiFolder);
         this.watcher?.add(newApiFolder);
         const changes = (await this.sourceTracker?.getAndFlushChanges()) ?? [];
@@ -1107,11 +1069,12 @@ export class FileSystemManager extends TracedEventEmitter {
         }));
     };
     async removeApiData(filePath) {
-        const api = this.apiFiles[filePath];
+        const normalizedPath = normalizePath(filePath);
+        const api = this.apiFiles[normalizedPath];
         if (!api) {
             return;
         }
-        delete this.apiFiles[filePath];
+        delete this.apiFiles[normalizedPath];
         this.sourceTracker?.deleteApi({
             apiName: api.apiPb.metadata.name,
         });
@@ -1170,9 +1133,10 @@ export class FileSystemManager extends TracedEventEmitter {
         let yamlPath = filePath;
         if (fileType.type === "python-api-step" ||
             fileType.type === "js-api-step") {
-            const apiFolderPath = filePath.split("/").slice(0, -1).join("/");
-            yamlPath = path.join(apiFolderPath, "api.yaml");
+            const apiFolderPath = nodePath.dirname(filePath);
+            yamlPath = nodePath.join(apiFolderPath, "api.yaml");
         }
+        const normalizedYamlPath = normalizePath(yamlPath);
         const logger = getLogger();
         logger.info(`Processing API file update: ${yamlPath}`);
         try {
@@ -1183,9 +1147,9 @@ export class FileSystemManager extends TracedEventEmitter {
             }
             logger.info(`API structure is valid: ${yamlPath}`);
             const parsedData = { apiPb: apiContent?.api };
-            if (yamlPath in this.apiFiles &&
-                isEqual(this.apiFiles[yamlPath]?.apiPb, parsedData.apiPb)) {
-                logger.info(`No changes detected in API: ${yamlPath}`);
+            if (normalizedYamlPath in this.apiFiles &&
+                isEqual(this.apiFiles[normalizedYamlPath]?.apiPb, parsedData.apiPb)) {
+                logger.info(`No changes detected in API: ${normalizedYamlPath}`);
                 return;
             }
             const { updatedApi, isNewApi } = this.updateInternalApiData({
@@ -1251,28 +1215,35 @@ export class MockFileSyncManager extends FileSystemManager {
     }
     async writeFile(path, content, kind) {
         await this.fsOperationQueue.enqueue(async () => {
+            const normalizedPath = normalizePath(path);
             if (kind === "ts") {
-                this.tsFiles[path] = content;
+                this.tsFiles[normalizedPath] = content;
             }
             else {
-                this.apiFiles[path] = {
+                this.apiFiles[normalizedPath] = {
                     apiPb: yaml.parse(content),
                     stepPathMap: {},
                     scopeId: getScopeIdFromName("App"),
                 };
             }
             // Notify subscribers
-            this.emit("fileChanged", path, content, true);
+            this.emit("fileChanged", normalizedPath, content, true);
         });
     }
     // Helper methods for testing
     mockFileChange(path, content) {
-        this.tsFiles[path] = content;
-        this.emit("fileChanged", path, content, true);
+        const normalizedPath = normalizePath(path);
+        this.tsFiles[normalizedPath] = content;
+        this.emit("fileChanged", normalizedPath, content, true);
     }
     handleUpdateApi = async (payload) => {
         const apiName = payload.api.apiPb.metadata.name;
-        this.apiFiles[apiName] = {
+        if (!this.rootDir) {
+            throw new Error("Root directory not set");
+        }
+        const apiFilePath = getApiFilePath(this.rootDir, apiName);
+        const normalizedApiFilePath = normalizePath(apiFilePath);
+        this.apiFiles[normalizedApiFilePath] = {
             ...payload.api,
             stepPathMap: {},
             scopeId: payload.scopeId,
@@ -1303,7 +1274,9 @@ async function readFile(path) {
     }
 }
 async function readFiles(dir) {
-    return await glob(path.join(dir, "**/*.{tsx,yaml,ts}"), {
+    const files = await glob("**/*.{tsx,yaml,ts}", {
+        cwd: dir,
+        absolute: true,
         ignore: [
             "node_modules/**",
             "dist/**",
@@ -1312,8 +1285,10 @@ async function readFiles(dir) {
             `./${getLegacyComponentsFolder()}/**`,
         ],
     });
+    // Normalize paths to use forward slashes on all platforms (Windows returns backslashes)
+    return files.map((file) => normalizePath(file));
 }
-const getMergedApiContent = async (path) => {
-    return readAppApiYamlFile(path.split("/").slice(0, -1).join("/"));
+const getMergedApiContent = async (filePath) => {
+    return readAppApiYamlFile(nodePath.dirname(filePath));
 };
 //# sourceMappingURL=file-system-manager.js.map