isActive: () => {
   const current = app.shell.currentWidget;
   return (
     current &&
     (notebookTracker.has(current) || consoleTracker.has(current))
   );
 }

 isEnabled: current => {
   let found = false;
   consoleTracker.forEach(console => {
     if (console.console.session.path === current.context.path) {
       found = true;
     }
   });
   return found;
 },

 app.shell.currentChanged.connect((sender, args) => {
   let widget = args.newValue;
   if (!widget || !consoles.has(widget)) {
     return;
   }
   let source = handlers[widget.id];
   if (source) {
     manager.source = source;
   }
 });

 restartAndRunAll: current => {
   const console = consoleTracker.find(
     console => console.session.path === current.context.path
   );
   if (console) {
     return console.session.restart().then(restarted => {
       if (restarted) {
         void commands.execute(CommandIDs.runAllCode);
       }
       return restarted;
     });
   }
 }

    app.shell.currentChanged.connect((shell, change) => {
      const { oldValue, newValue } = change;

      // Check if we need to disconnect the console listener
      // or the notebook active cell listener
      if (oldValue && consoleTracker.has(oldValue)) {
        (oldValue as ConsolePanel).console.promptCellCreated.disconnect(
          onPromptCreated
        );
      } else if (oldValue && notebookTracker.has(oldValue)) {
        (oldValue as NotebookPanel).content.activeCellChanged.disconnect(
          onActiveCellChanged
        );
      }

      // Wire up the new editor to the model if it exists
      if (newValue && consoleTracker.has(newValue)) {
        (newValue as ConsolePanel).console.promptCellCreated.connect(
          onPromptCreated
        );
        const prompt = (newValue as ConsolePanel).console.promptCell;
        item.model!.editor = prompt && prompt.editor;
      } else if (newValue && notebookTracker.has(newValue)) {
        (newValue as NotebookPanel).content.activeCellChanged.connect(
          onActiveCellChanged
        );
        const cell = (newValue as NotebookPanel).content.activeCell;
        item.model!.editor = cell && cell.editor;
      } else if (newValue && editorTracker.has(newValue)) {
        item.model!.editor = (newValue as IDocumentWidget<
          FileEditor
        >).content.editor;
      } else {
        item.model!.editor = null;
      }
    });