@adhdev/daemon-core 0.9.71 → 0.9.73

package/node_modules/@adhdev/session-host-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.9.71",
+  "version": "0.9.73",
   "description": "ADHDev local session host core \u2014 session registry, protocol, buffers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.71",
+  "version": "0.9.73",
   "description": "ADHDev daemon core \u2014 CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/commands/mesh-coordinator.ts

@@ -1,12 +1,20 @@
-import { join } from 'path'
+import { existsSync, realpathSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { dirname, join, resolve } from 'node:path'
 import type { ProviderModule, MeshCoordinatorMcpConfigFormat } from '../providers/contracts.js'
 
+export interface MeshCoordinatorMcpServerLaunch {
+  command: string
+  args: string[]
+}
+
 export type MeshCoordinatorSetup =
   | {
       kind: 'auto_import'
       serverName: string
       configPath: string
       configFormat?: MeshCoordinatorMcpConfigFormat
+      mcpServer: MeshCoordinatorMcpServerLaunch
     }
   | {
       kind: 'manual'
@@ -27,6 +35,8 @@ export interface ResolveMeshCoordinatorSetupOptions {
   meshId: string
   workspace: string
   adhdevMcpCommand?: string
+  adhdevMcpEntryPath?: string
+  nodeExecutable?: string
 }
 
 const DEFAULT_SERVER_NAME = 'adhdev-mesh'
@@ -56,11 +66,23 @@ export function resolveMeshCoordinatorSetup(options: ResolveMeshCoordinatorSetup
     if (!path) {
       return { kind: 'unsupported', reason: 'Provider auto-import MCP config is missing a config path' }
     }
+    const mcpServer = resolveAdhdevMcpServerLaunch({
+      meshId,
+      nodeExecutable: options.nodeExecutable,
+      adhdevMcpEntryPath: options.adhdevMcpEntryPath,
+    })
+    if (!mcpServer) {
+      return {
+        kind: 'unsupported',
+        reason: 'Could not resolve the ADHDev MCP server entrypoint without relying on a PATH bin shim',
+      }
+    }
     return {
       kind: 'auto_import',
       serverName,
       configPath: join(workspace, path),
       configFormat: mcpConfig.format,
+      mcpServer,
     }
   }
 
@@ -95,3 +117,62 @@ export function resolveMeshCoordinatorSetup(options: ResolveMeshCoordinatorSetup
 function renderMeshCoordinatorTemplate(template: string, values: Record<string, string>): string {
   return template.replace(/\{\{\s*(meshId|workspace|serverName|adhdevMcpCommand)\s*\}\}/g, (_, key: string) => values[key] || '')
 }
+
+function resolveAdhdevMcpServerLaunch(options: {
+  meshId: string
+  nodeExecutable?: string
+  adhdevMcpEntryPath?: string
+}): MeshCoordinatorMcpServerLaunch | null {
+  const entryPath = resolveAdhdevMcpEntryPath(options.adhdevMcpEntryPath)
+  if (!entryPath) return null
+  return {
+    command: options.nodeExecutable?.trim() || process.execPath,
+    args: [entryPath, '--repo-mesh', options.meshId],
+  }
+}
+
+function resolveAdhdevMcpEntryPath(explicitPath?: string): string | null {
+  const explicit = explicitPath?.trim()
+  if (explicit) return normalizeExistingPath(explicit) || explicit
+
+  const envPath = process.env.ADHDEV_MCP_SERVER_PATH?.trim()
+  if (envPath) return normalizeExistingPath(envPath) || envPath
+
+  const candidates: string[] = []
+  const addCandidate = (candidate: string) => {
+    if (!candidates.includes(candidate)) candidates.push(candidate)
+  }
+  const addPackagedCandidates = (baseFile?: string) => {
+    if (!baseFile) return
+    const realBase = normalizeExistingPath(baseFile) || baseFile
+    const dir = dirname(realBase)
+    addCandidate(resolve(dir, '../vendor/mcp-server/index.js'))
+    addCandidate(resolve(dir, '../../vendor/mcp-server/index.js'))
+    addCandidate(resolve(dir, '../../../vendor/mcp-server/index.js'))
+  }
+
+  addPackagedCandidates(process.argv[1])
+
+  for (const candidate of candidates) {
+    const normalized = normalizeExistingPath(candidate)
+    if (normalized) return normalized
+  }
+
+  try {
+    const requireBase = process.argv[1] ? (normalizeExistingPath(process.argv[1]) || process.argv[1]) : join(process.cwd(), 'adhdev-daemon.js')
+    const req = createRequire(requireBase)
+    const resolvedModule = req.resolve('@adhdev/mcp-server')
+    return normalizeExistingPath(resolvedModule) || resolvedModule
+  } catch {
+    return null
+  }
+}
+
+function normalizeExistingPath(filePath: string): string | null {
+  try {
+    if (!existsSync(filePath)) return null
+    return realpathSync.native(filePath)
+  } catch {
+    return null
+  }
+}

package/src/commands/router.ts

@@ -1019,7 +1019,25 @@ export class DaemonCommandRouter {
                     if (!mesh) return { success: false, error: 'Mesh not found' };
                     if (!Array.isArray(mesh.nodes) || mesh.nodes.length === 0) return { success: false, error: 'No nodes in mesh' };
 
-                    const workspace = mesh.nodes[0].workspace;
+                    const requestedCoordinatorNodeId = typeof args?.coordinatorNodeId === 'string'
+                        ? args.coordinatorNodeId.trim()
+                        : '';
+                    const preferredCoordinatorNodeId = requestedCoordinatorNodeId
+                        || (typeof mesh.coordinator?.preferredNodeId === 'string' ? mesh.coordinator.preferredNodeId.trim() : '');
+                    const coordinatorNode = preferredCoordinatorNodeId
+                        ? mesh.nodes.find((node: any) => node?.id === preferredCoordinatorNodeId || node?.nodeId === preferredCoordinatorNodeId)
+                        : mesh.nodes[0];
+                    if (!coordinatorNode) {
+                        return {
+                            success: false,
+                            code: 'mesh_coordinator_node_not_found',
+                            error: `Coordinator node ${preferredCoordinatorNodeId} was not found in mesh`,
+                            meshId,
+                            cliType,
+                        };
+                    }
+                    const workspace = typeof coordinatorNode.workspace === 'string' ? coordinatorNode.workspace.trim() : '';
+                    if (!workspace) return { success: false, error: 'Coordinator node workspace required', meshId, cliType };
                     const providerMeta = this.deps.providerLoader.resolve?.(cliType) || this.deps.providerLoader.getMeta(cliType);
                     const coordinatorSetup = resolveMeshCoordinatorSetup({
                         provider: providerMeta,
@@ -1081,8 +1099,8 @@ export class DaemonCommandRouter {
                         mcpServers: {
                             ...(existingMcpConfig.mcpServers || {}),
                             [coordinatorSetup.serverName]: {
-                                command: 'adhdev-mcp',
-                                args: ['--repo-mesh', meshId],
+                                command: coordinatorSetup.mcpServer.command,
+                                args: coordinatorSetup.mcpServer.args,
                             },
                         },
                     };