@adhdev/daemon-core 0.9.82-rc.16 → 0.9.82-rc.18

package/dist/index.mjs

@@ -23865,6 +23865,36 @@ function summarizeMeshSessionRecord(record) {
     isCached: false
   };
 }
+function readLiveMeshNodeWorkspace(args) {
+  const directNodeWorkspace = args.liveSessionRecords.find((record) => readStringValue(record?.meta?.meshNodeId) === args.nodeId && readStringValue(record?.workspace));
+  if (directNodeWorkspace) {
+    return readStringValue(directNodeWorkspace.workspace) || "";
+  }
+  if (args.allowCoordinatorSession) {
+    const coordinatorWorkspace = args.liveSessionRecords.find((record) => readStringValue(record?.meta?.meshCoordinatorFor) === args.meshId && readStringValue(record?.workspace));
+    if (coordinatorWorkspace) {
+      return readStringValue(coordinatorWorkspace.workspace) || "";
+    }
+  }
+  return "";
+}
+function collectLiveMeshSessionRecords(args) {
+  const matches = args.liveSessionRecords.filter((record) => {
+    if (readStringValue(record?.meta?.meshNodeId) === args.nodeId) return true;
+    const recordWorkspace = readStringValue(record?.workspace);
+    const nodeWorkspace = readStringValue(args.node?.workspace);
+    return !!recordWorkspace && !!nodeWorkspace && recordWorkspace === nodeWorkspace;
+  });
+  if (args.allowCoordinatorSession) {
+    for (const record of args.liveSessionRecords) {
+      if (readStringValue(record?.meta?.meshCoordinatorFor) !== args.meshId) continue;
+      const sessionId = readStringValue(record?.sessionId);
+      if (sessionId && matches.some((entry) => readStringValue(entry?.sessionId) === sessionId)) continue;
+      matches.push(record);
+    }
+  }
+  return matches;
+}
 function applyCachedInlineMeshNodeStatus(status, node) {
   const cachedStatus = readObjectRecord(node?.cachedStatus);
   const git = buildCachedInlineMeshGitStatus(node);
@@ -25817,7 +25847,14 @@ var DaemonCommandRouter = class {
               cliType
             };
           }
-          const workspace = typeof coordinatorNode.workspace === "string" ? coordinatorNode.workspace.trim() : "";
+          const sessionHostRecords = this.deps.sessionHostControl?.listSessions ? await this.deps.sessionHostControl.listSessions().catch(() => []) : [];
+          const liveMeshSessions = partitionSessionHostRecords(Array.isArray(sessionHostRecords) ? sessionHostRecords : []).liveRuntimes;
+          const workspace = readLiveMeshNodeWorkspace({
+            meshId,
+            nodeId: String(coordinatorNode.id || coordinatorNode.nodeId || preferredCoordinatorNodeId || ""),
+            liveSessionRecords: liveMeshSessions,
+            allowCoordinatorSession: true
+          }) || (typeof coordinatorNode.workspace === "string" ? coordinatorNode.workspace.trim() : "");
           if (!workspace) return { success: false, error: "Coordinator node workspace required", meshId, cliType };
           if (!cliType) {
             const resolved = await resolveProviderTypeFromPriority({
@@ -26128,7 +26165,12 @@ ${block}`);
           const sessionHostRecords = this.deps.sessionHostControl?.listSessions ? await this.deps.sessionHostControl.listSessions().catch(() => []) : [];
           const liveMeshSessions = partitionSessionHostRecords(Array.isArray(sessionHostRecords) ? sessionHostRecords : []).liveRuntimes;
           const localMachineId = loadConfig().machineId || "";
-          const inlineCoordinatorNodeId = meshRecord?.inline && Array.isArray(mesh.nodes) ? readStringValue(mesh.nodes[0]?.id, mesh.nodes[0]?.nodeId) : void 0;
+          const selectedCoordinatorNodeId = readStringValue(
+            mesh.coordinator?.preferredNodeId,
+            mesh.nodes?.[0]?.id,
+            mesh.nodes?.[0]?.nodeId
+          );
+          const inlineCoordinatorNodeId = meshRecord?.inline && Array.isArray(mesh.nodes) ? selectedCoordinatorNodeId : void 0;
           const refreshedAt = (/* @__PURE__ */ new Date()).toISOString();
           const nodeStatuses = [];
           for (const [nodeIndex, node] of (mesh.nodes || []).entries()) {
@@ -26187,7 +26229,20 @@ ${block}`);
                 reason: "Node has no daemon id, so mesh transport cannot be reported from the selected coordinator."
               };
             }
-            const matchedLiveSessionRecords = liveMeshSessions.filter((record) => this.sessionMatchesMeshNode(record, node, nodeId));
+            const matchedLiveSessionRecords = collectLiveMeshSessionRecords({
+              meshId,
+              node,
+              nodeId,
+              liveSessionRecords: liveMeshSessions,
+              allowCoordinatorSession: nodeId === selectedCoordinatorNodeId
+            });
+            const workspace = readLiveMeshNodeWorkspace({
+              meshId,
+              nodeId,
+              liveSessionRecords: matchedLiveSessionRecords,
+              allowCoordinatorSession: nodeId === selectedCoordinatorNodeId
+            }) || (typeof node.workspace === "string" ? node.workspace : "");
+            status.workspace = workspace || node.workspace;
             if (matchedLiveSessionRecords.length > 0) {
               const sessionIds = matchedLiveSessionRecords.map((record) => typeof record?.sessionId === "string" ? record.sessionId : "").filter(Boolean);
               const providerTypes = matchedLiveSessionRecords.map((record) => readStringValue(record?.providerType)).filter(Boolean);
@@ -26197,14 +26252,14 @@ ${block}`);
                 status.providers = Array.from(/* @__PURE__ */ new Set([...Array.isArray(status.providers) ? status.providers : [], ...providerTypes]));
               }
             }
-            if (node.workspace && typeof node.workspace === "string") {
-              if (!fs10.existsSync(node.workspace) && applyCachedInlineMeshNodeStatus(status, node)) {
+            if (workspace) {
+              if (!fs10.existsSync(workspace) && applyCachedInlineMeshNodeStatus(status, node)) {
                 status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || isSelfNode);
                 nodeStatuses.push(status);
                 continue;
               }
               try {
-                const gitStatus = await getGitRepoStatus(node.workspace, { timeoutMs: 1e4, refreshUpstream: true });
+                const gitStatus = await getGitRepoStatus(workspace, { timeoutMs: 1e4, refreshUpstream: true });
                 status.git = gitStatus;
                 if (gitStatus.isGitRepo) {
                   status.health = deriveMeshNodeHealthFromGit(gitStatus);