🤖 Fix symlink preservation when editing files

src/runtime/LocalRuntime.ts

@@ -241,15 +241,24 @@ export class LocalRuntime implements Runtime {
   writeFile(filePath: string): WritableStream<Uint8Array> {
     let tempPath: string;
     let writer: WritableStreamDefaultWriter<Uint8Array>;
+    let resolvedPath: string;
 
     return new WritableStream<Uint8Array>({
       async start() {
+        // Resolve symlinks to write through them (preserves the symlink)
+        try {
+          resolvedPath = await fsPromises.realpath(filePath);
+        } catch {
+          // If file doesn't exist, use the original path
+          resolvedPath = filePath;
+        }
+
         // Create parent directories if they don't exist
-        const parentDir = path.dirname(filePath);
+        const parentDir = path.dirname(resolvedPath);
         await fsPromises.mkdir(parentDir, { recursive: true });
 
         // Create temp file for atomic write
-        tempPath = `${filePath}.tmp.${Date.now()}`;
+        tempPath = `${resolvedPath}.tmp.${Date.now()}`;
         const nodeStream = fs.createWriteStream(tempPath);
         const webStream = Writable.toWeb(nodeStream) as WritableStream<Uint8Array>;
         writer = webStream.getWriter();
@@ -261,7 +270,7 @@ export class LocalRuntime implements Runtime {
         // Close the writer and rename to final location
         await writer.close();
         try {
-          await fsPromises.rename(tempPath, filePath);
+          await fsPromises.rename(tempPath, resolvedPath);
         } catch (err) {
           throw new RuntimeErrorClass(
             `Failed to write file ${filePath}: ${err instanceof Error ? err.message : String(err)}`,

src/runtime/SSHRuntime.ts

@@ -263,12 +263,14 @@ export class SSHRuntime implements Runtime {
 
   /**
    * Write file contents over SSH atomically from a stream
+   * Preserves symlinks by writing through them to the target file
    */
   writeFile(path: string): WritableStream<Uint8Array> {
     const tempPath = `${path}.tmp.${Date.now()}`;
     // Create parent directory if needed, then write file atomically
+    // Use cat to copy through symlinks (preserves them), then chmod and mv
     // Use shescape.quote for safe path escaping
-    const writeCommand = `mkdir -p $(dirname ${shescape.quote(path)}) && cat > ${shescape.quote(tempPath)} && chmod 600 ${shescape.quote(tempPath)} && mv ${shescape.quote(tempPath)} ${shescape.quote(path)}`;
+    const writeCommand = `mkdir -p $(dirname ${shescape.quote(path)}) && cat > ${shescape.quote(tempPath)} && chmod 600 ${shescape.quote(tempPath)} && cat ${shescape.quote(tempPath)} > ${shescape.quote(path)} && rm ${shescape.quote(tempPath)}`;
 
     // Need to get the exec stream in async callbacks
     let execPromise: Promise<ExecStream> | null = null;

tests/runtime/runtime.test.ts

@@ -329,6 +329,49 @@ describeIntegration("Runtime integration tests", () => {
           const content = await readFileString(runtime, `${workspace.path}/special.txt`);
           expect(content).toBe(specialContent);
         });
+
+        test.concurrent("preserves symlinks when editing target file", async () => {
+          const runtime = createRuntime();
+          await using workspace = await TestWorkspace.create(runtime, type);
+
+          // Create a target file
+          const targetPath = `${workspace.path}/target.txt`;
+          await writeFileString(runtime, targetPath, "original content");
+
+          // Create a symlink to the target
+          const linkPath = `${workspace.path}/link.txt`;
+          const result = await execBuffered(runtime, `ln -s target.txt link.txt`, {
+            cwd: workspace.path,
+            timeout: 30,
+          });
+          expect(result.exitCode).toBe(0);
+
+          // Verify symlink was created
+          const lsResult = await execBuffered(runtime, "ls -la link.txt", {
+            cwd: workspace.path,
+            timeout: 30,
+          });
+          expect(lsResult.stdout).toContain("->");
+          expect(lsResult.stdout).toContain("target.txt");
+
+          // Edit the file via the symlink
+          await writeFileString(runtime, linkPath, "new content");
+
+          // Verify the symlink is still a symlink (not replaced with a file)
+          const lsAfter = await execBuffered(runtime, "ls -la link.txt", {
+            cwd: workspace.path,
+            timeout: 30,
+          });
+          expect(lsAfter.stdout).toContain("->");
+          expect(lsAfter.stdout).toContain("target.txt");
+
+          // Verify both the symlink and target have the new content
+          const linkContent = await readFileString(runtime, linkPath);
+          expect(linkContent).toBe("new content");
+
+          const targetContent = await readFileString(runtime, targetPath);
+          expect(targetContent).toBe("new content");
+        });
       });
 
       describe("stat() - File metadata", () => {