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

package/dist/commands/mesh-coordinator.d.ts

@@ -23,10 +23,12 @@ export type MeshCoordinatorSetup = {
 };
 export interface ResolveMeshCoordinatorSetupOptions {
     provider?: ProviderModule | null;
+    cliType?: string;
     meshId: string;
     workspace: string;
     adhdevMcpCommand?: string;
     adhdevMcpEntryPath?: string;
     nodeExecutable?: string;
 }
+export declare function createHermesManualMeshCoordinatorSetup(meshId: string, workspace: string): MeshCoordinatorSetup;
 export declare function resolveMeshCoordinatorSetup(options: ResolveMeshCoordinatorSetupOptions): MeshCoordinatorSetup;

package/dist/index.js

@@ -20208,6 +20208,55 @@ var os17 = __toESM(require("os"));
 var import_node_path = require("path");
 var DEFAULT_SERVER_NAME = "adhdev-mesh";
 var DEFAULT_ADHDEV_MCP_COMMAND = "adhdev-mcp";
+var HERMES_CLI_TYPE = "hermes-cli";
+var HERMES_MCP_CONFIG_PATH = "~/.hermes/config.yaml";
+function isHermesProvider(provider, cliType) {
+  const type = cliType?.trim() || provider?.type?.trim() || "";
+  return type === HERMES_CLI_TYPE;
+}
+function resolveHermesMeshCoordinatorSetup(options) {
+  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
+  };
+}
+function createHermesManualMeshCoordinatorSetup(meshId, workspace) {
+  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
+      }
+    )
+  };
+}
 function resolveMeshCoordinatorSetup(options) {
   const { provider, meshId, workspace } = options;
   const config = provider?.meshCoordinator;
@@ -20217,6 +20266,9 @@ function resolveMeshCoordinatorSetup(options) {
       reason: config?.reason || "Provider does not declare Repo Mesh coordinator support"
     };
   }
+  if (isHermesProvider(provider, options.cliType)) {
+    return resolveHermesMeshCoordinatorSetup(options);
+  }
   const mcpConfig = config.mcpConfig;
   if (!mcpConfig || mcpConfig.mode === "none") {
     return {
@@ -22036,6 +22088,7 @@ var DaemonCommandRouter = class {
           const providerMeta = this.deps.providerLoader.resolve?.(cliType) || this.deps.providerLoader.getMeta(cliType);
           const coordinatorSetup = resolveMeshCoordinatorSetup({
             provider: providerMeta,
+            cliType,
             meshId,
             workspace
           });
@@ -22089,7 +22142,34 @@ var DaemonCommandRouter = class {
           const { existsSync: existsSync23, readFileSync: readFileSync15, writeFileSync: writeFileSync12, copyFileSync: copyFileSync3, mkdirSync: mkdirSync14 } = await import("fs");
           const { dirname: dirname9 } = await import("path");
           const mcpConfigPath = coordinatorSetup.configPath;
-          mkdirSync14(dirname9(mcpConfigPath), { recursive: true });
+          const hermesManualFallback = cliType === "hermes-cli" && configFormat === "hermes_config_yaml" ? createHermesManualMeshCoordinatorSetup(meshId, workspace) : null;
+          const returnManualFallback = (message) => ({
+            success: false,
+            code: "mesh_coordinator_manual_mcp_setup_required",
+            error: message,
+            meshId,
+            cliType,
+            workspace,
+            meshCoordinatorSetup: hermesManualFallback
+          });
+          const mcpServerEntry = {
+            command: coordinatorSetup.mcpServer.command,
+            args: coordinatorSetup.mcpServer.args
+          };
+          if (args?.inlineMesh) {
+            mcpServerEntry.env = {
+              ADHDEV_INLINE_MESH: JSON.stringify(mesh),
+              ADHDEV_MCP_TRANSPORT: "ipc"
+            };
+          }
+          try {
+            mkdirSync14(dirname9(mcpConfigPath), { recursive: true });
+          } catch (error) {
+            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 };
+          }
           const hadExistingMcpConfig = existsSync23(mcpConfigPath);
           let existingMcpConfig = {};
           if (hadExistingMcpConfig) {
@@ -22105,16 +22185,6 @@ var DaemonCommandRouter = class {
               };
             }
           }
-          const mcpServerEntry = {
-            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 = {
@@ -22124,7 +22194,14 @@ var DaemonCommandRouter = class {
               [coordinatorSetup.serverName]: mcpServerEntry
             }
           };
-          writeFileSync12(mcpConfigPath, serializeMeshCoordinatorMcpConfig(mcpConfig, configFormat), "utf-8");
+          try {
+            writeFileSync12(mcpConfigPath, serializeMeshCoordinatorMcpConfig(mcpConfig, configFormat), "utf-8");
+          } catch (error) {
+            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 = [];
           const launchEnv = {};