adhdev 0.9.82-rc.7 → 0.9.82-rc.8

package/dist/cli/index.js

@@ -46524,17 +46524,87 @@ function readCachedInlineMeshActiveSessions(node) {
   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);
+  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);
-  if (!git && !error48 && !health && !machineStatus && activeSessions.length === 0) return false;
+  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;
@@ -46543,7 +46613,7 @@ function applyCachedInlineMeshNodeStatus(status, node) {
     status.health = deriveMeshNodeHealthFromGit(git);
     return true;
   }
-  return activeSessions.length > 0 || !!machineStatus;
+  return activeSessions.length > 0 || !!machineStatus || !!lastSeenAt || !!updatedAt;
 }
 async function resolveProviderTypeFromPriority(args) {
   if (!args.providerPriority.length) {
@@ -48822,28 +48892,79 @@ ${block}`);
               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
                 };
-                const nodeId = String(node.id || node.nodeId || "");
-                const matchedLiveSessions = liveMeshSessions.filter((record2) => this.sessionMatchesMeshNode(record2, node, nodeId)).map((record2) => typeof record2?.sessionId === "string" ? record2.sessionId : "").filter(Boolean);
-                if (matchedLiveSessions.length > 0) {
-                  status.activeSessions = matchedLiveSessions;
+                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;
                   }
@@ -48864,6 +48985,7 @@ ${block}`);
                 } else {
                   applyCachedInlineMeshNodeStatus(status, node);
                 }
+                status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || isSelfNode);
                 nodeStatuses.push(status);
               }
               return {
@@ -48872,6 +48994,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 }
@@ -56950,6 +57073,7 @@ async function initDaemonComponents(config2) {
     sessionHostControl: config2.sessionHostControl,
     statusInstanceId: config2.statusInstanceId,
     statusVersion: config2.statusVersion,
+    getMeshPeerConnectionStatus: config2.getMeshPeerConnectionStatus,
     getCdpLogFn: config2.getCdpLogFn || ((ideType) => LOG.forComponent(`CDP:${ideType}`).asLogFn())
   });
   poller = new AgentStreamPoller({
@@ -97227,11 +97351,30 @@ var init_daemon_mesh_manager = __esm({
       nodeDatachannel = null;
       peers = /* @__PURE__ */ new Map();
       // Map<targetDaemonId, PeerEntry>
+      peerSnapshots = /* @__PURE__ */ new Map();
       pendingRequests = /* @__PURE__ */ new Map();
       commandCallback;
       p2pFailure(message, command, targetDaemonId) {
         return new P2pRelayFailureError(message, { command, targetDaemonId });
       }
+      updatePeerSnapshot(targetDaemonId, state, patch = {}) {
+        const previous = this.peerSnapshots.get(targetDaemonId);
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        this.peerSnapshots.set(targetDaemonId, {
+          perspective: "selected_coordinator",
+          source: "mesh_peer_status",
+          reported: true,
+          state,
+          transport: patch.transport ?? previous?.transport ?? "unknown",
+          reason: patch.reason ?? previous?.reason,
+          lastStateChangeAt: now,
+          lastConnectedAt: patch.lastConnectedAt ?? previous?.lastConnectedAt,
+          lastCommandAt: patch.lastCommandAt ?? previous?.lastCommandAt
+        });
+      }
+      getPeerConnectionStatus(targetDaemonId) {
+        return this.peerSnapshots.get(targetDaemonId) ?? null;
+      }
       invalidatePeer(targetDaemonId, reason, options = {}) {
         const peer = this.peers.get(targetDaemonId);
         if (peer?.commandQueue) {
@@ -97246,6 +97389,11 @@ var init_daemon_mesh_manager = __esm({
             pending.reject(this.p2pFailure(reason, pending.command, targetDaemonId));
           }
         }
+        const snapshotState = peer?.state === "closed" ? "closed" : peer?.state === "disconnected" ? "disconnected" : "failed";
+        this.updatePeerSnapshot(targetDaemonId, snapshotState, {
+          reason,
+          transport: peer?.isRelay === true ? "relay" : peer?.isRelay === false ? "direct" : "unknown"
+        });
         if (options.closeResources !== false && peer) {
           try {
             peer.dataChannel?.close?.();
@@ -97365,6 +97513,20 @@ var init_daemon_mesh_manager = __esm({
         if (!peer) {
           throw this.p2pFailure("Failed to initiate P2P connection entry", command, targetDaemonId);
         }
+        const lastCommandAt = (/* @__PURE__ */ new Date()).toISOString();
+        if (peer.state === "connected") {
+          this.updatePeerSnapshot(targetDaemonId, "connected", {
+            transport: peer.isRelay === true ? "relay" : peer.isRelay === false ? "direct" : "unknown",
+            lastConnectedAt: this.peerSnapshots.get(targetDaemonId)?.lastConnectedAt,
+            lastCommandAt
+          });
+        } else {
+          this.updatePeerSnapshot(targetDaemonId, "connecting", {
+            transport: peer.isRelay === true ? "relay" : peer.isRelay === false ? "direct" : "unknown",
+            reason: "Waiting for mesh DataChannel to open.",
+            lastCommandAt
+          });
+        }
         return new Promise((resolve23, reject) => {
           const requestId = `req_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
           const timer = setTimeout(() => {
@@ -97508,6 +97670,9 @@ var init_daemon_mesh_manager = __esm({
           remoteDescriptionSet: false
         };
         this.peers.set(targetDaemonId, entry);
+        this.updatePeerSnapshot(targetDaemonId, "connecting", {
+          reason: isInitiator ? "P2P mesh connection initiated by the selected coordinator." : "Waiting for the remote daemon to finish the mesh DataChannel handshake."
+        });
         pc.onLocalDescription((sdp, type2) => {
           this.serverConn.sendMeshCommand(targetDaemonId, type2 === "offer" ? "mesh_p2p_offer" : "mesh_p2p_answer", { sdp, type: type2 });
         });
@@ -97518,7 +97683,26 @@ var init_daemon_mesh_manager = __esm({
           LOG.info("Mesh", `[Mesh] P2P state with ${targetDaemonId.slice(0, 12)}: ${state}`);
           if (state === "connected") {
             entry.state = "connected";
+            let transport = "unknown";
+            try {
+              const pair = pc.getSelectedCandidatePair?.();
+              if (pair) {
+                const localType = pair.local?.type || "unknown";
+                const remoteType = pair.remote?.type || "unknown";
+                entry.isRelay = localType === "relay" || remoteType === "relay";
+                transport = entry.isRelay ? "relay" : "direct";
+                LOG.info("Mesh", `[Mesh] Candidate pair with ${targetDaemonId.slice(0, 12)}: local=${localType} remote=${remoteType} \u2192 ${transport}`);
+              }
+            } catch {
+              transport = entry.isRelay === true ? "relay" : entry.isRelay === false ? "direct" : "unknown";
+            }
+            this.updatePeerSnapshot(targetDaemonId, "connected", {
+              transport,
+              reason: transport === "relay" ? "Connected over TURN relay." : transport === "direct" ? "Connected directly peer-to-peer." : "Connected, but selected candidate pair details are unavailable.",
+              lastConnectedAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
           } else if (state === "failed" || state === "closed" || state === "disconnected") {
+            entry.state = state;
             this.invalidatePeer(targetDaemonId, `P2P state changed to ${state}`, { rejectPending: true, closeResources: false });
           }
         });
@@ -97536,6 +97720,11 @@ var init_daemon_mesh_manager = __esm({
         dc.onOpen(() => {
           LOG.info("Mesh", `[Mesh] DataChannel OPEN with ${targetDaemonId.slice(0, 12)}`);
           entry.state = "connected";
+          this.updatePeerSnapshot(targetDaemonId, "connected", {
+            transport: entry.isRelay === true ? "relay" : entry.isRelay === false ? "direct" : "unknown",
+            reason: entry.isRelay === true ? "Connected over TURN relay." : entry.isRelay === false ? "Connected directly peer-to-peer." : "DataChannel open; transport details not reported yet.",
+            lastConnectedAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
           if (entry.commandQueue) {
             const queue = entry.commandQueue;
             entry.commandQueue = [];
@@ -97831,7 +98020,7 @@ var init_adhdev_daemon = __esm({
     init_version();
     init_src();
     init_runtime_defaults();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.82-rc.7" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.82-rc.8" });
     AdhdevDaemon = class _AdhdevDaemon {
       localHttpServer = null;
       localWss = null;
@@ -98355,6 +98544,7 @@ ${err?.stack || ""}`);
               if (!this.meshManager) throw new Error("Mesh manager not initialized");
               return this.meshManager.sendCommand(daemonId, command, args);
             },
+            getMeshPeerConnectionStatus: (daemonId) => this.meshManager?.getPeerConnectionStatus(daemonId) ?? null,
             onStatusChange: () => {
               this.invalidateHotChatSnapshotCache();
               this.statusReporter?.onStatusChange();