@adhdev/daemon-standalone 0.9.82-rc.21 → 0.9.82-rc.23

package/dist/index.js

@@ -45981,6 +45981,96 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         ...submodules ? { submodules } : {}
       };
     }
+    function shouldDiscardCachedInlineMeshStatus(node) {
+      const cachedStatus = readObjectRecord(node?.cachedStatus);
+      if (!Object.keys(cachedStatus).length) return false;
+      const cachedGit = readObjectRecord(cachedStatus.git);
+      const workspaceError = readStringValue(cachedStatus.error, node?.error);
+      if (workspaceError && /workspace must be an existing directory/i.test(workspaceError)) return true;
+      const isGitRepo = readBooleanValue(cachedGit.isGitRepo);
+      const branch = readStringValue(cachedGit.branch);
+      const headCommit = readStringValue(cachedGit.headCommit);
+      return isGitRepo === false && !branch && !headCommit;
+    }
+    function stripInlineMeshTransientNodeState(node) {
+      if (!node || typeof node !== "object" || Array.isArray(node)) return node;
+      const {
+        cachedStatus,
+        lastGit: _lastGit,
+        last_git: _lastGitLegacy,
+        lastProbe: _lastProbe,
+        last_probe: _lastProbeLegacy,
+        error: _error,
+        health: _health,
+        machineStatus: _machineStatus,
+        lastSeenAt: _lastSeenAt,
+        last_seen_at: _lastSeenAtLegacy,
+        updatedAt: _updatedAt,
+        updated_at: _updatedAtLegacy,
+        activeSession: _activeSession,
+        active_session: _activeSessionLegacy,
+        activeSessionId: _activeSessionId,
+        active_session_id: _activeSessionIdLegacy,
+        sessionId: _sessionId,
+        session_id: _sessionIdLegacy,
+        providerType: _providerType,
+        provider_type: _providerTypeLegacy,
+        providers: _providers,
+        ...rest
+      } = node;
+      if (cachedStatus && !shouldDiscardCachedInlineMeshStatus(node)) {
+        return { ...rest, cachedStatus };
+      }
+      return rest;
+    }
+    function hasInlineMeshTransientNodeState(node) {
+      if (!node || typeof node !== "object" || Array.isArray(node)) return false;
+      return "cachedStatus" in node || "lastGit" in node || "last_git" in node || "lastProbe" in node || "last_probe" in node || "error" in node || "health" in node || "machineStatus" in node || "lastSeenAt" in node || "last_seen_at" in node || "updatedAt" in node || "updated_at" in node || "activeSession" in node || "active_session" in node || "activeSessionId" in node || "active_session_id" in node || "sessionId" in node || "session_id" in node || "providerType" in node || "provider_type" in node || "providers" in node;
+    }
+    function readInlineMeshNodeId(node) {
+      return readStringValue(node?.id, node?.nodeId) || "";
+    }
+    function sanitizeInlineMesh(inlineMesh) {
+      if (!inlineMesh || typeof inlineMesh !== "object" || Array.isArray(inlineMesh)) return inlineMesh;
+      if (!Array.isArray(inlineMesh.nodes)) return inlineMesh;
+      let changed = false;
+      const nodes = inlineMesh.nodes.map((node) => {
+        if (!hasInlineMeshTransientNodeState(node)) return node;
+        changed = true;
+        return stripInlineMeshTransientNodeState(node);
+      });
+      if (!changed) return inlineMesh;
+      return {
+        ...inlineMesh,
+        nodes
+      };
+    }
+    function reconcileInlineMeshCache(cached2, incoming) {
+      if (!cached2 || typeof cached2 !== "object" || Array.isArray(cached2)) return incoming;
+      if (!incoming || typeof incoming !== "object" || Array.isArray(incoming)) return cached2;
+      const cachedNodes = Array.isArray(cached2.nodes) ? cached2.nodes : [];
+      const incomingNodes = Array.isArray(incoming.nodes) ? incoming.nodes : [];
+      if (!cachedNodes.length || !incomingNodes.length) return { ...cached2, ...incoming };
+      const incomingById = /* @__PURE__ */ new Map();
+      for (const node of incomingNodes) {
+        const nodeId = readInlineMeshNodeId(node);
+        if (nodeId) incomingById.set(nodeId, node);
+      }
+      const nodes = cachedNodes.map((cachedNode) => {
+        const nodeId = readInlineMeshNodeId(cachedNode);
+        const incomingNode = nodeId ? incomingById.get(nodeId) : void 0;
+        if (!incomingNode) return cachedNode;
+        if (hasInlineMeshTransientNodeState(incomingNode)) {
+          return { ...cachedNode, ...incomingNode };
+        }
+        return { ...stripInlineMeshTransientNodeState(cachedNode), ...incomingNode };
+      });
+      return {
+        ...cached2,
+        ...incoming,
+        nodes
+      };
+    }
     function hasGitWorktreeChanges(git) {
       if (!git) return false;
       return Number(git.staged || 0) + Number(git.modified || 0) + Number(git.untracked || 0) + Number(git.deleted || 0) + Number(git.renamed || 0) > 0;
@@ -46075,8 +46165,21 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         isCached: false
       };
     }
+    function liveSessionRecordMatchesMeshNode(record2, meshId, nodeId) {
+      const recordNodeId = readStringValue(record2?.meta?.meshNodeId);
+      if (!recordNodeId || recordNodeId !== nodeId) return false;
+      const recordMeshId = readStringValue(record2?.meta?.meshNodeFor);
+      return !recordMeshId || recordMeshId === meshId;
+    }
+    function liveSessionRecordMatchesMeshWorkspace(record2, meshId, workspace) {
+      const recordWorkspace = readStringValue(record2?.workspace);
+      if (!recordWorkspace || !workspace || recordWorkspace !== workspace) return false;
+      const recordMeshId = readStringValue(record2?.meta?.meshNodeFor);
+      if (recordMeshId) return recordMeshId === meshId;
+      return record2?.meta?.launchedByCoordinator === true || !!readStringValue(record2?.meta?.meshNodeId);
+    }
     function readLiveMeshNodeWorkspace(args) {
-      const directNodeWorkspace = args.liveSessionRecords.find((record2) => readStringValue(record2?.meta?.meshNodeId) === args.nodeId && readStringValue(record2?.workspace));
+      const directNodeWorkspace = args.liveSessionRecords.find((record2) => liveSessionRecordMatchesMeshNode(record2, args.meshId, args.nodeId) && readStringValue(record2?.workspace));
       if (directNodeWorkspace) {
         return readStringValue(directNodeWorkspace.workspace) || "";
       }
@@ -46090,10 +46193,9 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
     }
     function collectLiveMeshSessionRecords(args) {
       const matches = args.liveSessionRecords.filter((record2) => {
-        if (readStringValue(record2?.meta?.meshNodeId) === args.nodeId) return true;
-        const recordWorkspace = readStringValue(record2?.workspace);
         const nodeWorkspace = readStringValue(args.node?.workspace);
-        return !!recordWorkspace && !!nodeWorkspace && recordWorkspace === nodeWorkspace;
+        if (liveSessionRecordMatchesMeshNode(record2, args.meshId, args.nodeId)) return true;
+        return !!nodeWorkspace && liveSessionRecordMatchesMeshWorkspace(record2, args.meshId, nodeWorkspace);
       });
       if (args.allowCoordinatorSession) {
         for (const record2 of args.liveSessionRecords) {
@@ -46535,10 +46637,15 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       }
       warmInlineMeshCache(meshId, inlineMesh) {
         if (!inlineMesh || typeof inlineMesh !== "object") return void 0;
+        const sanitizedInlineMesh = sanitizeInlineMesh(inlineMesh);
         const cached2 = this.inlineMeshCache.get(meshId);
-        if (cached2) return cached2;
-        this.inlineMeshCache.set(meshId, inlineMesh);
-        return inlineMesh;
+        if (cached2) {
+          const merged = reconcileInlineMeshCache(cached2, sanitizedInlineMesh);
+          this.inlineMeshCache.set(meshId, merged);
+          return merged;
+        }
+        this.inlineMeshCache.set(meshId, sanitizedInlineMesh);
+        return sanitizedInlineMesh;
       }
       async getMeshForCommand(meshId, inlineMesh, options) {
         const preferInline = options?.preferInline === true;
@@ -48481,10 +48588,17 @@ ${block}`);
                   }
                 }
                 if (workspace) {
-                  if (!fs10.existsSync(workspace) && applyCachedInlineMeshNodeStatus(status, node)) {
-                    status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || isSelfNode);
-                    nodeStatuses.push(status);
-                    continue;
+                  if (!fs10.existsSync(workspace)) {
+                    if (applyCachedInlineMeshNodeStatus(status, node)) {
+                      status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || isSelfNode);
+                      nodeStatuses.push(status);
+                      continue;
+                    }
+                    if (meshRecord?.source === "inline_cache" && !isSelfNode) {
+                      status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || isSelfNode);
+                      nodeStatuses.push(status);
+                      continue;
+                    }
                   }
                   try {
                     const gitStatus = await getGitRepoStatus(workspace, { timeoutMs: 1e4, refreshUpstream: true });