@adhdev/daemon-standalone 0.9.77-rc.24 → 0.9.77-rc.26

package/package.json

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

package/vendor/mcp-server/index.js

@@ -26256,13 +26256,18 @@ function formatCompletionMetadata(event) {
   ].filter(Boolean);
   return parts.length > 0 ? ` (${parts.join("; ")})` : "";
 }
+function getMeshWithCache(components, meshId) {
+  const localMesh = getMesh(meshId);
+  if (localMesh) return localMesh;
+  return components.router?.getCachedInlineMesh(meshId);
+}
 function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType) {
   const task = claimNextTask(meshId, nodeId, sessionId);
   if (!task) {
     return false;
   }
   LOG.info("MeshQueue", `Node ${nodeId} (${sessionId}) pulled task ${task.id}`);
-  const mesh = getMesh(meshId);
+  const mesh = getMeshWithCache(components, meshId);
   const node = mesh?.nodes.find((n) => n.id === nodeId);
   if (node?.daemonId && components.dispatchMeshCommand) {
     const isLocalNode = components.cliManager.adapters.has(sessionId);
@@ -26291,7 +26296,7 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
   return true;
 }
 function triggerMeshQueue(components, meshId) {
-  const mesh = getMesh(meshId);
+  const mesh = getMeshWithCache(components, meshId);
   if (!mesh) return;
   const cliInstances = components.instanceManager.getByCategory("cli");
   for (const inst of cliInstances) {
@@ -26549,7 +26554,7 @@ function setupMeshEventForwarding(components) {
     const meshIdFromRuntime = readNonEmptyString(settings.meshNodeFor);
     const isMeshDelegate = Boolean(meshIdFromRuntime || settings.launchedByCoordinator);
     if (!isMeshDelegate) return;
-    const mesh = meshIdFromRuntime ? getMesh(meshIdFromRuntime) : getMeshByRepo(workspace);
+    const mesh = meshIdFromRuntime ? getMeshWithCache(components, meshIdFromRuntime) : getMeshByRepo(workspace);
     const meshId = meshIdFromRuntime || readNonEmptyString(mesh?.id);
     if (!meshId) return;
     const targetNode = mesh?.nodes?.find((n) => n.workspace === workspace);
@@ -57461,6 +57466,42 @@ 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() || "";
+  let resolvedProviderType = args.providerType?.trim() || "";
+  if (!sessionId) {
+    try {
+      const sessionsResult = await transport.meshCommand(daemonId, "get_cli_sessions", {});
+      const payload = unwrapCommandPayload(sessionsResult);
+      const sessions = Array.isArray(payload?.sessions) ? payload.sessions : Array.isArray(sessionsResult?.sessions) ? sessionsResult.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[0];
+      if (targetSession?.sessionId || targetSession?.id) {
+        sessionId = targetSession.sessionId || targetSession.id;
+        if (!resolvedProviderType) resolvedProviderType = targetSession.providerType || targetSession.cliType || "";
+      }
+    } catch {
+    }
+  }
+  if (!sessionId) {
+    return { success: false, error: `No active session found on remote node '${node.id}'. Use mesh_launch_session first.` };
+  }
+  try {
+    await transport.meshCommand(daemonId, "agent_command", {
+      targetSessionId: sessionId,
+      cliType: resolvedProviderType,
+      action: "send_chat",
+      message: args.message
+    });
+    return { success: true, dispatched: true, sessionId };
+  } 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) {
@@ -57893,6 +57934,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) {
@@ -57921,12 +57975,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(() => {
       });
     }