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

package/dist/index.mjs

@@ -23771,6 +23771,96 @@ function buildCachedInlineMeshGitStatus(node) {
     ...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(cached, incoming) {
+  if (!cached || typeof cached !== "object" || Array.isArray(cached)) return incoming;
+  if (!incoming || typeof incoming !== "object" || Array.isArray(incoming)) return cached;
+  const cachedNodes = Array.isArray(cached.nodes) ? cached.nodes : [];
+  const incomingNodes = Array.isArray(incoming.nodes) ? incoming.nodes : [];
+  if (!cachedNodes.length || !incomingNodes.length) return { ...cached, ...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 {
+    ...cached,
+    ...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;
@@ -23865,8 +23955,21 @@ function summarizeMeshSessionRecord(record) {
     isCached: false
   };
 }
+function liveSessionRecordMatchesMeshNode(record, meshId, nodeId) {
+  const recordNodeId = readStringValue(record?.meta?.meshNodeId);
+  if (!recordNodeId || recordNodeId !== nodeId) return false;
+  const recordMeshId = readStringValue(record?.meta?.meshNodeFor);
+  return !recordMeshId || recordMeshId === meshId;
+}
+function liveSessionRecordMatchesMeshWorkspace(record, meshId, workspace) {
+  const recordWorkspace = readStringValue(record?.workspace);
+  if (!recordWorkspace || !workspace || recordWorkspace !== workspace) return false;
+  const recordMeshId = readStringValue(record?.meta?.meshNodeFor);
+  if (recordMeshId) return recordMeshId === meshId;
+  return record?.meta?.launchedByCoordinator === true || !!readStringValue(record?.meta?.meshNodeId);
+}
 function readLiveMeshNodeWorkspace(args) {
-  const directNodeWorkspace = args.liveSessionRecords.find((record) => readStringValue(record?.meta?.meshNodeId) === args.nodeId && readStringValue(record?.workspace));
+  const directNodeWorkspace = args.liveSessionRecords.find((record) => liveSessionRecordMatchesMeshNode(record, args.meshId, args.nodeId) && readStringValue(record?.workspace));
   if (directNodeWorkspace) {
     return readStringValue(directNodeWorkspace.workspace) || "";
   }
@@ -23880,10 +23983,9 @@ function readLiveMeshNodeWorkspace(args) {
 }
 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 (liveSessionRecordMatchesMeshNode(record, args.meshId, args.nodeId)) return true;
+    return !!nodeWorkspace && liveSessionRecordMatchesMeshWorkspace(record, args.meshId, nodeWorkspace);
   });
   if (args.allowCoordinatorSession) {
     for (const record of args.liveSessionRecords) {
@@ -24325,10 +24427,15 @@ var DaemonCommandRouter = class {
   }
   warmInlineMeshCache(meshId, inlineMesh) {
     if (!inlineMesh || typeof inlineMesh !== "object") return void 0;
+    const sanitizedInlineMesh = sanitizeInlineMesh(inlineMesh);
     const cached = this.inlineMeshCache.get(meshId);
-    if (cached) return cached;
-    this.inlineMeshCache.set(meshId, inlineMesh);
-    return inlineMesh;
+    if (cached) {
+      const merged = reconcileInlineMeshCache(cached, 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;
@@ -26271,10 +26378,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 });