@deepblend/dsh-blender-provider-local 0.2.11 → 0.2.13

package/lib/index.js

@@ -591,6 +591,14 @@ export default class LocalBlenderRuntime extends Service {
   /** The kept Blender for `sessionActions`, and the timer that closes it when it goes quiet. */
   _session = null
   _sessionTimer = null
+  /**
+   * Which transport the kept session came from: `configured`, `discovered` or `spawned`.
+   *
+   * Recorded rather than inferred, because "is this deployment driving the user's Blender or one of
+   * its own" is the first question anybody asks of a Live Bridge that behaves unexpectedly — and the
+   * only place that knows is the branch that chose.
+   */
+  _sessionOrigin = null
 
   /**
    * @param {import('@deepseek-ai/cordis').Context} ctx
@@ -1021,12 +1029,39 @@ export default class LocalBlenderRuntime extends Service {
    */
   async _keptSession() {
     if (this._session !== null && !this._session.closed) return this._session
-    const socket = this.config.sessionSocket
-    // THE USER'S BLENDER, when they have named one. `attachSession` owns the refusal and its message;
-    // this only decides which of the two transports the configured actions travel over.
-    this._session = typeof socket === 'string' && socket.length > 0
-      ? await this.attachSession(socket)
-      : await this.openSession()
+
+    const configured = this.config.sessionSocket
+    if (typeof configured === 'string' && configured.length > 0) {
+      // NAMED BY THE OPERATOR, so it is used and a failure is theirs to see. `attachSession` owns the
+      // refusal and its message; this only decides which transport the configured actions travel over.
+      this._session = await this.attachSession(configured)
+      this._sessionOrigin = 'configured'
+      return this._session
+    }
+
+    // DISCOVERY, WHICH IS NOT A GUESS. The convention says a bridge listens at
+    // `<workspace>/.deepblend/bridge.sock`, and a deployment that opted into sessions should not have
+    // to write that path down as well. A GUESS asserts and fails when it is wrong; this CHECKS and
+    // falls back — something answering at the conventional path is used, and nothing answering means
+    // exactly what happened before this existed. The wrong-blender check still applies to whatever is
+    // found, so discovery cannot attach to another workspace's Blender.
+    const conventional = join(this.workspaceRoot, '.deepblend', 'bridge.sock')
+    if (existsSync(conventional)) {
+      const found = await this.attachSession(conventional).then(
+        session => session,
+        () => null,
+      )
+      if (found !== null) {
+        this._session = found
+        this._sessionOrigin = 'discovered'
+        return this._session
+      }
+      // A file that exists and does not answer is the state a crash leaves; the bridge replaces it
+      // when it starts again, and until then this deployment spawns its own Blender as before.
+    }
+
+    this._session = await this.openSession()
+    this._sessionOrigin = 'spawned'
     return this._session
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepblend/dsh-blender-provider-local",
-  "version": "0.2.11",
+  "version": "0.2.13",
   "type": "module",
   "description": "Local Blender Provider: the BlenderRuntime Service over ctx.subprocess (batch execution).",
   "main": "lib/index.js",
@@ -11,7 +11,7 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@deepblend/dsh-blender-contracts": "0.2.11"
+    "@deepblend/dsh-blender-contracts": "0.2.13"
   },
   "license": "MIT",
   "repository": {

package/python/deepblend_bridge.py

@@ -90,6 +90,26 @@ bl_info = {
 # add-on uses when a user enables it with no configuration.
 DEFAULT_SOCKET = os.path.join(os.path.expanduser("~"), ".deepblend-bridge.sock")
 
+# THE PER-WORKSPACE CONVENTION, and the reason it exists: the global default above is ONE path for the
+# whole machine, so two workspaces with a Blender each collide there — the second refuses now, which is
+# honest but is still the user's problem to solve by hand. When a bridge knows its workspace, it can
+# simply listen somewhere that belongs to that workspace, and the collision never happens.
+#
+# The path is inside `.deepblend/`, which is the store and is gitignored — a socket is a runtime object,
+# not a source file, and it must never be committable.
+WORKSPACE_SOCKET_RELATIVE = os.path.join(".deepblend", "bridge.sock")
+
+
+def default_socket_for(workspace):
+    """Where a bridge should listen, given what it knows.
+
+    A workspace it knows gives a path that belongs to that workspace; a workspace it does not know
+    gives the machine-wide default, which is what every deployment had before this convention.
+    """
+    if isinstance(workspace, str) and workspace != "":
+        return os.path.join(workspace, WORKSPACE_SOCKET_RELATIVE)
+    return DEFAULT_SOCKET
+
 
 class _Bridge:
     """The serving state: one socket, one thread, and the last thing that happened."""
@@ -134,6 +154,11 @@ class _Bridge:
             # Nothing answers, so it is the file a process that died left behind. Refusing here would
             # leave the user with no way forward except deleting a file they cannot see.
             os.unlink(self.socket_path)
+        # A workspace-derived path lives inside `.deepblend/`, which may not exist yet on a machine
+        # where the product has never run — and `bind` does not create directories.
+        parent = os.path.dirname(self.socket_path)
+        if parent and not os.path.isdir(parent):
+            os.makedirs(parent, exist_ok=True)
         self.server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
         self.server.bind(self.socket_path)
         self.server.listen(4)
@@ -314,11 +339,11 @@ class DEEPBLEND_PT_bridge(bpy.types.Panel):
 
 def register():
     global _BRIDGE
-    socket_path = os.environ.get("DEEPBLEND_BRIDGE_SOCKET", DEFAULT_SOCKET)
     workspace = os.environ.get("DEEPBLEND_BRIDGE_WORKSPACE", "")
     if workspace == "":
         # In a GUI the user has a file open, and if the product wrote it, it names the workspace.
         workspace = _Bridge.derive_workspace(getattr(bpy.data, "filepath", ""))
+    socket_path = os.environ.get("DEEPBLEND_BRIDGE_SOCKET") or default_socket_for(workspace)
     _BRIDGE = _Bridge(socket_path, {"workspace": workspace})
     try:
         _BRIDGE.start()
@@ -357,11 +382,13 @@ def main():
                 index += 2
                 continue
             index += 1
-    socket_path = options.get("socket", DEFAULT_SOCKET)
     if workspace == "":
         # WHAT THE OPEN FILE SAYS, when it says anything. An operator's explicit setting always wins;
         # this only fills a silence, and only from a path that follows the product's own layout.
         workspace = _Bridge.derive_workspace(getattr(bpy.data, "filepath", ""))
+    # THE SOCKET FOLLOWS THE WORKSPACE, so two workspaces with a Blender each do not collide at all.
+    # An explicit DEEPBLEND_BRIDGE_SOCKET still wins, exactly as an explicit workspace does.
+    socket_path = options.get("socket") or os.environ.get("DEEPBLEND_BRIDGE_SOCKET") or default_socket_for(workspace)
 
     if bootstrap is None:
         print(json.dumps({"kind": "error", "message": BOOTSTRAP_PROBLEM}), flush=True)