@adhdev/daemon-core 0.9.76-rc.5 → 0.9.76-rc.50

package/src/commands/mesh-coordinator.ts

@@ -1,6 +1,8 @@
-import { existsSync, realpathSync } from 'node:fs'
+import { execFileSync } from 'node:child_process'
+import { existsSync, readdirSync, realpathSync } from 'node:fs'
 import { createRequire } from 'node:module'
-import { dirname, join, resolve } from 'node:path'
+import * as os from 'node:os'
+import { dirname, isAbsolute, join, resolve } from 'node:path'
 import type { ProviderModule, MeshCoordinatorMcpConfigFormat } from '../providers/contracts.js'
 
 export interface MeshCoordinatorMcpServerLaunch {
@@ -32,6 +34,7 @@ export type MeshCoordinatorSetup =
 
 export interface ResolveMeshCoordinatorSetupOptions {
   provider?: ProviderModule | null
+  cliType?: string
   meshId: string
   workspace: string
   adhdevMcpCommand?: string
@@ -41,6 +44,58 @@ export interface ResolveMeshCoordinatorSetupOptions {
 
 const DEFAULT_SERVER_NAME = 'adhdev-mesh'
 const DEFAULT_ADHDEV_MCP_COMMAND = 'adhdev-mcp'
+const HERMES_CLI_TYPE = 'hermes-cli'
+const HERMES_MCP_CONFIG_PATH = '~/.hermes/config.yaml'
+
+function isHermesProvider(provider: ProviderModule | null | undefined, cliType?: string): boolean {
+  const type = cliType?.trim() || provider?.type?.trim() || ''
+  return type === HERMES_CLI_TYPE
+}
+
+function resolveHermesMeshCoordinatorSetup(options: ResolveMeshCoordinatorSetupOptions): MeshCoordinatorSetup {
+  const mcpServer = resolveAdhdevMcpServerLaunch({
+    meshId: options.meshId,
+    nodeExecutable: options.nodeExecutable,
+    adhdevMcpEntryPath: options.adhdevMcpEntryPath,
+  })
+  if (!mcpServer) {
+    return {
+      kind: 'unsupported',
+      reason: 'Could not resolve the ADHDev MCP server entrypoint and a Node runtime with WebSocket support for daemon IPC mode',
+    }
+  }
+  const configPath = resolveMcpConfigPath(HERMES_MCP_CONFIG_PATH, options.workspace)
+  if (!configPath.trim()) {
+    return createHermesManualMeshCoordinatorSetup(options.meshId, options.workspace)
+  }
+  return {
+    kind: 'auto_import',
+    serverName: DEFAULT_SERVER_NAME,
+    configPath,
+    configFormat: 'hermes_config_yaml',
+    mcpServer,
+  }
+}
+
+export function createHermesManualMeshCoordinatorSetup(meshId: string, workspace: string): MeshCoordinatorSetup {
+  return {
+    kind: 'manual',
+    serverName: DEFAULT_SERVER_NAME,
+    configFormat: 'hermes_config_yaml',
+    configPathCommand: HERMES_MCP_CONFIG_PATH,
+    requiresRestart: true,
+    instructions: 'Hermes CLI does not auto-import repo-local .mcp.json. Add this MCP server to Hermes config under mcp_servers, then start a fresh Hermes session.',
+    template: renderMeshCoordinatorTemplate(
+      'mcp_servers:\n  {{serverName}}:\n    command: {{adhdevMcpCommand}}\n    args:\n      - --repo-mesh\n      - {{meshId}}\n    enabled: true\n',
+      {
+        meshId,
+        workspace,
+        serverName: DEFAULT_SERVER_NAME,
+        adhdevMcpCommand: DEFAULT_ADHDEV_MCP_COMMAND,
+      },
+    ),
+  }
+}
 
 export function resolveMeshCoordinatorSetup(options: ResolveMeshCoordinatorSetupOptions): MeshCoordinatorSetup {
   const { provider, meshId, workspace } = options
@@ -52,6 +107,10 @@ export function resolveMeshCoordinatorSetup(options: ResolveMeshCoordinatorSetup
     }
   }
 
+  if (isHermesProvider(provider, options.cliType)) {
+    return resolveHermesMeshCoordinatorSetup(options)
+  }
+
   const mcpConfig = config.mcpConfig
   if (!mcpConfig || mcpConfig.mode === 'none') {
     return {
@@ -74,13 +133,13 @@ export function resolveMeshCoordinatorSetup(options: ResolveMeshCoordinatorSetup
     if (!mcpServer) {
       return {
         kind: 'unsupported',
-        reason: 'Could not resolve the ADHDev MCP server entrypoint without relying on a PATH bin shim',
+        reason: 'Could not resolve the ADHDev MCP server entrypoint and a Node runtime with WebSocket support for daemon IPC mode',
       }
     }
     return {
       kind: 'auto_import',
       serverName,
-      configPath: join(workspace, path),
+      configPath: resolveMcpConfigPath(path, workspace),
       configFormat: mcpConfig.format,
       mcpServer,
     }
@@ -118,6 +177,14 @@ function renderMeshCoordinatorTemplate(template: string, values: Record<string,
   return template.replace(/\{\{\s*(meshId|workspace|serverName|adhdevMcpCommand)\s*\}\}/g, (_, key: string) => values[key] || '')
 }
 
+function resolveMcpConfigPath(configPath: string, workspace: string): string {
+  const trimmed = configPath.trim()
+  if (trimmed === '~') return os.homedir()
+  if (trimmed.startsWith('~/')) return join(os.homedir(), trimmed.slice(2))
+  if (isAbsolute(trimmed)) return trimmed
+  return join(workspace, trimmed)
+}
+
 function resolveAdhdevMcpServerLaunch(options: {
   meshId: string
   nodeExecutable?: string
@@ -125,9 +192,85 @@ function resolveAdhdevMcpServerLaunch(options: {
 }): MeshCoordinatorMcpServerLaunch | null {
   const entryPath = resolveAdhdevMcpEntryPath(options.adhdevMcpEntryPath)
   if (!entryPath) return null
+  const nodeExecutable = resolveMcpNodeExecutable(options.nodeExecutable)
+  if (!nodeExecutable) return null
   return {
-    command: options.nodeExecutable?.trim() || process.execPath,
-    args: [entryPath, '--repo-mesh', options.meshId],
+    command: nodeExecutable,
+    args: [entryPath, '--mode', 'ipc', '--repo-mesh', options.meshId],
+  }
+}
+
+function resolveMcpNodeExecutable(explicitExecutable?: string): string | null {
+  const explicit = explicitExecutable?.trim()
+  if (explicit) return explicit
+
+  const candidates: string[] = []
+  const addCandidate = (candidate?: string | null) => {
+    const trimmed = candidate?.trim()
+    if (!trimmed) return
+    const normalized = normalizeExistingPath(trimmed) || trimmed
+    if (!candidates.includes(normalized)) candidates.push(normalized)
+  }
+
+  addCandidate(process.env.ADHDEV_MCP_NODE_EXECUTABLE)
+  addCandidate(process.env.ADHDEV_NODE_EXECUTABLE)
+  addCandidate(process.env.npm_node_execpath)
+  addNodeCandidatesFromPath(process.env.PATH, addCandidate)
+  addNodeCandidatesFromNvm(os.homedir(), addCandidate)
+  addCandidate('/opt/homebrew/bin/node')
+  addCandidate('/usr/local/bin/node')
+  addCandidate('/usr/bin/node')
+  addCandidate(process.execPath)
+
+  for (const candidate of candidates) {
+    if (nodeRuntimeSupportsWebSocket(candidate)) return candidate
+  }
+  return null
+}
+
+function addNodeCandidatesFromPath(pathValue: string | undefined, addCandidate: (candidate?: string | null) => void) {
+  for (const entry of (pathValue || '').split(':')) {
+    const dir = entry.trim()
+    if (!dir) continue
+    addCandidate(join(dir, 'node'))
+  }
+}
+
+function addNodeCandidatesFromNvm(homeDir: string, addCandidate: (candidate?: string | null) => void) {
+  const versionsDir = join(homeDir, '.nvm', 'versions', 'node')
+  try {
+    const versionDirs = readdirSync(versionsDir, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name)
+      .sort(compareNodeVersionNamesDescending)
+    for (const versionDir of versionDirs) {
+      addCandidate(join(versionsDir, versionDir, 'bin', 'node'))
+    }
+  } catch {
+    // nvm is optional; PATH and process.execPath candidates still cover normal installs.
+  }
+}
+
+function compareNodeVersionNamesDescending(a: string, b: string): number {
+  const parse = (value: string) => value.replace(/^v/, '').split('.').map((part) => Number.parseInt(part, 10) || 0)
+  const left = parse(a)
+  const right = parse(b)
+  for (let i = 0; i < Math.max(left.length, right.length); i++) {
+    const diff = (right[i] || 0) - (left[i] || 0)
+    if (diff !== 0) return diff
+  }
+  return b.localeCompare(a)
+}
+
+function nodeRuntimeSupportsWebSocket(nodeExecutable: string): boolean {
+  try {
+    execFileSync(nodeExecutable, ['-e', "process.exit(typeof WebSocket === 'function' ? 0 : 42)"], {
+      stdio: 'ignore',
+      timeout: 3000,
+    })
+    return true
+  } catch {
+    return false
   }
 }
 

package/src/commands/router.d.ts

@@ -21,6 +21,7 @@ export interface SessionHostControlPlane {
     }): Promise<any>;
     listSessions(): Promise<any[]>;
     stopSession(sessionId: string): Promise<any>;
+    deleteSession(sessionId: string, opts?: { force?: boolean }): Promise<any>;
     resumeSession(sessionId: string): Promise<any>;
     restartSession(sessionId: string): Promise<any>;
     sendSignal(sessionId: string, signal: string): Promise<any>;