@adhdev/daemon-core 0.9.76-rc.19 → 0.9.76-rc.20

package/package.json

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

package/src/commands/mesh-coordinator.ts

@@ -34,6 +34,7 @@ export type MeshCoordinatorSetup =
 
 export interface ResolveMeshCoordinatorSetupOptions {
   provider?: ProviderModule | null
+  cliType?: string
   meshId: string
   workspace: string
   adhdevMcpCommand?: string
@@ -43,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
@@ -54,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 {

package/src/commands/router.ts

@@ -34,7 +34,7 @@ import * as yaml from 'js-yaml';
 import { getRecentLogs, LOG_PATH } from '../logging/logger.js';
 import { createInteractionId, getRecentDebugTrace, recordDebugTrace } from '../logging/debug-trace.js';
 import { getSessionHostSurfaceKind, partitionSessionHostRecords } from '../session-host/runtime-surface.js';
-import { resolveMeshCoordinatorSetup } from './mesh-coordinator.js';
+import { createHermesManualMeshCoordinatorSetup, resolveMeshCoordinatorSetup } from './mesh-coordinator.js';
 import { buildSessionEntries } from '../status/builders.js';
 import { buildMachineInfo, buildStatusSnapshot } from '../status/snapshot.js';
 import { getSessionCompletionMarker } from '../status/snapshot.js';
@@ -1227,6 +1227,7 @@ export class DaemonCommandRouter {
                     const providerMeta = this.deps.providerLoader.resolve?.(cliType) || this.deps.providerLoader.getMeta(cliType);
                     const coordinatorSetup = resolveMeshCoordinatorSetup({
                         provider: providerMeta,
+                        cliType,
                         meshId,
                         workspace,
                     });
@@ -1289,7 +1290,41 @@ export class DaemonCommandRouter {
                     const { existsSync, readFileSync, writeFileSync, copyFileSync, mkdirSync } = await import('fs');
                     const { dirname } = await import('path');
                     const mcpConfigPath = coordinatorSetup.configPath;
-                    mkdirSync(dirname(mcpConfigPath), { recursive: true });
+                    const hermesManualFallback = cliType === 'hermes-cli' && configFormat === 'hermes_config_yaml'
+                        ? createHermesManualMeshCoordinatorSetup(meshId, workspace)
+                        : null;
+                    const returnManualFallback = (message: string) => ({
+                        success: false,
+                        code: 'mesh_coordinator_manual_mcp_setup_required',
+                        error: message,
+                        meshId,
+                        cliType,
+                        workspace,
+                        meshCoordinatorSetup: hermesManualFallback,
+                    });
+
+                    // Merge ADHDev mesh server into existing config.
+                    // Pass full mesh data as env var so the MCP server can bootstrap
+                    // without depending on meshes.json or a running daemon.
+                    const mcpServerEntry: Record<string, any> = {
+                        command: coordinatorSetup.mcpServer.command,
+                        args: coordinatorSetup.mcpServer.args,
+                    };
+                    if (args?.inlineMesh) {
+                        mcpServerEntry.env = {
+                            ADHDEV_INLINE_MESH: JSON.stringify(mesh),
+                            ADHDEV_MCP_TRANSPORT: 'ipc',
+                        };
+                    }
+
+                    try {
+                        mkdirSync(dirname(mcpConfigPath), { recursive: true });
+                    } catch (error: any) {
+                        const message = `Could not prepare MCP config path for automatic setup: ${error?.message || error}`;
+                        LOG.error('MeshCoordinator', message);
+                        if (hermesManualFallback) return returnManualFallback(message);
+                        return { success: false, code: 'mesh_coordinator_config_write_failed', error: message, meshId, cliType, workspace };
+                    }
 
                     // Backup existing MCP config if present.
                     const hadExistingMcpConfig = existsSync(mcpConfigPath);
@@ -1308,19 +1343,6 @@ export class DaemonCommandRouter {
                         }
                     }
 
-                    // Merge ADHDev mesh server into existing config.
-                    // Pass full mesh data as env var so the MCP server can bootstrap
-                    // without depending on meshes.json or a running daemon.
-                    const mcpServerEntry: Record<string, any> = {
-                        command: coordinatorSetup.mcpServer.command,
-                        args: coordinatorSetup.mcpServer.args,
-                    };
-                    if (args?.inlineMesh) {
-                        mcpServerEntry.env = {
-                            ADHDEV_INLINE_MESH: JSON.stringify(mesh),
-                            ADHDEV_MCP_TRANSPORT: 'ipc',
-                        };
-                    }
                     const mcpServersKey = getMcpServersKey(configFormat);
                     const existingServers = existingMcpConfig[mcpServersKey];
                     const mcpConfig = {
@@ -1330,7 +1352,14 @@ export class DaemonCommandRouter {
                             [coordinatorSetup.serverName]: mcpServerEntry,
                         },
                     };
-                    writeFileSync(mcpConfigPath, serializeMeshCoordinatorMcpConfig(mcpConfig, configFormat), 'utf-8');
+                    try {
+                        writeFileSync(mcpConfigPath, serializeMeshCoordinatorMcpConfig(mcpConfig, configFormat), 'utf-8');
+                    } catch (error: any) {
+                        const message = `Could not write MCP config for automatic setup: ${error?.message || error}`;
+                        LOG.error('MeshCoordinator', message);
+                        if (hermesManualFallback) return returnManualFallback(message);
+                        return { success: false, code: 'mesh_coordinator_config_write_failed', error: message, meshId, cliType, workspace };
+                    }
                     LOG.info('MeshCoordinator', `Wrote ${mcpConfigPath} with ${coordinatorSetup.serverName} server`);
 
                     const cliArgs: string[] = [];