@adhdev/daemon-standalone 0.9.77-rc.25 → 0.9.77-rc.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-standalone",
-  "version": "0.9.77-rc.25",
+  "version": "0.9.77-rc.27",
   "description": "ADHDev standalone daemon — embedded HTTP/WS server for local dashboard",
   "main": "dist/index.js",
   "bin": {

package/vendor/mcp-server/index.js

@@ -57466,6 +57466,49 @@ function extractGitDiff(value) {
 function extractLaunchPayload(value) {
   return findNestedPayload(value, (payload) => Boolean(payload?.sessionId || payload?.id || payload?.runtimeSessionId));
 }
+async function ipcDispatchToRemoteAgent(ctx, node, args) {
+  const transport = ctx.transport;
+  const daemonId = node.daemonId;
+  let sessionId = args.session_id?.trim() || "";
+  const providerPriorityList = Array.isArray(node.policy?.providerPriority) ? node.policy.providerPriority : [];
+  let resolvedProviderType = args.providerType?.trim() || providerPriorityList[0] || "";
+  if (!sessionId) {
+    try {
+      const statusResult = await transport.meshCommand(daemonId, "get_status_metadata", {});
+      const payload = unwrapCommandPayload(statusResult);
+      const sessions = Array.isArray(payload?.sessions) ? payload.sessions : Array.isArray(payload?.status?.sessions) ? payload.status.sessions : [];
+      const meshSessions = sessions.filter(
+        (s) => s?.settings?.meshNodeFor === ctx.mesh.id || s?.settings?.meshNodeId === node.id || s?.settings?.launchedByCoordinator === true
+      );
+      const targetSession = meshSessions[0] || sessions.find(
+        (s) => !resolvedProviderType || s?.providerType === resolvedProviderType || s?.cliType === resolvedProviderType
+      ) || sessions[0];
+      if (targetSession?.id || targetSession?.sessionId) {
+        sessionId = targetSession.id || targetSession.sessionId;
+        if (!resolvedProviderType) {
+          resolvedProviderType = targetSession.providerType || targetSession.cliType || "";
+        }
+      }
+    } catch {
+    }
+  }
+  if (!resolvedProviderType) {
+    return { success: false, error: `Cannot dispatch to remote node '${node.id}': providerType unknown. Set providerPriority on the node policy or call mesh_launch_session first.` };
+  }
+  try {
+    await transport.meshCommand(daemonId, "agent_command", {
+      // Precise match when sessionId known, fuzzy type match otherwise
+      ...sessionId ? { targetSessionId: sessionId } : {},
+      agentType: resolvedProviderType,
+      cliType: resolvedProviderType,
+      action: "send_chat",
+      message: args.message
+    });
+    return { success: true, dispatched: true, sessionId: sessionId || resolvedProviderType };
+  } catch (e) {
+    return { success: false, error: `P2P dispatch failed: ${e?.message || String(e)}` };
+  }
+}
 function resolveCoordinatorNode(ctx) {
   const preferredNodeId = typeof ctx.mesh.coordinator?.preferredNodeId === "string" ? ctx.mesh.coordinator.preferredNodeId.trim() : "";
   if (preferredNodeId) {
@@ -57898,6 +57941,19 @@ async function meshEnqueueTask(ctx, args) {
     if (isLocalTransport(ctx.transport)) {
       ctx.transport.command("trigger_mesh_queue", { meshId: ctx.mesh.id }).catch(() => {
       });
+      if (ctx.transport instanceof IpcTransport) {
+        for (const node of ctx.mesh.nodes) {
+          const isLocalNode = ctx.localMachineId && node.machineId === ctx.localMachineId || ctx.localDaemonId && node.daemonId === ctx.localDaemonId;
+          if (!isLocalNode && node.daemonId) {
+            ctx.transport.meshCommand(
+              node.daemonId,
+              "trigger_mesh_queue",
+              { meshId: ctx.mesh.id }
+            ).catch(() => {
+            });
+          }
+        }
+      }
     }
     return JSON.stringify({ success: true, taskId: task.id, status: task.status });
   } catch (e) {
@@ -57926,12 +57982,29 @@ async function meshSendTask(ctx, args) {
       });
       return JSON.stringify(res);
     }
-    const task = enqueueTask(ctx.mesh.id, args.message, { targetNodeId: args.node_id });
     const isLocalNode = ctx.localMachineId && node.machineId === ctx.localMachineId || ctx.localDaemonId && node.daemonId === ctx.localDaemonId;
     if (ctx.transport instanceof IpcTransport && node.daemonId && !isLocalNode) {
-      ctx.transport.meshCommand(node.daemonId, "trigger_mesh_queue", { meshId: ctx.mesh.id }).catch(() => {
+      const cached2 = meshSessionProviderMetadata.get(meshSessionCacheKey(args.node_id, args.session_id || ""));
+      const result = await ipcDispatchToRemoteAgent(ctx, node, {
+        session_id: args.session_id,
+        message: args.message,
+        providerType: cached2?.providerType
       });
-    } else if (isLocalTransport(ctx.transport)) {
+      if (result.success) {
+        try {
+          appendLedgerEntry(ctx.mesh.id, {
+            kind: "task_dispatched",
+            nodeId: args.node_id,
+            sessionId: result.sessionId,
+            payload: { message: args.message, via: "p2p_direct" }
+          });
+        } catch {
+        }
+      }
+      return JSON.stringify({ ...result, nodeId: args.node_id });
+    }
+    const task = enqueueTask(ctx.mesh.id, args.message, { targetNodeId: args.node_id });
+    if (isLocalTransport(ctx.transport)) {
       ctx.transport.command("trigger_mesh_queue", { meshId: ctx.mesh.id }).catch(() => {
       });
     }