Edit a score that runs on another machine

ci/common.deps.sh

@@ -63,7 +63,9 @@ clone_addon() {
   )
 }
 
-clone_addon https://github.com/ossia/iscore-addon-network
+# Paired with the session work on the add-on: the two repositories change
+# together, so CI has to build the branch that matches rather than master.
+clone_addon https://github.com/ossia/iscore-addon-network remote-control
 clone_addon https://github.com/ossia/score-addon-synthimi
 clone_addon https://github.com/ossia/score-addon-jk
 clone_addon https://github.com/ossia/GBAP

src/lib/CMakeLists.txt

@@ -103,6 +103,7 @@ set(HEADERS
     "${CMAKE_CURRENT_SOURCE_DIR}/score/application/ApplicationComponents.hpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/score/application/ApplicationContext.hpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/score/application/ApplicationServices.hpp"
+    "${CMAKE_CURRENT_SOURCE_DIR}/score/application/ScriptEvaluator.hpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/score/application/GUIApplicationContext.hpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/score/command/AggregateCommand.hpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/score/command/Command.hpp"
@@ -413,6 +414,7 @@ set(SRCS
 "${CMAKE_CURRENT_SOURCE_DIR}/score/application/ApplicationContext.cpp"
 "${CMAKE_CURRENT_SOURCE_DIR}/score/application/ApplicationComponents.cpp"
 "${CMAKE_CURRENT_SOURCE_DIR}/score/application/ApplicationServices.cpp"
+"${CMAKE_CURRENT_SOURCE_DIR}/score/application/ScriptEvaluator.cpp"
 
 "${CMAKE_CURRENT_SOURCE_DIR}/score/actions/Action.cpp"
 "${CMAKE_CURRENT_SOURCE_DIR}/score/actions/ActionManager.cpp"

src/lib/core/application/ApplicationSettings.cpp

@@ -10,14 +10,56 @@
 #include <QFileInfo>
 #include <QObject>
 #include <QString>
+#include <QUrlQuery>
+
+#if defined(__EMSCRIPTEN__)
+#include <emscripten.h>
+#endif
 
 #include <score_git_info.hpp>
 
 #include <thread>
 namespace score
 {
+#if defined(__EMSCRIPTEN__)
+namespace
+{
+//! A page has no command line: ?network-join=host:port&network-terminal
+//! reaches score as --network-join=host:port --network-terminal.
+//!
+//! Passed through without an allow-list, so a link can ask a page to do
+//! whatever a command line could.
+QStringList argumentsFromUrl()
+{
+  QStringList out;
+  const char* raw = emscripten_run_script_string("location.search");
+  if(!raw || !*raw)
+    return out;
+
+  QString search = QString::fromUtf8(raw);
+  if(search.startsWith('?'))
+    search.remove(0, 1);
+
+  const QUrlQuery query{search};
+  for(const auto& [key, value] : query.queryItems(QUrl::FullyDecoded))
+  {
+    if(key.isEmpty())
+      continue;
+
+    out += value.isEmpty() ? QStringLiteral("--%1").arg(key)
+                           : QStringLiteral("--%1=%2").arg(key, value);
+  }
+  return out;
+}
+}
+#endif
+
 void ApplicationSettings::parse(QStringList cargs, int& argc, char** argv)
 {
+#if defined(__EMSCRIPTEN__)
+  cargs += argumentsFromUrl();
+#endif
+
   arguments = cargs;
 
   opengl = false;

src/lib/core/command/CommandStackSerialization.hpp

@@ -24,12 +24,15 @@ void loadCommandStack(
   stack.updateStack([&]() {
     stack.setSavedIndex(-1);
 
+    // A command we cannot read stops the history there rather than the load:
+    // what precedes it is consistent, what follows would undo against a state
+    // we never reached.
     bool ok = true;
     for(const auto& elt : undoStack)
     {
-      auto cmd = components.instantiateUndoCommand(elt);
+      auto cmd = components.instantiateUndoCommandIfAvailable(elt);
 
-      if(redo_fun(cmd))
+      if(cmd && redo_fun(cmd))
       {
         stack.undoable().push(cmd);
       }
@@ -44,7 +47,9 @@ void loadCommandStack(
     {
       for(const auto& elt : redoStack)
       {
-        auto cmd = components.instantiateUndoCommand(elt);
+        auto cmd = components.instantiateUndoCommandIfAvailable(elt);
+        if(!cmd)
+          break;
 
         stack.redoable().push(cmd);
       }

src/lib/core/document/Document.cpp

@@ -123,11 +123,26 @@ const std::vector<DocumentPlugin*>& DocumentContext::pluginModels() const
   return document.model().pluginModels();
 }
 
+void Document::setScriptSink(ScriptSink s)
+{
+  m_scriptSink = std::move(s);
+}
+
+const Document::ScriptSink& Document::scriptSink() const noexcept
+{
+  return m_scriptSink;
+}
+
 score::Environment& DocumentContext::environment() const noexcept
 {
   return document.environment();
 }
 
+score::DocumentRole DocumentContext::role() const noexcept
+{
+  return document.role();
+}
+
 Document::Document(
     const QString& name, const Id<DocumentModel>& id, DocumentDelegateFactory& factory,
     QWidget* parentview, QObject* parent)

src/lib/core/document/Document.hpp

@@ -1,5 +1,6 @@
 #pragma once
 #include <score/document/DocumentContext.hpp>
+#include <score/document/DocumentRole.hpp>
 #include <score/tools/Environment.hpp>
 #include <score/locking/ObjectLocker.hpp>
 #include <score/selection/FocusManager.hpp>
@@ -13,6 +14,8 @@
 
 #include <QByteArray>
 #include <QString>
+
+#include <functional>
 #include <QTimer>
 #include <QVariant>
 
@@ -85,6 +88,21 @@ class SCORE_LIB_BASE_EXPORT Document final : public QObject
   //! typically, once it is being edited through a session.
   void setEnvironment(std::unique_ptr<score::Environment> env);
 
+  //! Where a script typed here should run. Set when this document is a view of
+  //! a score running elsewhere: the console then asks that machine instead of
+  //! answering from a document with no devices and no execution behind it.
+  //! `onResult` is called with what the other machine printed.
+  using ScriptSink
+      = std::function<void(const QString& code, std::function<void(QString)> onResult)>;
+  void setScriptSink(ScriptSink s);
+  const ScriptSink& scriptSink() const noexcept;
+
+  //! Whether this document may drive the hardware of the machine it is open on.
+  //!
+  //! Fixed at construction: devices connect while their plug-in deserializes,
+  //! so a document that must not claim them has to say so before it is read.
+  DocumentRole role() const noexcept { return m_role; }
+
   DocumentModel& model() const noexcept { return *m_model; }
 
   DocumentPresenter* presenter() const noexcept { return m_presenter; }
@@ -130,7 +148,8 @@ class SCORE_LIB_BASE_EXPORT Document final : public QObject
 
   Document(
       const QString& name, const QByteArray& data, SerializationIdentifier format,
-      DocumentDelegateFactory& type, QWidget* parentview, QObject* parent);
+      DocumentDelegateFactory& type, QWidget* parentview, QObject* parent,
+      DocumentRole role = DocumentRole::Local);
 
   // Restore
   Document(
@@ -163,6 +182,8 @@ class SCORE_LIB_BASE_EXPORT Document final : public QObject
 
   DocumentContext m_context;
   mutable std::unique_ptr<score::Environment> m_environment;
+  ScriptSink m_scriptSink;
+  DocumentRole m_role{DocumentRole::Local};
 
   std::optional<score::RestorableDocument> m_initialData{};
   bool m_virgin{false}; // Used to check if we can safely close it

src/lib/core/document/DocumentBuilder.cpp

@@ -123,13 +123,14 @@ Document* DocumentBuilder::loadDocument(
 SCORE_LIB_BASE_EXPORT
 Document* DocumentBuilder::loadDocument(
     const score::GUIApplicationContext& ctx, QString filename, QByteArray data,
-    SerializationIdentifier format, DocumentDelegateFactory& doctype)
+    SerializationIdentifier format, DocumentDelegateFactory& doctype, DocumentRole role)
 {
   Document* doc = nullptr;
   auto& doclist = ctx.documents.documents();
   try
   {
-    doc = new Document{filename, data, format, doctype, m_parentView, m_parentPresenter};
+    doc = new Document{
+        filename, data, format, doctype, m_parentView, m_parentPresenter, role};
     for(auto& appPlug : ctx.guiApplicationPlugins())
     {
       appPlug->on_loadedDocument(*doc);

src/lib/core/document/DocumentBuilder.hpp

@@ -1,4 +1,5 @@
 #pragma once
+#include <score/document/DocumentRole.hpp>
 #include <score/model/Identifier.hpp>
 #include <score/serialization/VisitorInterface.hpp>
 
@@ -36,7 +37,8 @@ class SCORE_LIB_BASE_EXPORT DocumentBuilder
       score::DocumentDelegateFactory& doctype);
   Document* loadDocument(
       const score::GUIApplicationContext& ctx, QString filename, QByteArray data,
-      SerializationIdentifier format, score::DocumentDelegateFactory& doctype);
+      SerializationIdentifier format, score::DocumentDelegateFactory& doctype,
+      DocumentRole role = DocumentRole::Local);
   Document* restoreDocument(
       const score::GUIApplicationContext& ctx, const score::RestorableDocument& doc,
       score::DocumentDelegateFactory& doctype);

src/lib/core/document/DocumentSerialization.cpp

@@ -166,13 +166,17 @@ Document::Document(
 
 Document::Document(
     const QString& fileName, const QByteArray& data, SerializationIdentifier format,
-    DocumentDelegateFactory& factory, QWidget* parentview, QObject* parent)
+    DocumentDelegateFactory& factory, QWidget* parentview, QObject* parent,
+    DocumentRole role)
     : QObject{parent}
     , m_metadata{fileName}
     , m_commandStack{*this}
     , m_objectLocker{this}
     , m_context{*this}
+    , m_role{role}
 {
+  // Before loadModel: devices are instantiated as the device plug-in is read,
+  // and a terminal must not claim any of them.
   loadModel(fileName, data, format, factory);
 
   if(parentview)

src/lib/core/presenter/DocumentManager.cpp

@@ -744,11 +744,8 @@ DocumentManager::Loadability DocumentManager::checkAndUpdateJson(
     auto it = local_plugins.find(plug.plugin);
     if(it == local_plugins.end())
     {
-      // Not fatal. Refusing here used to make a document unopenable on any
-      // machine that did not have every plug-in it mentions -- which is every
-      // machine, once builds differ by platform -- and it could not see a
-      // factory missing inside a plug-in that *is* present anyway, so it never
-      // gave the guarantee it appeared to.
+      // Not fatal: it never gave the guarantee it looked like, since a
+      // factory missing inside a present plug-in is invisible to it.
       res.missingPlugins.push_back(plug.plugin);
     }
     else

src/lib/score/application/ScriptEvaluator.cpp

@@ -0,0 +1,12 @@
+#include <score/application/ScriptEvaluator.hpp>
+
+namespace score
+{
+ScriptEvaluator::~ScriptEvaluator() = default;
+
+ScriptEvaluator*& scriptEvaluator() noexcept
+{
+  static ScriptEvaluator* instance{};
+  return instance;
+}
+}

src/lib/score/application/ScriptEvaluator.hpp

@@ -0,0 +1,37 @@
+#pragma once
+#include <QString>
+
+#include <score_lib_base_export.h>
+
+namespace score
+{
+struct DocumentContext;
+
+/**
+ * @brief Running a script on this machine, for somebody who is not here.
+ *
+ * A terminal's console edits a score that runs elsewhere. Commands happen to
+ * replicate, so `Score.createProcess` appears to work -- but everything that is
+ * not a command runs against the terminal's own document, where there are no
+ * devices, no execution and no hardware. `Score.device("x")` is null there and
+ * always will be.
+ *
+ * Rather than forwarding one call at a time, the script itself goes to the
+ * machine that can answer it. Which means the session layer has to run
+ * JavaScript, and it has no business knowing what JavaScript is: it looks up
+ * this interface, which the JS plug-in registers if it is loaded, and finds
+ * nothing if it is not.
+ */
+struct SCORE_LIB_BASE_EXPORT ScriptEvaluator
+{
+  virtual ~ScriptEvaluator();
+
+  //! Evaluate `code` against `ctx`. The returned string is what a console
+  //! would have printed -- the value, or the error.
+  virtual QString evaluate(const score::DocumentContext& ctx, const QString& code) = 0;
+};
+
+//! The evaluator for this process, or null when nothing registered one.
+//! Set once at startup by whichever plug-in can actually run scripts.
+SCORE_LIB_BASE_EXPORT ScriptEvaluator*& scriptEvaluator() noexcept;
+}

src/lib/score/document/DocumentContext.hpp

@@ -2,6 +2,7 @@
 #include <score/command/CommandStackFacade.hpp>
 #include <score/command/Dispatchers/OngoingCommandDispatcher.hpp>
 #include <score/document/DocumentInterface.hpp>
+#include <score/document/DocumentRole.hpp>
 #include <score/selection/FocusManager.hpp>
 class IdentifiedObjectAbstract;
 class QTimer;
@@ -36,6 +37,9 @@ struct SCORE_LIB_BASE_EXPORT DocumentContext
   //! the score. Ask rather than assuming a path can be opened.
   score::Environment& environment() const noexcept;
 
+  //! Whether this document may claim the hardware of the machine it is open on.
+  score::DocumentRole role() const noexcept;
+
   template <typename T>
   T& model() const
   {

src/lib/score/document/DocumentRole.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+namespace score
+{
+/**
+ * @brief What a document is allowed to do to the machine it is open on.
+ *
+ * A score names hardware: sound cards, MIDI ports, cameras, OSC sockets,
+ * render windows. Opening one has always meant claiming all of it, because the
+ * machine holding the document was the machine running the show.
+ *
+ * That stops being true once a score can be edited from somewhere else. A
+ * laptop driving a score that plays on a headless box must not open that box's
+ * MIDI ports on itself, nor put its render window on the wrong screen -- and
+ * the browser it might be a tab in has none of those things to offer anyway.
+ *
+ * Distinct from score::Environment, which answers where the *files* are: a
+ * peer in a multiplayer session reads its score from another machine and still
+ * plays it on its own hardware. Both answers are needed, and they differ.
+ *
+ * Known before the document is read rather than set afterwards: devices
+ * connect while their plug-in deserializes, so anything decided later is
+ * decided too late.
+ */
+enum class DocumentRole
+{
+  //! Ordinary. Devices connect, execution runs here, windows open here.
+  Local,
+
+  //! The score runs elsewhere. This copy is for editing and watching it: no
+  //! ports, no hardware, no rendering, no executor.
+  Terminal
+};
+}

src/lib/score/model/path/ObjectPath.hpp

@@ -112,10 +112,8 @@ class SCORE_LIB_BASE_EXPORT ObjectPath
   template <class T>
   T& find(const score::DocumentContext& ctx) const
   {
-    // Checked rather than assumed, for the reason given on try_find: an object
-    // of another type can be standing where this path points. safe_cast would
-    // abort in debug and cast blind in release; throwing lets the caller --
-    // a command being replayed from another peer, typically -- report it.
+    // Checked: another type can stand where this path points, and safe_cast
+    // aborts in debug and casts blind in release.
     auto raw = m_cache.isNull() ? find_impl(ctx) : m_cache.data();
     auto ptr = dynamic_cast<typename std::remove_const<T>::type*>(raw);
     if(!ptr)