adhdev 0.9.82-rc.32 → 0.9.82-rc.34

package/dist/cli/index.js

@@ -97986,6 +97986,13 @@ var init_daemon_mesh_manager = __esm({
       p2pFailure(message, command, targetDaemonId) {
         return new P2pRelayFailureError(message, { command, targetDaemonId });
       }
+      logMeshCommandEvent(event, fields) {
+        try {
+          LOG.info("Mesh", `[MeshCommand] ${JSON.stringify({ event, ...fields })}`);
+        } catch {
+          LOG.info("Mesh", `[MeshCommand] ${event}`);
+        }
+      }
       updatePeerSnapshot(targetDaemonId, state, patch = {}) {
         const previous = this.peerSnapshots.get(targetDaemonId);
         const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -98116,6 +98123,13 @@ var init_daemon_mesh_manager = __esm({
         const peer = this.peers.get(targetDaemonId);
         if (!peer || peer.state !== "connected" || !peer.dataChannel?.isOpen()) {
           LOG.warn("Mesh", `[Mesh] Cannot send result for ${requestId}, P2P not open with ${targetDaemonId.slice(0, 12)}`);
+          this.logMeshCommandEvent("response_send_failed", {
+            requestId,
+            targetDaemonId,
+            sentAt: (/* @__PURE__ */ new Date()).toISOString(),
+            peerState: peer?.state ?? "missing",
+            error: "P2P not open"
+          });
           return;
         }
         try {
@@ -98126,8 +98140,22 @@ var init_daemon_mesh_manager = __esm({
             result,
             error: error48
           }));
+          this.logMeshCommandEvent("response_sent", {
+            requestId,
+            targetDaemonId,
+            sentAt: (/* @__PURE__ */ new Date()).toISOString(),
+            peerState: peer.state,
+            success: !error48
+          });
         } catch (err) {
           LOG.warn("Mesh", `[Mesh] Failed to send command result: ${err.message}`);
+          this.logMeshCommandEvent("response_send_failed", {
+            requestId,
+            targetDaemonId,
+            sentAt: (/* @__PURE__ */ new Date()).toISOString(),
+            peerState: peer.state,
+            error: err?.message || "Failed to send command result"
+          });
         }
       }
       /** Convenience: send a one-off mesh command without a rule. */
@@ -98159,9 +98187,21 @@ var init_daemon_mesh_manager = __esm({
         }
         return new Promise((resolve23, reject) => {
           const requestId = `req_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+          const queuedAt = (/* @__PURE__ */ new Date()).toISOString();
           const timer = setTimeout(() => {
+            const pending = this.pendingRequests.get(requestId);
             this.pendingRequests.delete(requestId);
+            const timedOutAt = (/* @__PURE__ */ new Date()).toISOString();
             const message = `P2P DataChannel command '${command}' to ${targetDaemonId.slice(0, 12)} timed out after 30s`;
+            this.logMeshCommandEvent("timeout", {
+              requestId,
+              command,
+              targetDaemonId,
+              queuedAt: pending?.queuedAt ?? queuedAt,
+              sentAt: pending?.sentAt,
+              timedOutAt,
+              peerState: peer?.state
+            });
             this.invalidatePeer(targetDaemonId, message, { rejectPending: true, excludeRequestId: requestId });
             reject(this.p2pFailure(message, command, targetDaemonId));
           }, 3e4);
@@ -98178,7 +98218,8 @@ var init_daemon_mesh_manager = __esm({
             },
             timer,
             targetDaemonId,
-            command
+            command,
+            queuedAt
           });
           const payload = {
             type: "mesh_command",
@@ -98187,18 +98228,47 @@ var init_daemon_mesh_manager = __esm({
             args
           };
           if (peer.state === "connected" && peer.dataChannel?.isOpen()) {
+            const sentAt = (/* @__PURE__ */ new Date()).toISOString();
+            const pending = this.pendingRequests.get(requestId);
+            if (pending) pending.sentAt = sentAt;
             LOG.info("Mesh", `[Mesh] Sending '${command}' via P2P DataChannel to ${targetDaemonId.slice(0, 12)}`);
+            this.logMeshCommandEvent("sent", {
+              requestId,
+              command,
+              targetDaemonId,
+              queuedAt,
+              sentAt,
+              peerState: peer.state,
+              transport: peer.isRelay === true ? "relay" : peer.isRelay === false ? "direct" : "unknown"
+            });
             try {
               peer.dataChannel.sendMessage(JSON.stringify(payload));
             } catch (err) {
               const req = this.pendingRequests.get(requestId);
               const message = err?.message || "P2P DataChannel send failed";
+              this.logMeshCommandEvent("send_failed", {
+                requestId,
+                command,
+                targetDaemonId,
+                queuedAt,
+                sentAt,
+                failedAt: (/* @__PURE__ */ new Date()).toISOString(),
+                error: message
+              });
               this.invalidatePeer(targetDaemonId, message, { rejectPending: true, excludeRequestId: requestId });
               if (req) req.reject(this.p2pFailure(message, command, targetDaemonId));
             }
             return;
           }
           LOG.info("Mesh", `[Mesh] Queuing '${command}' for ${targetDaemonId.slice(0, 12)} (state: ${peer.state})`);
+          this.logMeshCommandEvent("queued", {
+            requestId,
+            command,
+            targetDaemonId,
+            queuedAt,
+            peerState: peer.state,
+            transport: peer.isRelay === true ? "relay" : peer.isRelay === false ? "direct" : "unknown"
+          });
           if (!peer.commandQueue) {
             peer.commandQueue = [];
           }
@@ -98206,6 +98276,7 @@ var init_daemon_mesh_manager = __esm({
             command,
             args,
             requestId,
+            queuedAt,
             reject: (err) => {
               const req = this.pendingRequests.get(requestId);
               if (req) req.reject(err);
@@ -98360,7 +98431,20 @@ var init_daemon_mesh_manager = __esm({
             entry.commandQueue = [];
             for (const item of queue) {
               try {
+                const sentAt = (/* @__PURE__ */ new Date()).toISOString();
+                const pending = this.pendingRequests.get(item.requestId);
+                if (pending) pending.sentAt = sentAt;
                 LOG.info("Mesh", `[Mesh] Flushing queued '${item.command}' to ${targetDaemonId.slice(0, 12)}`);
+                this.logMeshCommandEvent("sent", {
+                  requestId: item.requestId,
+                  command: item.command,
+                  targetDaemonId,
+                  queuedAt: item.queuedAt,
+                  sentAt,
+                  peerState: entry.state,
+                  transport: entry.isRelay === true ? "relay" : entry.isRelay === false ? "direct" : "unknown",
+                  flushed: true
+                });
                 dc.sendMessage(JSON.stringify({
                   type: "mesh_command",
                   requestId: item.requestId,
@@ -98368,6 +98452,14 @@ var init_daemon_mesh_manager = __esm({
                   args: item.args
                 }));
               } catch (err) {
+                this.logMeshCommandEvent("send_failed", {
+                  requestId: item.requestId,
+                  command: item.command,
+                  targetDaemonId,
+                  queuedAt: item.queuedAt,
+                  failedAt: (/* @__PURE__ */ new Date()).toISOString(),
+                  error: err?.message || "P2P DataChannel send failed while flushing command queue"
+                });
                 item.reject(this.p2pFailure(err?.message || "P2P DataChannel send failed while flushing command queue", item.command, targetDaemonId));
               }
             }
@@ -98382,6 +98474,12 @@ var init_daemon_mesh_manager = __esm({
             const str2 = typeof msg === "string" ? msg : msg.toString("utf8");
             const data = JSON.parse(str2);
             if (data.type === "mesh_command" && data.command) {
+              this.logMeshCommandEvent("incoming", {
+                requestId: data.requestId,
+                command: data.command,
+                senderDaemonId: targetDaemonId,
+                receivedAt: (/* @__PURE__ */ new Date()).toISOString()
+              });
               if (this.commandCallback) {
                 this.commandCallback(targetDaemonId, data.command, data.args, data.requestId).catch((e) => {
                   LOG.warn("Mesh", `[Mesh] Error handling incoming P2P command: ${e.message}`);
@@ -98390,11 +98488,27 @@ var init_daemon_mesh_manager = __esm({
             } else if (data.type === "mesh_command_result" && data.requestId) {
               const pending = this.pendingRequests.get(data.requestId);
               if (pending) {
+                this.logMeshCommandEvent("response_received", {
+                  requestId: data.requestId,
+                  command: pending.command,
+                  targetDaemonId: pending.targetDaemonId,
+                  queuedAt: pending.queuedAt,
+                  sentAt: pending.sentAt,
+                  receivedAt: (/* @__PURE__ */ new Date()).toISOString(),
+                  success: data.success === true
+                });
                 if (data.success) {
                   pending.resolve(data.result);
                 } else {
                   pending.reject(new Error(data.error || "P2P Command failed"));
                 }
+              } else {
+                this.logMeshCommandEvent("response_orphan", {
+                  requestId: data.requestId,
+                  targetDaemonId,
+                  receivedAt: (/* @__PURE__ */ new Date()).toISOString(),
+                  success: data.success === true
+                });
               }
             }
           } catch (e) {
@@ -98651,7 +98765,7 @@ var init_adhdev_daemon = __esm({
     init_version();
     init_src();
     init_runtime_defaults();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.82-rc.32" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.82-rc.34" });
     AdhdevDaemon = class _AdhdevDaemon {
       localHttpServer = null;
       localWss = null;