We can now name the current VM using the service protocol.

runtime/observatory/lib/src/elements/debugger.dart

 // Copyright (c) 2014, 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.
 
 library debugger_page_element;
 
 import 'dart:async';
 import 'dart:html';
+import 'dart:math';
 import 'observatory_element.dart';
 import 'package:observatory/app.dart';
 import 'package:observatory/cli.dart';
 import 'package:observatory/debugger.dart';
 import 'package:observatory/service.dart';
 import 'package:logging/logging.dart';
 import 'package:polymer/polymer.dart';
 
 // TODO(turnidge): Move Debugger, DebuggerCommand to debugger library.
 abstract class DebuggerCommand extends Command {
@@ skipping 937 matching lines @@
     for (var isolate in debugger.vm.isolates) {
       if (isolate.name.startsWith(args[0])) {
         result.add('${isolate.name} ');
       }
     }
     return new Future.value(result);
   }
   String helpShort = 'Switch the current isolate';
 
   String helpLong =
-      'Switch the current isolate.\n'
+      'Switch, list, or rename isolates.\n'
       '\n'
       'Syntax: isolate <number>\n'
       '        isolate <name>\n';
 }
 
 String _isolateRunState(Isolate isolate) {
   if (isolate.paused) {
     return 'paused';
   } else if (isolate.running) {
     return 'running';
@@ skipping 16 matching lines @@
 
     // Refresh all isolates first.
     var pending = [];
     for (var isolate in debugger.vm.isolates) {
       pending.add(isolate.reload());
     }
     await Future.wait(pending);
 
     const maxIdLen = 9;
     const maxRunStateLen = 7;
-    var maxNameLen = 0;
+    var maxNameLen = 'NAME'.length;
     for (var isolate in debugger.vm.isolates) {
-      if (isolate.name.length > maxNameLen) {
-        maxNameLen = isolate.name.length;
-      }
+      maxNameLen = max(maxNameLen, isolate.name.length);
     }
 
     debugger.console.print("${'ID'.padLeft(maxIdLen, ' ')} "
                            "${'ORIGIN'.padLeft(maxIdLen, ' ')} "
                            "${'NAME'.padRight(maxNameLen, ' ')} "
                            "${'STATE'.padRight(maxRunStateLen, ' ')} "
                            "CURRENT");
     for (var isolate in debugger.vm.isolates) {
       String current = (isolate == debugger.isolate ? '*' : '');
       debugger.console.print(
@@ skipping 100 matching lines @@
   }
 
   String helpShort = 'Refresh debugging information of various sorts';
 
   String helpLong =
       'Refresh debugging information of various sorts.\n'
       '\n'
       'Syntax: refresh <subcommand>\n';
 }
 
+class VmListCommand extends DebuggerCommand {
+  VmListCommand(Debugger debugger) : super(debugger, 'list', []);
+
+  Future run(List<String> args) async {
+    if (args.length > 0) {
+      debugger.console.print('vm list expects no arguments');
+      return;
+    }
+    if (debugger.vm == null) {
+      debugger.console.print("No connected VMs");
+      return;
+    }
+    // TODO(turnidge): Right now there is only one vm listed.
+    var vmList = [debugger.vm];
+
+    var maxAddrLen = 'ADDRESS'.length;
+    var maxNameLen = 'NAME'.length;
+
+    for (var vm in vmList) {
+      maxAddrLen = max(maxAddrLen, vm.target.networkAddress.length);
+      maxNameLen = max(maxNameLen, vm.name.length);
+    }
+
+    debugger.console.print("${'ADDRESS'.padRight(maxAddrLen, ' ')} "
+                           "${'NAME'.padRight(maxNameLen, ' ')} "
+                           "CURRENT");
+    for (var vm in vmList) {
+      String current = (vm == debugger.vm ? '*' : '');
+      debugger.console.print(
+          "${vm.target.networkAddress.padRight(maxAddrLen, ' ')} "
+          "${vm.name.padRight(maxNameLen, ' ')} "
+          "${current}");
+    }
+  }
+
+  String helpShort = 'List all connected Dart virtual machines';
+
+  String helpLong =
+      'List all connected Dart virtual machines..\n'
+      '\n'
+      'Syntax: vm list\n';
+}
+
+class VmNameCommand extends DebuggerCommand {
+  VmNameCommand(Debugger debugger) : super(debugger, 'name', []);
+
+  Future run(List<String> args) async {
+    if (args.length != 1) {
+      debugger.console.print('vm name expects one argument');
+      return;
+    }
+    if (debugger.vm == null) {
+      debugger.console.print('There is no current vm');
+      return;
+    }
+    await debugger.vm.setName(args[0]);
+  }
+
+  String helpShort = 'Rename the current Dart virtual machine';
+
+  String helpLong =
+      'Rename the current Dart virtual machine.\n'
+      '\n'
+      'Syntax: vm name <name>\n';
+}
+
 class VmRestartCommand extends DebuggerCommand {
   VmRestartCommand(Debugger debugger) : super(debugger, 'restart', []);
 
   Future handleModalInput(String line) async {
     if (line == 'yes') {
       debugger.console.printRed('Restarting VM...');
       await debugger.vm.restart();
       debugger.input.exitMode();
     } else if (line == 'no') {
       debugger.console.printRed('VM restart canceled.');
@@ skipping 10 matching lines @@
   String helpShort = 'Restart a Dart virtual machine';
 
   String helpLong =
       'Restart a Dart virtual machine.\n'
       '\n'
       'Syntax: vm restart\n';
 }
 
 class VmCommand extends DebuggerCommand {
   VmCommand(Debugger debugger) : super(debugger, 'vm', [
+      new VmListCommand(debugger),
+      new VmNameCommand(debugger),
       new VmRestartCommand(debugger),
   ]);
 
   Future run(List<String> args) async {
     debugger.console.print("'vm' expects a subcommand (see 'help vm')");
   }
 
   String helpShort = 'Manage a Dart virtual machine';
 
   String helpLong =
@@ skipping 342 matching lines @@
       console.print(
           'Breakpoint ${bpId} ${verb} at ${locString}');
     } else {
       console.print(
           'Future breakpoint ${bpId} ${verb} at ${locString}');
     }
   }
 
   void onEvent(ServiceEvent event) {
     switch(event.kind) {
+      case ServiceEvent.kVMUpdate:
+        var vm = event.owner;
+        console.print("VM ${vm.target.networkAddress} renamed to '${vm.name}'");
+        break;
+
       case ServiceEvent.kIsolateStart:
         {
           var iso = event.owner;
           console.print(
               "Isolate ${iso.number} '${iso.name}' has been created");
           if (isolate == null) {
             console.print("Switching to isolate ${iso.number} '${iso.name}'");
             isolate = iso;
           }
         }
@@ skipping 272 matching lines @@
   isolateChanged(oldValue) {
     debugger.updateIsolate(isolate);
   }
   ObservatoryDebugger debugger = new ObservatoryDebugger();
 
   DebuggerPageElement.created() : super.created() {
     debugger.page = this;
   }
 
   StreamSubscription _resizeSubscription;
+  Future<StreamSubscription> _vmSubscriptionFuture;
   Future<StreamSubscription> _isolateSubscriptionFuture;
   Future<StreamSubscription> _debugSubscriptionFuture;
   Future<StreamSubscription> _stdoutSubscriptionFuture;
   Future<StreamSubscription> _stderrSubscriptionFuture;
   Future<StreamSubscription> _logSubscriptionFuture;
 
   @override
   void attached() {
     super.attached();
     _onResize(null);
 
     // Wire the debugger object to the stack, console, and command line.
     var stackElement = $['stackElement'];
     debugger.stackElement = stackElement;
     stackElement.debugger = debugger;
     debugger.console = $['console'];
     debugger.input = $['commandline'];
     debugger.input.debugger = debugger;
     debugger.init();
 
     _resizeSubscription = window.onResize.listen(_onResize);
+    _vmSubscriptionFuture =
+        app.vm.listenEventStream(VM.kVMStream, debugger.onEvent);
     _isolateSubscriptionFuture =
         app.vm.listenEventStream(VM.kIsolateStream, debugger.onEvent);
     _debugSubscriptionFuture =
         app.vm.listenEventStream(VM.kDebugStream, debugger.onEvent);
     _stdoutSubscriptionFuture =
         app.vm.listenEventStream(VM.kStdoutStream, debugger.onStdout);
     if (_stdoutSubscriptionFuture != null) {
       // TODO(turnidge): How do we want to handle this in general?
       _stdoutSubscriptionFuture.catchError((e, st) {
         Logger.root.info('Failed to subscribe to stdout: $e\n$st\n');
@@ skipping 42 matching lines @@
     int available = windowHeight - fixedHeight;
     int stackHeight = available ~/ 1.6;
     stackDiv.style.setProperty('height', '${stackHeight}px');
   }
 
   @override
   void detached() {
     debugger.isolate = null;
     _resizeSubscription.cancel();
     _resizeSubscription = null;
+    cancelFutureSubscription(_vmSubscriptionFuture);
+    _vmSubscriptionFuture = null;
     cancelFutureSubscription(_isolateSubscriptionFuture);
     _isolateSubscriptionFuture = null;
     cancelFutureSubscription(_debugSubscriptionFuture);
     _debugSubscriptionFuture = null;
     cancelFutureSubscription(_stdoutSubscriptionFuture);
     _stdoutSubscriptionFuture = null;
     cancelFutureSubscription(_stderrSubscriptionFuture);
     _stderrSubscriptionFuture = null;
     cancelFutureSubscription(_logSubscriptionFuture);
     _logSubscriptionFuture = null;
@@ skipping 587 matching lines @@
         }
       });
   }
 
   void focus() {
     $['textBox'].focus();
   }
 
   DebuggerInputElement.created() : super.created();
 }