Keep Claude NODE_OPTIONS restore module out of temp cleanup

CLI/CMUXCLI+NodeOptions.swift

@@ -0,0 +1,18 @@
+import Foundation
+import CMUXNodeOptions
+
+extension CMUXCLI {
+    func mergedNodeOptions(existing: String?, restoreModulePath: String) -> String {
+        let requireOption = "--require=\(NodeOptionsSupport.requirePath(restoreModulePath))"
+        let memoryOption = "--max-old-space-size=4096"
+        guard let cleanedExisting = NodeOptionsSupport.sanitizedNodeOptions(existing) else {
+            return "\(requireOption) \(memoryOption)"
+        }
+        return "\(requireOption) \(memoryOption) \(cleanedExisting)"
+    }
+
+    func normalizedNodeOptionsForRestore(_ existing: String) -> String? {
+        NodeOptionsSupport.normalizedNodeOptionsForRestore(existing)
+    }
+
+}

CLI/cmux.swift

@@ -3,6 +3,7 @@ import CMUXAgentLaunch
 import CoreFoundation
 import CryptoKit
 import Darwin
+import CMUXNodeOptions
 #if canImport(LocalAuthentication)
 import LocalAuthentication
 #endif
@@ -13189,9 +13190,10 @@ struct CMUXCLI {
             unsetenv("CMUX_ORIGINAL_NODE_OPTIONS")
             return
         }
-        if let existing = processEnvironment["NODE_OPTIONS"] {
+        if let existing = processEnvironment["NODE_OPTIONS"],
+           let originalNodeOptions = normalizedNodeOptionsForRestore(existing) {
             setenv("CMUX_ORIGINAL_NODE_OPTIONS_PRESENT", "1", 1)
-            setenv("CMUX_ORIGINAL_NODE_OPTIONS", normalizedNodeOptionsForRestore(existing), 1)
+            setenv("CMUX_ORIGINAL_NODE_OPTIONS", originalNodeOptions, 1)
         } else {
             setenv("CMUX_ORIGINAL_NODE_OPTIONS_PRESENT", "0", 1)
             unsetenv("CMUX_ORIGINAL_NODE_OPTIONS")
@@ -13233,14 +13235,23 @@ struct CMUXCLI {
     }
 
     private func createClaudeNodeOptionsRestoreModule() throws -> URL {
-        let root = URL(fileURLWithPath: NSTemporaryDirectory(), isDirectory: true)
-            .appendingPathComponent("cmux-claude-node-options", isDirectory: true)
+        let root = try claudeNodeOptionsRestoreDirectory()
         try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true, attributes: nil)
-        let restoreModuleURL = root.appendingPathComponent("restore-node-options.cjs", isDirectory: false)
+        let restoreModuleURL = root.appendingPathComponent(NodeOptionsSupport.restoreModuleFilename, isDirectory: false)
         try writeShimIfChanged(Self.claudeNodeOptionsRestoreModule, to: restoreModuleURL)
         return restoreModuleURL
     }
 
+    private func claudeNodeOptionsRestoreDirectory() throws -> URL {
+        try NodeOptionsSupport.claudeRestoreDirectory(
+            homePath: ProcessInfo.processInfo.environment["HOME"],
+            appSupportDirectory: FileManager.default.urls(
+                for: .applicationSupportDirectory,
+                in: .userDomainMask
+            ).first
+        )
+    }
+
     private func runClaudeTeams(
         commandArgs: [String],
         socketPath: String,
@@ -15182,9 +15193,10 @@ struct CMUXCLI {
             unsetenv("CMUX_ORIGINAL_NODE_OPTIONS")
             return
         }
-        if let existing = processEnvironment["NODE_OPTIONS"] {
+        if let existing = processEnvironment["NODE_OPTIONS"],
+           let originalNodeOptions = normalizedNodeOptionsForRestore(existing) {
             setenv("CMUX_ORIGINAL_NODE_OPTIONS_PRESENT", "1", 1)
-            setenv("CMUX_ORIGINAL_NODE_OPTIONS", normalizedNodeOptionsForRestore(existing), 1)
+            setenv("CMUX_ORIGINAL_NODE_OPTIONS", originalNodeOptions, 1)
         } else {
             setenv("CMUX_ORIGINAL_NODE_OPTIONS_PRESENT", "0", 1)
             unsetenv("CMUX_ORIGINAL_NODE_OPTIONS")
@@ -18771,61 +18783,6 @@ struct CMUXCLI {
         }
     }
 
-    private func mergedNodeOptions(existing: String?, restoreModulePath: String) -> String {
-        let requireOption = "--require=\(restoreModulePath)"
-        let memoryOption = "--max-old-space-size=4096"
-        let cleanedExisting = cleanedNodeOptions(existing)
-        guard !cleanedExisting.isEmpty else {
-            return "\(requireOption) \(memoryOption)"
-        }
-        return "\(requireOption) \(memoryOption) \(cleanedExisting)"
-    }
-
-    private func cleanedNodeOptions(_ existing: String?) -> String {
-        let tokens = (existing ?? "")
-            .split(whereSeparator: \.isWhitespace)
-            .map(String.init)
-        guard !tokens.isEmpty else { return "" }
-
-        var filtered: [String] = []
-        var index = 0
-        while index < tokens.count {
-            let token = tokens[index]
-            if token == "--max-old-space-size" {
-                index += min(2, tokens.count - index)
-                continue
-            }
-            if token.hasPrefix("--max-old-space-size=") {
-                index += 1
-                continue
-            }
-            filtered.append(token)
-            index += 1
-        }
-        return filtered.joined(separator: " ")
-    }
-
-    private func normalizedNodeOptionsForRestore(_ existing: String) -> String {
-        let tokens = existing
-            .split(whereSeparator: \.isWhitespace)
-            .map(String.init)
-        guard !tokens.isEmpty else { return "" }
-
-        var normalized: [String] = []
-        var index = 0
-        while index < tokens.count {
-            let token = tokens[index]
-            if token == "--max-old-space-size", index + 1 < tokens.count {
-                normalized.append("--max-old-space-size=\(tokens[index + 1])")
-                index += 2
-                continue
-            }
-            normalized.append(token)
-            index += 1
-        }
-        return normalized.joined(separator: " ")
-    }
-
     // MARK: - Codex hooks
 
     /// The hooks.json content that cmux installs into ~/.codex/.

Packages/CMUXAgentLaunch/Package.swift

@@ -14,11 +14,12 @@ let package = Package(
     ],
     dependencies: [
         .package(path: "../CMUXAgentVault"),
+        .package(path: "../CMUXNodeOptions"),
     ],
     targets: [
         .target(
             name: "CMUXAgentLaunch",
-            dependencies: ["CMUXAgentVault"]
+            dependencies: ["CMUXAgentVault", "CMUXNodeOptions"]
         ),
         .testTarget(
             name: "CMUXAgentLaunchTests",

Packages/CMUXAgentLaunch/Sources/CMUXAgentLaunch/AgentLaunchEnvironmentPolicy.swift

@@ -1,4 +1,5 @@
 import Foundation
+import CMUXNodeOptions
 
 public enum ClaudeConfigDirectoryPath {
     public static func preferredPath(
@@ -87,7 +88,7 @@ public enum AgentLaunchEnvironmentPolicy {
         case "CLAUDE_CONFIG_DIR":
             return value.map { ClaudeConfigDirectoryPath.preferredPath($0) }
         case "NODE_OPTIONS":
-            return sanitizedNodeOptions(value)
+            return NodeOptionsSupport.normalizedNodeOptionsForRestore(value)
         default:
             return value
         }
@@ -96,93 +97,19 @@ public enum AgentLaunchEnvironmentPolicy {
     private static func selectedNodeOptions(from env: [String: String]) -> String? {
         switch normalizedValue(env["CMUX_ORIGINAL_NODE_OPTIONS_PRESENT"]) {
         case "1":
-            return sanitizedNodeOptions(env["CMUX_ORIGINAL_NODE_OPTIONS"])
+            return NodeOptionsSupport.normalizedNodeOptionsForRestore(env["CMUX_ORIGINAL_NODE_OPTIONS"])
         case "0":
             return nil
         default:
-            return sanitizedNodeOptions(env["NODE_OPTIONS"])
+            return NodeOptionsSupport.normalizedNodeOptionsForRestore(env["NODE_OPTIONS"])
         }
     }
 
-    private static func sanitizedNodeOptions(_ rawValue: String?) -> String? {
-        let tokens = rawValue?
-            .split(whereSeparator: \.isWhitespace)
-            .map(String.init) ?? []
-        guard !tokens.isEmpty else { return nil }
-
-        var sanitized: [String] = []
-        var index = 0
-        var shouldDropInjectedHeapCap = false
-        while index < tokens.count {
-            let token = tokens[index]
-
-            if shouldDropInjectedHeapCap, isInjectedNodeHeapCap(tokens, index: index) {
-                index += nodeHeapCapWidth(tokens, index: index)
-                shouldDropInjectedHeapCap = false
-                continue
-            }
-            shouldDropInjectedHeapCap = false
-
-            if isRequireOption(token), index + 1 < tokens.count,
-               isCmuxNodeOptionsRestoreModulePath(tokens[index + 1]) {
-                index += 2
-                shouldDropInjectedHeapCap = true
-                continue
-            }
-            if let path = inlineRequireOptionPath(token),
-               isCmuxNodeOptionsRestoreModulePath(path) {
-                index += 1
-                shouldDropInjectedHeapCap = true
-                continue
-            }
-
-            sanitized.append(token)
-            index += 1
-        }
-
-        let joined = sanitized.joined(separator: " ")
-            .trimmingCharacters(in: .whitespacesAndNewlines)
-        return joined.isEmpty ? nil : joined
-    }
-
     private static func normalizedValue(_ value: String?) -> String? {
         guard let trimmed = value?.trimmingCharacters(in: .whitespacesAndNewlines),
               !trimmed.isEmpty else {
             return nil
         }
         return trimmed
     }
-
-    private static func isRequireOption(_ token: String) -> Bool {
-        token == "--require" || token == "-r"
-    }
-
-    private static func inlineRequireOptionPath(_ token: String) -> String? {
-        for prefix in ["--require=", "-r="] where token.hasPrefix(prefix) {
-            return String(token.dropFirst(prefix.count))
-        }
-        return nil
-    }
-
-    private static func isCmuxNodeOptionsRestoreModulePath(_ value: String) -> Bool {
-        let trimmed = value.trimmingCharacters(in: CharacterSet(charactersIn: "'\""))
-        guard URL(fileURLWithPath: trimmed).lastPathComponent == "restore-node-options.cjs" else {
-            return false
-        }
-        return trimmed.contains("/cmux-")
-    }
-
-    private static func isInjectedNodeHeapCap(_ tokens: [String], index: Int) -> Bool {
-        guard index < tokens.count else { return false }
-        let token = tokens[index]
-        if token == "--max-old-space-size" {
-            return index + 1 < tokens.count && tokens[index + 1] == "4096"
-        }
-        return token == "--max-old-space-size=4096"
-    }
-
-    private static func nodeHeapCapWidth(_ tokens: [String], index: Int) -> Int {
-        guard index < tokens.count else { return 1 }
-        return tokens[index] == "--max-old-space-size" ? min(2, tokens.count - index) : 1
-    }
 }

Packages/CMUXNodeOptions/Package.swift

@@ -0,0 +1,22 @@
+// swift-tools-version: 5.9
+
+import PackageDescription
+
+let package = Package(
+    name: "CMUXNodeOptions",
+    platforms: [
+        .macOS(.v13),
+    ],
+    products: [
+        .library(
+            name: "CMUXNodeOptions",
+            targets: ["CMUXNodeOptions"]
+        ),
+    ],
+    targets: [
+        .target(
+            name: "CMUXNodeOptions",
+            path: "Sources/CMUXNodeOptions"
+        ),
+    ]
+)