refactor(cli): unify on clawdis CLI + node permissions

apps/macos/Sources/Clawdis/ShellExecutor.swift

@@ -2,8 +2,30 @@ import ClawdisIPC
 import Foundation
 
 enum ShellExecutor {
-    static func run(command: [String], cwd: String?, env: [String: String]?, timeout: Double?) async -> Response {
-        guard !command.isEmpty else { return Response(ok: false, message: "empty command") }
+    struct ShellResult {
+        var stdout: String
+        var stderr: String
+        var exitCode: Int?
+        var timedOut: Bool
+        var success: Bool
+        var errorMessage: String?
+    }
+
+    static func runDetailed(
+        command: [String],
+        cwd: String?,
+        env: [String: String]?,
+        timeout: Double?) async -> ShellResult
+    {
+        guard !command.isEmpty else {
+            return ShellResult(
+                stdout: "",
+                stderr: "",
+                exitCode: nil,
+                timedOut: false,
+                success: false,
+                errorMessage: "empty command")
+        }
 
         let process = Process()
         process.executableURL = URL(fileURLWithPath: "/usr/bin/env")
@@ -19,36 +41,59 @@ enum ShellExecutor {
         do {
             try process.run()
         } catch {
-            return Response(ok: false, message: "failed to start: \(error.localizedDescription)")
+            return ShellResult(
+                stdout: "",
+                stderr: "",
+                exitCode: nil,
+                timedOut: false,
+                success: false,
+                errorMessage: "failed to start: \(error.localizedDescription)")
         }
 
-        let waitTask = Task { () -> Response in
+        let waitTask = Task { () -> ShellResult in
             process.waitUntilExit()
             let out = stdoutPipe.fileHandleForReading.readToEndSafely()
             let err = stderrPipe.fileHandleForReading.readToEndSafely()
-            let status = process.terminationStatus
-            let combined = out.isEmpty ? err : out
-            return Response(ok: status == 0, message: status == 0 ? nil : "exit \(status)", payload: combined)
+            let status = Int(process.terminationStatus)
+            return ShellResult(
+                stdout: String(decoding: out, as: UTF8.self),
+                stderr: String(decoding: err, as: UTF8.self),
+                exitCode: status,
+                timedOut: false,
+                success: status == 0,
+                errorMessage: status == 0 ? nil : "exit \(status)")
         }
 
         if let timeout, timeout > 0 {
             let nanos = UInt64(timeout * 1_000_000_000)
-            let response = await withTaskGroup(of: Response.self) { group in
+            let result = await withTaskGroup(of: ShellResult.self) { group in
                 group.addTask { await waitTask.value }
                 group.addTask {
                     try? await Task.sleep(nanoseconds: nanos)
                     if process.isRunning { process.terminate() }
                     _ = await waitTask.value // drain pipes after termination
-                    return Response(ok: false, message: "timeout")
+                    return ShellResult(
+                        stdout: "",
+                        stderr: "",
+                        exitCode: nil,
+                        timedOut: true,
+                        success: false,
+                        errorMessage: "timeout")
                 }
-                // Whichever completes first (process exit or timeout) wins; cancel the other branch.
                 let first = await group.next()!
                 group.cancelAll()
                 return first
             }
-            return response
+            return result
         }
 
         return await waitTask.value
     }
+
+    static func run(command: [String], cwd: String?, env: [String: String]?, timeout: Double?) async -> Response {
+        let result = await self.runDetailed(command: command, cwd: cwd, env: env, timeout: timeout)
+        let combined = result.stdout.isEmpty ? result.stderr : result.stdout
+        let payload = combined.isEmpty ? nil : Data(combined.utf8)
+        return Response(ok: result.success, message: result.errorMessage, payload: payload)
+    }
 }