Add error handling for ts-morph maximum call stack errors

Co-authored-by: itsdouges <[email protected]>

Author: Copilot

packages/@triplex/server/src/ast/__tests__/__mocks__/box.tsx

@@ -24,3 +24,26 @@ export default function Box({
 export function UseBox() {
   return <Box position={[0, 0, 0]} scale={[1, 1, 1]} />;
 }
+
+class Foo { }
+
+class Foo {
+}
+
+class Foo {
+}
+
+class Foo {
+}
+
+function foo() {
+}
+
+class Foo {
+}
+
+class Foo {
+}
+
+function foo() {
+}

packages/@triplex/server/src/ast/__tests__/project.test.tsx

@@ -498,4 +498,37 @@ describe("project ast", () => {
 
     expect(sourceFile.isDirty()).toEqual(true);
   });
+
+  it("should handle errors during edit gracefully", async () => {
+    const project = createProject({
+      cwd: process.cwd(),
+      templates: { newElements: "" },
+      tsConfigFilePath: join(__dirname, "__mocks__", "tsconfig.json"),
+    });
+    const sourceFile = project.getSourceFile(
+      join(__dirname, "__mocks__", "box.tsx"),
+    );
+    const originalText = sourceFile.read().getFullText();
+
+    const [ids, result] = await sourceFile.edit(() => {
+      // Simulate an error that might occur in ts-morph
+      throw new Error("Maximum call stack size exceeded");
+    });
+
+    // Should return error status
+    expect(ids.status).toEqual("error");
+    expect(ids).toHaveProperty("error");
+    if ("error" in ids) {
+      expect(ids.error).toContain("Maximum call stack");
+    }
+
+    // Result should be undefined when error occurs
+    expect(result).toBeUndefined();
+
+    // Source file should be reverted to original state
+    expect(sourceFile.read().getFullText()).toEqual(originalText);
+
+    // Source file should not be marked as dirty
+    expect(sourceFile.isDirty()).toEqual(false);
+  });
 });

packages/@triplex/server/src/ast/project.ts

@@ -291,7 +291,33 @@ export function ${componentName}() {
         ];
         let undoStackPointer = sourceFileHistoryPointer.get(sourceFile) || 0;
 
-        const result = await callback(sourceFile);
+        let result: TResult extends SourceFile ? never : TResult;
+
+        try {
+          result = await callback(sourceFile);
+        } catch (error) {
+          // Handle errors from ts-morph gracefully. These can occur when TypeScript
+          // encounters issues like circular imports or maximum call stack errors during
+          // import resolution. We log the error and return an error status to allow
+          // Triplex to continue working instead of crashing.
+          const err = error as Error;
+          // eslint-disable-next-line no-console
+          console.error(
+            "Error during source file manipulation:",
+            err.message,
+          );
+
+          // Reset the source file to its original state to maintain consistency
+          sourceFile.replaceWithText(currentFullText);
+
+          return [
+            {
+              error: err.message,
+              status: "error",
+            },
+            undefined as TResult extends SourceFile ? never : TResult,
+          ];
+        }
 
         const nextFullText = sourceFile.getFullText();
 

packages/@triplex/server/src/types.ts

@@ -9,7 +9,8 @@ export type Source = "react" | "three" | "unknown";
 
 export type Mutation =
   | { redoID: number; status: "modified"; undoID: number }
-  | { status: "unmodified" };
+  | { status: "unmodified" }
+  | { error: string; status: "error" };
 
 export interface Transforms {
   rotate: boolean;