@adhdev/daemon-core 0.9.77-rc.20 → 0.9.77-rc.22

package/dist/mesh/mesh-events.d.ts

@@ -8,17 +8,12 @@ export interface PendingMeshCoordinatorEvent {
 }
 /** Drain and return all pending coordinator events, clearing the queue. */
 export declare function drainPendingMeshCoordinatorEvents(): PendingMeshCoordinatorEvent[];
-export declare function tryAssignQueueTask(components: {
-    cliManager: any;
-}, meshId: string, nodeId: string, sessionId: string, providerType: string): boolean;
+export declare function tryAssignQueueTask(components: DaemonComponents, meshId: string, nodeId: string, sessionId: string, providerType: string): boolean;
 /**
  * Triggers a queue check for all nodes in the mesh.
  * Called when a new task is enqueued, in case nodes are already idle.
  */
-export declare function triggerMeshQueue(components: {
-    instanceManager: any;
-    cliManager: any;
-}, meshId: string): void;
+export declare function triggerMeshQueue(components: DaemonComponents, meshId: string): void;
 export declare function handleMeshForwardEvent(components: DaemonComponents, payload: Record<string, unknown>): {
     success: boolean;
     forwarded: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.77-rc.20",
+  "version": "0.9.77-rc.22",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/boot/daemon-lifecycle.ts

@@ -83,6 +83,9 @@ export interface DaemonInitConfig {
 
     /** Fired before send_chat is dispatched — used for turn snapshot hooks */
     onBeforeSendChat?: (params: { workspace: string; sessionId: string }) => void;
+
+    /** Relays a command to a remote mesh node daemon */
+    dispatchMeshCommand?: (daemonId: string, command: string, args: Record<string, unknown>) => Promise<any>;
 }
 
 // ─── Result ───
@@ -100,6 +103,7 @@ export interface DaemonComponents {
     sessionRegistry: SessionRegistry;
     detectedIdes: { value: IDEInfo[] };
     refreshProviderAvailability: (providerType?: string) => Promise<void>;
+    dispatchMeshCommand?: (daemonId: string, command: string, args: Record<string, unknown>) => Promise<any>;
 }
 
 export interface DaemonDevSupportOptions {
@@ -331,6 +335,7 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
         sessionRegistry,
         detectedIdes: detectedIdesRef,
         refreshProviderAvailability,
+        dispatchMeshCommand: config.dispatchMeshCommand,
     };
 
     // 11. Setup Mesh Event Forwarding

package/src/mesh/mesh-events.ts

@@ -3,7 +3,7 @@ import { getMesh, getMeshByRepo } from '../config/mesh-config.js';
 import { LOG } from '../logging/logger.js';
 import { appendLedgerEntry, getSessionRecoveryContext } from './mesh-ledger.js';
 import type { MeshLedgerKind, SessionRecoveryContext } from './mesh-ledger.js';
-import { claimNextTask, updateSessionTaskStatus, enqueueTask } from './mesh-work-queue.js';
+import { claimNextTask, updateSessionTaskStatus, enqueueTask, updateTaskStatus } from './mesh-work-queue.js';
 
 // ---------------------------------------------------------------------------
 // MCP coordinator pending-event queue
@@ -62,24 +62,49 @@ function formatCompletionMetadata(event: Record<string, unknown>): string {
 }
 
 export function tryAssignQueueTask(
-    components: { cliManager: any },
+    components: DaemonComponents,
     meshId: string,
     nodeId: string,
     sessionId: string,
     providerType: string
 ): boolean {
     const task = claimNextTask(meshId, nodeId, sessionId);
-    if (!task) return false;
+    if (!task) {
+        return false;
+    }
 
     LOG.info('MeshQueue', `Node ${nodeId} (${sessionId}) pulled task ${task.id}`);
+
+    // Check if the node is remote
+    const mesh = getMesh(meshId);
+    const node = mesh?.nodes.find((n: any) => n.id === nodeId);
     
+    // If the node is explicitly remote and we have a dispatch mechanism, route via P2P
+    if (node?.daemonId && components.dispatchMeshCommand) {
+        const isLocalNode = components.cliManager.adapters.has(sessionId);
+        if (!isLocalNode) {
+            components.dispatchMeshCommand(node.daemonId, 'agent_command', {
+                targetSessionId: sessionId,
+                cliType: providerType,
+                action: 'send_chat',
+                message: task.message,
+            }).catch((e: any) => {
+                LOG.error('MeshQueue', `Failed to dispatch task via P2P to remote node ${nodeId}: ${e?.message}`);
+                updateTaskStatus(meshId, task.id, 'failed');
+            });
+            return true;
+        }
+    }
+
+    // Local routing
     components.cliManager.handleCliCommand('agent_command', {
         targetSessionId: sessionId,
         cliType: providerType,
         action: 'send_chat',
         message: task.message,
     }).catch((e: any) => {
-        LOG.error('MeshQueue', `Failed to dispatch task to node ${nodeId}: ${e?.message}`);
+        LOG.error('MeshQueue', `Failed to dispatch task locally to node ${nodeId}: ${e?.message}`);
+        updateTaskStatus(meshId, task.id, 'failed');
     });
 
     return true;
@@ -89,7 +114,7 @@ export function tryAssignQueueTask(
  * Triggers a queue check for all nodes in the mesh.
  * Called when a new task is enqueued, in case nodes are already idle.
  */
-export function triggerMeshQueue(components: { instanceManager: any; cliManager: any }, meshId: string) {
+export function triggerMeshQueue(components: DaemonComponents, meshId: string) {
     const mesh = getMesh(meshId);
     if (!mesh) return;
 
@@ -165,6 +190,7 @@ function buildMeshSystemMessage(args: {
 function injectMeshSystemMessage(components: DaemonComponents, args: {
     meshId: string;
     sourceInstanceId?: string;
+    nodeId?: string;
     nodeLabel: string;
     event: string;
     metadataEvent: Record<string, unknown>;
@@ -172,7 +198,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
     // ── Task Queue & Ledger ──
     if (args.event === 'agent:generating_completed') {
         const sessionId = readNonEmptyString(args.metadataEvent.targetSessionId);
-        const nodeId = readNonEmptyString(args.metadataEvent.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
+        const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
         const providerType = readNonEmptyString(args.metadataEvent.providerType);
         
         if (sessionId) {
@@ -186,7 +212,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         }
     } else if (args.event === 'agent:ready') {
         const sessionId = readNonEmptyString(args.metadataEvent.targetSessionId);
-        const nodeId = readNonEmptyString(args.metadataEvent.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
+        const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
         const providerType = readNonEmptyString(args.metadataEvent.providerType);
         
         if (sessionId && nodeId && providerType) {
@@ -206,7 +232,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         try {
             appendLedgerEntry(args.meshId, {
                 kind: ledgerKind,
-                nodeId: readNonEmptyString(args.metadataEvent.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || undefined,
+                nodeId: readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || undefined,
                 sessionId: readNonEmptyString(args.metadataEvent.targetSessionId) || undefined,
                 providerType: readNonEmptyString(args.metadataEvent.providerType) || undefined,
                 payload: {
@@ -230,7 +256,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
 
             recoveryContext = getSessionRecoveryContext(args.meshId, {
                 sessionId: readNonEmptyString(args.metadataEvent.targetSessionId) || undefined,
-                nodeId: readNonEmptyString(args.metadataEvent.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || undefined,
+                nodeId: readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || undefined,
                 maxRetries,
             });
             recoveryContext.failedProviderType = readNonEmptyString(args.metadataEvent.providerType) || null;
@@ -338,6 +364,7 @@ export function handleMeshForwardEvent(components: DaemonComponents, payload: Re
     const nodeLabel = nodeId ? `Node '${nodeId}'` : workspace ? `Agent at ${workspace}` : 'Remote agent';
     return injectMeshSystemMessage(components, {
         meshId,
+        nodeId,
         nodeLabel,
         event: eventName,
         metadataEvent: {
@@ -385,6 +412,7 @@ export function setupMeshEventForwarding(components: DaemonComponents) {
         // Determine node label. Inline/cloud meshes may be unavailable here, so preserve runtime node id.
         const targetNode = mesh?.nodes?.find((n: any) => n.workspace === workspace);
         const runtimeNodeId = readNonEmptyString(settings.meshNodeId);
+        const resolvedNodeId = targetNode?.id || runtimeNodeId;
         const nodeLabel = targetNode
             ? `Node '${targetNode.id}'`
             : runtimeNodeId
@@ -394,6 +422,7 @@ export function setupMeshEventForwarding(components: DaemonComponents) {
         injectMeshSystemMessage(components, {
             meshId,
             sourceInstanceId: instanceId,
+            nodeId: resolvedNodeId,
             nodeLabel,
             event: event.event,
             metadataEvent: event,