This is a request for comments.

runtime/bin/process_impl.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 class _ProcessStartStatus {
   int _errorCode;  // Set to OS error code if process start failed.
   String _errorMessage;  // Set to OS error message if process start failed.
 }
 
 
+// Abstract factory class capable of producing interactive and
+// non-interactive processes.
 class _Process implements Process {
 
-  _Process.start(String path,
-                 List<String> arguments,
-                 [String workingDirectory]) {
+  _Process();
+
+  factory _Process.start(String path,
+                         List<String> arguments,
+                         [String workingDirectory]) {
+    return new _InteractiveProcess.start(path, arguments, workingDirectory);
+  }
+
+  factory _Process.startNonInteractive(String path,
+                                       List<String> arguments,
+                                       String workingDirectory,
+                                       void callback(int exitCode,
+                                                     String stdout,
+                                                     String stderr)) {
+    return new _NonInteractiveProcess.start(path,
+                                            arguments,
+                                            workingDirectory,
+                                            callback);
+  }
+}
+
+
+// _InteractiveProcess is the actual implementation of all processes
+// started from Dart code.
+class _InteractiveProcess extends _Process {
+
+  _InteractiveProcess.start(String path,
+                            List<String> arguments,
+                            String workingDirectory) {
     if (path is !String) {
       throw new ProcessException("Path is not a String: $path");
     }
     _path = path;
 
     if (arguments is !List) {
       throw new ProcessException("Arguments is not a List: $arguments");
     }
     int len = arguments.length;
     _arguments = new ObjectArray<String>(len);
@@ skipping 226 matching lines @@
   _Socket _err;
   Socket _exitHandler;
   int _pid;
   bool _closed;
   bool _killed;
   bool _started;
   Function _onExit;
   Function _onError;
   Function _onStart;
 }
+
+
+// _NonInteractiveProcess is a wrapper around an interactive process
+// that restricts the interface to disallow access to the streams and
+// buffers output so it can be delivered to the callback when the
+// process exits.
+class _NonInteractiveProcess extends _Process {
+
+  _NonInteractiveProcess.start(String path,
+                               List<String> arguments,
+                               String workingDirectory,
+                               Function this._callback) {
+    _process = new _InteractiveProcess.start(path, arguments, workingDirectory);
+
+    // Setup process exit handling.
+    _process.onExit = (exitCode) {
+      _exitCode = exitCode;
+      _checkDone();
+    };
+
+    // Setup stdout handling.
+    _stdoutBuffer = new StringBuffer();
+    var stdoutStream = new StringInputStream(_process.stdout);
+    stdoutStream.onData = () {
+      var data = stdoutStream.read();
+      if (data != null) _stdoutBuffer.add(data);
+    };
+    stdoutStream.onClosed = () {
+      _stdoutClosed = true;
+      _checkDone();
+    };
+
+    // Setup stderr handling.
+    _stderrBuffer = new StringBuffer();
+    var stderrStream = new StringInputStream(_process.stderr);
+    stderrStream.onData = () {
+      var data = stderrStream.read();
+      if (data != null) _stderrBuffer.add(data);
+    };
+    stderrStream.onClosed = () {
+      _stderrClosed = true;
+      _checkDone();
+    };
+  }
+
+  void _checkDone() {
+    if (_exitCode != null && _stderrClosed && _stdoutClosed) {
+      _callback(_exitCode, _stdoutBuffer.toString(), _stderrBuffer.toString());
+    }
+  }
+
+  InputStream get stdout() {
+    throw new ProcessException(
+        'Cannot get stdout stream for process started with '
+        'the startNonInteractive constructor. The entire stdout '
+        'will be supplied in the callback on completion.');
+  }
+
+  InputStream get stderr() {
+    throw new ProcessException(
+        'Cannot get stderr stream for process started with '
+        'the startNonInteractive constructor. The entire stderr '
+        'will be supplied in the callback on completion.');
+  }
+
+  OutputStream get stdin() {
+    throw new ProcessException(
+        'Cannot communicate via stdin with process started with '
+        'the startNonInteractive constructor');
+  }
+
+  void set onStart(void callback()) => _process.onStart = callback;
+
+  void set onExit(void callback(int exitCode)) {
+    throw new ProcessException(
+        'Cannot set exit handler on process started with '
+        'the startNonInteractive constructor. The exit code will '
+        'be supplied in the callback on completion.');
+  }
+
+  void set onError(void callback(ProcessException error)) {
+    _process.onError = callback;
+  }
+
+  void kill() => _process.kill();
+
+  void close() => _process.close();
+
+  Process _process;
+  Function _callback;
+  StringBuffer _stdoutBuffer;
+  StringBuffer _stderrBuffer;
+  int _exitCode;
+  bool _stdoutClosed = false;
+  bool _stderrClosed = false;
+}