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

package/dist/index.js

@@ -45903,26 +45903,127 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         ...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(record2) {
+      return readStringValue(
+        record2?.meta?.sessionStatus,
+        record2?.meta?.status,
+        record2?.meta?.providerStatus,
+        record2?.status,
+        record2?.state,
+        record2?.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(record2) {
+      return {
+        sessionId: readStringValue(record2?.sessionId) || "unknown",
+        providerType: readStringValue(record2?.providerType),
+        state: readLiveMeshSessionState(record2),
+        lifecycle: readStringValue(record2?.lifecycle),
+        surfaceKind: getSessionHostSurfaceKind(record2),
+        recoveryState: readStringValue(record2?.meta?.runtimeRecoveryState) ?? null,
+        workspace: readStringValue(record2?.workspace) ?? null,
+        title: readStringValue(record2?.displayName, record2?.workspaceLabel) ?? null,
+        lastActivityAt: toIsoTimestamp(record2?.updatedAt ?? record2?.lastActivityAt ?? record2?.last_activity_at),
+        isCached: false
+      };
+    }
     function applyCachedInlineMeshNodeStatus(status, node) {
       const cachedStatus = readObjectRecord(node?.cachedStatus);
       const git = buildCachedInlineMeshGitStatus(node);
       const error48 = readStringValue(cachedStatus.error, node?.error);
       const health = readStringValue(cachedStatus.health, node?.health);
       const machineStatus = readStringValue(cachedStatus.machineStatus, node?.machineStatus);
-      if (!git && !error48 && !health) return false;
-      if (!machineStatus && !git && !error48) 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 && !error48 && !health && !machineStatus && !lastSeenAt && !updatedAt && activeSessions.length === 0) return false;
       if (git) status.git = git;
       if (error48) status.error = error48;
+      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) {
@@ -48162,23 +48263,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 = loadConfig2().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((record2) => this.sessionMatchesMeshNode(record2, node, nodeId));
+                if (matchedLiveSessionRecords.length > 0) {
+                  const sessionIds = matchedLiveSessionRecords.map((record2) => typeof record2?.sessionId === "string" ? record2.sessionId : "").filter(Boolean);
+                  const providerTypes = matchedLiveSessionRecords.map((record2) => readStringValue(record2?.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;
                   }
@@ -48186,8 +48345,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;
@@ -48200,6 +48358,7 @@ ${block}`);
                 } else {
                   applyCachedInlineMeshNodeStatus(status, node);
                 }
+                status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || isSelfNode);
                 nodeStatuses.push(status);
               }
               return {
@@ -48208,6 +48367,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 }
@@ -56083,6 +56243,7 @@ data: ${JSON.stringify(msg.data)}
         sessionHostControl: config2.sessionHostControl,
         statusInstanceId: config2.statusInstanceId,
         statusVersion: config2.statusVersion,
+        getMeshPeerConnectionStatus: config2.getMeshPeerConnectionStatus,
         getCdpLogFn: config2.getCdpLogFn || ((ideType) => LOG2.forComponent(`CDP:${ideType}`).asLogFn())
       });
       poller = new AgentStreamPoller({