@adhdev/daemon-core 0.9.82-rc.6 → 0.9.82-rc.8

package/dist/index.mjs

@@ -23694,26 +23694,127 @@ function buildCachedInlineMeshGitStatus(node) {
     ...submodules ? { submodules } : {}
   };
 }
+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;
+}
+function getGitSubmoduleDriftState(git) {
+  const submodules = Array.isArray(git?.submodules) ? git.submodules : [];
+  let dirty = false;
+  let outOfSync = false;
+  for (const entry of submodules) {
+    const submodule = readObjectRecord(entry);
+    if (readBooleanValue(submodule.dirty) === true) dirty = true;
+    if (readBooleanValue(submodule.outOfSync) === true || !!readStringValue(submodule.error)) outOfSync = true;
+  }
+  return { dirty, outOfSync };
+}
+function deriveMeshNodeHealthFromGit(git) {
+  if (!git || readBooleanValue(git.isGitRepo) === false) return "degraded";
+  const branch = readStringValue(git.branch);
+  if (!branch) return "degraded";
+  const submoduleDrift = getGitSubmoduleDriftState(git);
+  if (submoduleDrift.outOfSync) return "degraded";
+  if (submoduleDrift.dirty || hasGitWorktreeChanges(git)) return "dirty";
+  return "online";
+}
+function readCachedInlineMeshActiveSessions(node) {
+  const cachedStatus = readObjectRecord(node?.cachedStatus);
+  const activeSession = readObjectRecord(cachedStatus.activeSession);
+  const fallbackSession = Object.keys(activeSession).length ? activeSession : readObjectRecord(node?.activeSession ?? node?.active_session);
+  const sessionId = readStringValue(fallbackSession.id, fallbackSession.sessionId, fallbackSession.session_id, node?.activeSessionId, node?.active_session_id, node?.sessionId, node?.session_id);
+  return sessionId ? [sessionId] : [];
+}
+function readCachedInlineMeshActiveSessionDetails(node) {
+  const cachedStatus = readObjectRecord(node?.cachedStatus);
+  const activeSession = readObjectRecord(cachedStatus.activeSession);
+  const fallbackSession = Object.keys(activeSession).length ? activeSession : readObjectRecord(node?.activeSession ?? node?.active_session);
+  const sessionId = readStringValue(
+    fallbackSession.id,
+    fallbackSession.sessionId,
+    fallbackSession.session_id,
+    node?.activeSessionId,
+    node?.active_session_id,
+    node?.sessionId,
+    node?.session_id
+  );
+  if (!sessionId) return [];
+  return [{
+    sessionId,
+    providerType: readStringValue(
+      fallbackSession.providerType,
+      fallbackSession.provider_type,
+      fallbackSession.cliType,
+      fallbackSession.cli_type,
+      fallbackSession.provider,
+      node?.providerType,
+      node?.provider_type
+    ),
+    state: readStringValue(fallbackSession.status, fallbackSession.state, fallbackSession.lifecycle),
+    lifecycle: readStringValue(fallbackSession.lifecycle),
+    title: readStringValue(fallbackSession.title, fallbackSession.displayName, fallbackSession.display_name) ?? null,
+    workspace: readStringValue(fallbackSession.workspace, node?.workspace) ?? null,
+    lastActivityAt: readStringValue(fallbackSession.lastActivityAt, fallbackSession.last_activity_at) ?? null,
+    recoveryState: readStringValue(fallbackSession.recoveryState, fallbackSession.recovery_state) ?? null,
+    isCached: true
+  }];
+}
+function readLiveMeshSessionState(record) {
+  return readStringValue(
+    record?.meta?.sessionStatus,
+    record?.meta?.status,
+    record?.meta?.providerStatus,
+    record?.status,
+    record?.state,
+    record?.lifecycle
+  );
+}
+function toIsoTimestamp(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return new Date(value).toISOString();
+  const stringValue = readStringValue(value);
+  return stringValue || null;
+}
+function summarizeMeshSessionRecord(record) {
+  return {
+    sessionId: readStringValue(record?.sessionId) || "unknown",
+    providerType: readStringValue(record?.providerType),
+    state: readLiveMeshSessionState(record),
+    lifecycle: readStringValue(record?.lifecycle),
+    surfaceKind: getSessionHostSurfaceKind(record),
+    recoveryState: readStringValue(record?.meta?.runtimeRecoveryState) ?? null,
+    workspace: readStringValue(record?.workspace) ?? null,
+    title: readStringValue(record?.displayName, record?.workspaceLabel) ?? null,
+    lastActivityAt: toIsoTimestamp(record?.updatedAt ?? record?.lastActivityAt ?? record?.last_activity_at),
+    isCached: false
+  };
+}
 function applyCachedInlineMeshNodeStatus(status, node) {
   const cachedStatus = readObjectRecord(node?.cachedStatus);
   const git = buildCachedInlineMeshGitStatus(node);
   const error = readStringValue(cachedStatus.error, node?.error);
   const health = readStringValue(cachedStatus.health, node?.health);
   const machineStatus = readStringValue(cachedStatus.machineStatus, node?.machineStatus);
-  if (!git && !error && !health) return false;
-  if (!machineStatus && !git && !error) return false;
+  const lastSeenAt = toIsoTimestamp(cachedStatus.lastSeenAt ?? cachedStatus.last_seen_at ?? node?.lastSeenAt ?? node?.last_seen_at);
+  const updatedAt = toIsoTimestamp(cachedStatus.updatedAt ?? cachedStatus.updated_at ?? node?.updatedAt ?? node?.updated_at);
+  const activeSessions = readCachedInlineMeshActiveSessions(node);
+  const activeSessionDetails = readCachedInlineMeshActiveSessionDetails(node);
+  if (!git && !error && !health && !machineStatus && !lastSeenAt && !updatedAt && activeSessions.length === 0) return false;
   if (git) status.git = git;
   if (error) status.error = error;
+  if (machineStatus) status.machineStatus = machineStatus;
+  if (lastSeenAt) status.lastSeenAt = lastSeenAt;
+  if (updatedAt) status.updatedAt = updatedAt;
+  if (activeSessions.length > 0) status.activeSessions = activeSessions;
+  if (activeSessionDetails.length > 0) status.activeSessionDetails = activeSessionDetails;
   if (health) {
     status.health = health;
     return true;
   }
   if (git) {
-    const dirty = Number(git.staged || 0) + Number(git.modified || 0) + Number(git.untracked || 0) + Number(git.deleted || 0) + Number(git.renamed || 0) > 0;
-    status.health = git.isGitRepo === false ? "degraded" : dirty ? "dirty" : "online";
+    status.health = deriveMeshNodeHealthFromGit(git);
     return true;
   }
-  return false;
+  return activeSessions.length > 0 || !!machineStatus || !!lastSeenAt || !!updatedAt;
 }
 async function resolveProviderTypeFromPriority(args) {
   if (!args.providerPriority.length) {
@@ -25953,23 +26054,81 @@ ${block}`);
           const { readLedgerEntries: readLedgerEntries2, getLedgerSummary: getLedgerSummary2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
           const ledgerEntries = readLedgerEntries2(meshId, { tail: 20 });
           const ledgerSummary = getLedgerSummary2(meshId);
+          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 refreshedAt = (/* @__PURE__ */ new Date()).toISOString();
           const nodeStatuses = [];
-          for (const node of mesh.nodes || []) {
+          for (const [nodeIndex, node] of (mesh.nodes || []).entries()) {
+            const nodeId = String(node.id || node.nodeId || "");
+            const daemonId = readStringValue(node.daemonId);
+            const providerPriority = readProviderPriorityFromPolicy(node.policy);
+            const isSelfNode = Boolean(
+              nodeId && inlineCoordinatorNodeId && nodeId === inlineCoordinatorNodeId
+            ) || Boolean(
+              daemonId && (daemonId === localMachineId || daemonId === this.deps.statusInstanceId)
+            ) || Boolean(meshRecord?.inline && nodeIndex === 0);
             const status = {
-              nodeId: node.id || node.nodeId,
+              nodeId,
               machineLabel: node.machineLabel || node.id || node.nodeId,
               workspace: node.workspace,
               repoRoot: node.repoRoot,
               isLocalWorktree: node.isLocalWorktree,
               worktreeBranch: node.worktreeBranch,
-              daemonId: node.daemonId,
+              daemonId,
               machineId: node.machineId,
+              machineStatus: node.machineStatus,
               health: "unknown",
               providers: node.providers || [],
-              activeSessions: []
+              providerPriority,
+              activeSessions: [],
+              activeSessionDetails: [],
+              launchReady: false
             };
+            if (isSelfNode) {
+              status.connection = {
+                perspective: "selected_coordinator",
+                source: "mesh_peer_status",
+                state: "self",
+                transport: "local",
+                reported: true,
+                reason: "Selected coordinator daemon",
+                lastStateChangeAt: refreshedAt
+              };
+            } else if (daemonId) {
+              const connection = this.deps.getMeshPeerConnectionStatus?.(daemonId);
+              status.connection = connection ?? {
+                perspective: "selected_coordinator",
+                source: "not_reported",
+                state: "unknown",
+                transport: "unknown",
+                reported: false,
+                reason: "No live mesh peer telemetry reported by the selected coordinator yet."
+              };
+            } else {
+              status.connection = {
+                perspective: "selected_coordinator",
+                source: "not_reported",
+                state: "unknown",
+                transport: "unknown",
+                reported: false,
+                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));
+            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);
+              status.activeSessions = sessionIds;
+              status.activeSessionDetails = matchedLiveSessionRecords.map(summarizeMeshSessionRecord);
+              if (providerTypes.length > 0) {
+                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)) {
+                status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || isSelfNode);
                 nodeStatuses.push(status);
                 continue;
               }
@@ -25977,8 +26136,7 @@ ${block}`);
                 const gitStatus = await getGitRepoStatus(node.workspace, { timeoutMs: 1e4 });
                 status.git = gitStatus;
                 if (gitStatus.isGitRepo) {
-                  const dirty = gitStatus.staged + gitStatus.modified + gitStatus.untracked + gitStatus.deleted + gitStatus.renamed > 0;
-                  status.health = gitStatus.branch ? dirty ? "dirty" : "online" : "degraded";
+                  status.health = deriveMeshNodeHealthFromGit(gitStatus);
                 } else {
                   status.health = "degraded";
                   if (gitStatus.error && !status.error) status.error = gitStatus.error;
@@ -25991,6 +26149,7 @@ ${block}`);
             } else {
               applyCachedInlineMeshNodeStatus(status, node);
             }
+            status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || isSelfNode);
             nodeStatuses.push(status);
           }
           return {
@@ -25999,6 +26158,7 @@ ${block}`);
             meshName: mesh.name,
             repoIdentity: mesh.repoIdentity,
             defaultBranch: mesh.defaultBranch,
+            refreshedAt: (/* @__PURE__ */ new Date()).toISOString(),
             nodes: nodeStatuses,
             queue: { tasks: queue, summary: queueSummary },
             ledger: { entries: ledgerEntries, summary: ledgerSummary }
@@ -33933,6 +34093,7 @@ async function initDaemonComponents(config) {
     sessionHostControl: config.sessionHostControl,
     statusInstanceId: config.statusInstanceId,
     statusVersion: config.statusVersion,
+    getMeshPeerConnectionStatus: config.getMeshPeerConnectionStatus,
     getCdpLogFn: config.getCdpLogFn || ((ideType) => LOG.forComponent(`CDP:${ideType}`).asLogFn())
   });
   poller = new AgentStreamPoller({